Initial checkin of GCC 4.9.0 from trunk (r208799).

Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba

710 files changed, 253655 insertions, 0 deletions

diff --git a/gcc-4.9/libstdc++-v3/include/Makefile.am b/gcc-4.9/libstdc++-v3/include/Makefile.am
new file mode 100644
index 0000000..85b0f31
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/Makefile.am
@@ -0,0 +1,1348 @@
+## Makefile for the include subdirectory of the GNU C++ Standard library.
+##
+## Copyright (C) 2001-2014 Free Software Foundation, Inc.
+##
+## This file is part of the libstdc++ version 3 distribution.
+## Process this file with automake to produce Makefile.in.
+
+## This file is part of the GNU ISO C++ Library.  This library is free
+## software; you can redistribute it and/or modify it under the
+## terms of the GNU General Public License as published by the
+## Free Software Foundation; either version 3, or (at your option)
+## any later version.
+
+## This library is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+## You should have received a copy of the GNU General Public License along
+## with this library; see the file COPYING3.  If not see
+## <http://www.gnu.org/licenses/>.
+
+include $(top_srcdir)/fragment.am
+
+# Standard C++ includes.
+std_srcdir = ${glibcxx_srcdir}/include/std
+std_builddir = .
+std_headers = \
+	${std_srcdir}/algorithm \
+	${std_srcdir}/array \
+	${std_srcdir}/atomic \
+	${std_srcdir}/bitset \
+	${std_srcdir}/chrono \
+	${std_srcdir}/complex \
+	${std_srcdir}/condition_variable \
+	${std_srcdir}/deque \
+	${std_srcdir}/forward_list \
+	${std_srcdir}/fstream \
+	${std_srcdir}/functional \
+	${std_srcdir}/future \
+	${std_srcdir}/iomanip \
+	${std_srcdir}/ios \
+	${std_srcdir}/iosfwd \
+	${std_srcdir}/iostream \
+	${std_srcdir}/istream \
+	${std_srcdir}/iterator \
+	${std_srcdir}/limits \
+	${std_srcdir}/list \
+	${std_srcdir}/locale \
+	${std_srcdir}/map \
+	${std_srcdir}/memory \
+	${std_srcdir}/mutex \
+	${std_srcdir}/numeric \
+	${std_srcdir}/ostream \
+	${std_srcdir}/queue \
+	${std_srcdir}/random \
+	${std_srcdir}/ratio \
+	${std_srcdir}/regex \
+	${std_srcdir}/scoped_allocator \
+	${std_srcdir}/set \
+	${std_srcdir}/shared_mutex \
+	${std_srcdir}/sstream \
+	${std_srcdir}/stack \
+	${std_srcdir}/stdexcept \
+	${std_srcdir}/streambuf \
+	${std_srcdir}/string \
+	${std_srcdir}/system_error \
+	${std_srcdir}/thread \
+	${std_srcdir}/tuple \
+	${std_srcdir}/typeindex \
+	${std_srcdir}/type_traits \
+	${std_srcdir}/unordered_map \
+	${std_srcdir}/unordered_set \
+	${std_srcdir}/utility \
+	${std_srcdir}/valarray \
+	${std_srcdir}/vector
+
+bits_srcdir = ${glibcxx_srcdir}/include/bits
+bits_builddir = ./bits
+bits_headers = \
+	${bits_srcdir}/algorithmfwd.h \
+	${bits_srcdir}/alloc_traits.h \
+	${bits_srcdir}/allocator.h \
+	${bits_srcdir}/atomic_base.h \
+	${bits_srcdir}/basic_ios.h \
+	${bits_srcdir}/basic_ios.tcc \
+	${bits_srcdir}/basic_string.h \
+	${bits_srcdir}/basic_string.tcc \
+	${bits_srcdir}/boost_concept_check.h \
+	${bits_srcdir}/c++0x_warning.h \
+	${bits_srcdir}/c++14_warning.h \
+	${bits_srcdir}/char_traits.h \
+	${bits_srcdir}/codecvt.h \
+	${bits_srcdir}/concept_check.h \
+	${bits_srcdir}/cpp_type_traits.h \
+	${bits_srcdir}/deque.tcc \
+	${bits_srcdir}/enable_special_members.h \
+	${bits_srcdir}/forward_list.h \
+	${bits_srcdir}/forward_list.tcc \
+	${bits_srcdir}/fstream.tcc \
+	${bits_srcdir}/functexcept.h \
+	${bits_srcdir}/functional_hash.h \
+	${bits_srcdir}/gslice.h \
+	${bits_srcdir}/gslice_array.h \
+	${bits_srcdir}/hashtable.h \
+	${bits_srcdir}/hashtable_policy.h \
+	${bits_srcdir}/indirect_array.h \
+	${bits_srcdir}/ios_base.h \
+	${bits_srcdir}/istream.tcc \
+	${bits_srcdir}/list.tcc \
+	${bits_srcdir}/locale_classes.h \
+	${bits_srcdir}/locale_classes.tcc \
+	${bits_srcdir}/locale_facets.h \
+	${bits_srcdir}/locale_facets.tcc \
+	${bits_srcdir}/locale_facets_nonio.h \
+	${bits_srcdir}/locale_facets_nonio.tcc \
+	${bits_srcdir}/localefwd.h \
+	${bits_srcdir}/mask_array.h \
+	${bits_srcdir}/memoryfwd.h \
+	${bits_srcdir}/move.h \
+	${bits_srcdir}/ostream.tcc \
+	${bits_srcdir}/ostream_insert.h \
+	${bits_srcdir}/parse_numbers.h \
+	${bits_srcdir}/postypes.h \
+	${bits_srcdir}/predefined_ops.h \
+	${bits_srcdir}/ptr_traits.h \
+	${bits_srcdir}/random.h \
+	${bits_srcdir}/random.tcc \
+	${bits_srcdir}/range_access.h \
+	${bits_srcdir}/regex.h \
+	${bits_srcdir}/regex.tcc \
+	${bits_srcdir}/regex_constants.h \
+	${bits_srcdir}/regex_error.h \
+	${bits_srcdir}/regex_scanner.h \
+	${bits_srcdir}/regex_scanner.tcc \
+	${bits_srcdir}/regex_automaton.h \
+	${bits_srcdir}/regex_automaton.tcc \
+	${bits_srcdir}/regex_compiler.h \
+	${bits_srcdir}/regex_compiler.tcc \
+	${bits_srcdir}/regex_executor.h \
+	${bits_srcdir}/regex_executor.tcc \
+	${bits_srcdir}/stream_iterator.h \
+	${bits_srcdir}/streambuf_iterator.h \
+	${bits_srcdir}/shared_ptr.h \
+	${bits_srcdir}/shared_ptr_base.h \
+	${bits_srcdir}/slice_array.h \
+	${bits_srcdir}/sstream.tcc \
+	${bits_srcdir}/stl_algo.h \
+	${bits_srcdir}/stl_algobase.h \
+	${bits_srcdir}/stl_bvector.h \
+	${bits_srcdir}/stl_construct.h \
+	${bits_srcdir}/stl_deque.h \
+	${bits_srcdir}/stl_function.h \
+	${bits_srcdir}/stl_heap.h \
+	${bits_srcdir}/stl_iterator.h \
+	${bits_srcdir}/stl_iterator_base_funcs.h \
+	${bits_srcdir}/stl_iterator_base_types.h \
+	${bits_srcdir}/stl_list.h \
+	${bits_srcdir}/stl_map.h \
+	${bits_srcdir}/stl_multimap.h \
+	${bits_srcdir}/stl_multiset.h \
+	${bits_srcdir}/stl_numeric.h \
+	${bits_srcdir}/stl_pair.h \
+	${bits_srcdir}/stl_queue.h \
+	${bits_srcdir}/stl_raw_storage_iter.h \
+	${bits_srcdir}/stl_relops.h \
+	${bits_srcdir}/stl_set.h \
+	${bits_srcdir}/stl_stack.h \
+	${bits_srcdir}/stl_tempbuf.h \
+	${bits_srcdir}/stl_tree.h \
+	${bits_srcdir}/stl_uninitialized.h \
+	${bits_srcdir}/stl_vector.h \
+	${bits_srcdir}/streambuf.tcc \
+	${bits_srcdir}/stringfwd.h \
+	${bits_srcdir}/unique_ptr.h \
+	${bits_srcdir}/unordered_map.h \
+	${bits_srcdir}/unordered_set.h \
+	${bits_srcdir}/uses_allocator.h \
+	${bits_srcdir}/valarray_array.h \
+	${bits_srcdir}/valarray_array.tcc \
+	${bits_srcdir}/valarray_before.h \
+	${bits_srcdir}/valarray_after.h \
+	${bits_srcdir}/vector.tcc
+
+bits_host_headers = \
+	${glibcxx_srcdir}/${CPU_OPT_BITS_RANDOM}
+
+bits_sup_srcdir = ${glibcxx_srcdir}/libsupc++
+bits_sup_headers = \
+	${bits_sup_srcdir}/atomic_lockfree_defines.h \
+	${bits_sup_srcdir}/cxxabi_forced.h \
+	${bits_sup_srcdir}/exception_defines.h \
+	${bits_sup_srcdir}/exception_ptr.h \
+	${bits_sup_srcdir}/hash_bytes.h \
+	${bits_sup_srcdir}/nested_exception.h
+
+backward_srcdir = ${glibcxx_srcdir}/include/backward
+backward_builddir = ./backward
+backward_headers = \
+	${backward_srcdir}/auto_ptr.h \
+	${backward_srcdir}/backward_warning.h \
+	${backward_srcdir}/binders.h \
+	${backward_srcdir}/hash_map \
+	${backward_srcdir}/hash_set \
+	${backward_srcdir}/hash_fun.h \
+	${backward_srcdir}/hashtable.h \
+	${backward_srcdir}/strstream
+
+pb_srcdir = ${glibcxx_srcdir}/include/ext/pb_ds
+pb_builddir = ./ext/pb_ds
+
+pb_subdirs = \
+	${pb_builddir}/detail \
+	${pb_builddir}/detail/pairing_heap_ \
+	${pb_builddir}/detail/splay_tree_ \
+	${pb_builddir}/detail/list_update_map_ \
+	${pb_builddir}/detail/branch_policy \
+	${pb_builddir}/detail/trie_policy \
+	${pb_builddir}/detail/gp_hash_table_map_ \
+	${pb_builddir}/detail/tree_policy \
+	${pb_builddir}/detail/binomial_heap_base_ \
+	${pb_builddir}/detail/resize_policy \
+	${pb_builddir}/detail/bin_search_tree_ \
+	${pb_builddir}/detail/binomial_heap_ \
+	${pb_builddir}/detail/thin_heap_ \
+	${pb_builddir}/detail/pat_trie_ \
+	${pb_builddir}/detail/cc_hash_table_map_ \
+	${pb_builddir}/detail/rc_binomial_heap_ \
+	${pb_builddir}/detail/left_child_next_sibling_heap_ \
+	${pb_builddir}/detail/unordered_iterator \
+	${pb_builddir}/detail/binary_heap_ \
+	${pb_builddir}/detail/ov_tree_map_ \
+	${pb_builddir}/detail/hash_fn \
+	${pb_builddir}/detail/eq_fn \
+	${pb_builddir}/detail/rb_tree_map_ \
+	${pb_builddir}/detail/list_update_policy
+
+# The ability for make and the underlying host to deal with this
+# unwieldy list as one entire entity is not a sure thing, and may
+# cause build errors. Thus, split one list into many smaller
+# mini-lists, with the maximum size per mini-list of no more than 42.
+
+pb_headers1 = \
+	${pb_srcdir}/assoc_container.hpp \
+	${pb_srcdir}/exception.hpp \
+	${pb_srcdir}/hash_policy.hpp \
+	${pb_srcdir}/list_update_policy.hpp \
+	${pb_srcdir}/priority_queue.hpp \
+	${pb_srcdir}/tag_and_trait.hpp \
+	${pb_srcdir}/tree_policy.hpp \
+	${pb_srcdir}/trie_policy.hpp \
+	${pb_srcdir}/detail/branch_policy/branch_policy.hpp \
+	${pb_srcdir}/detail/branch_policy/null_node_metadata.hpp \
+	${pb_srcdir}/detail/branch_policy/traits.hpp \
+	${pb_srcdir}/detail/binary_heap_/binary_heap_.hpp \
+	${pb_srcdir}/detail/binary_heap_/const_iterator.hpp \
+	${pb_srcdir}/detail/binary_heap_/point_const_iterator.hpp \
+	${pb_srcdir}/detail/binary_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/entry_cmp.hpp \
+	${pb_srcdir}/detail/binary_heap_/entry_pred.hpp \
+	${pb_srcdir}/detail/binary_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/resize_policy.hpp \
+	${pb_srcdir}/detail/binary_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/binomial_heap_base_.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_/binomial_heap_.hpp \
+	${pb_srcdir}/detail/binomial_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/bin_search_tree_.hpp
+
+pb_headers2 = \
+	${pb_srcdir}/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/node_iterators.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/point_iterators.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/r_erase_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/rotate_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/traits.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/cc_ht_map_.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/cmp_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/cond_key_dtor_entry_dealtor.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/entry_list_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/find_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/resize_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/resize_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/size_fn_imps.hpp
+
+pb_headers3 = \
+	${pb_srcdir}/detail/cc_hash_table_map_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/cond_dealtor.hpp \
+	${pb_srcdir}/detail/container_base_dispatch.hpp \
+	${pb_srcdir}/detail/eq_fn/eq_by_less.hpp \
+	${pb_srcdir}/detail/eq_fn/hash_eq_fn.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/find_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/find_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/gp_ht_map_.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/iterator_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/resize_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/hash_fn/direct_mask_range_hashing_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/direct_mod_range_hashing_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/linear_probe_fn_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/mask_based_range_hashing.hpp \
+	${pb_srcdir}/detail/hash_fn/mod_based_range_hashing.hpp \
+	${pb_srcdir}/detail/hash_fn/probe_fn_base.hpp \
+	${pb_srcdir}/detail/hash_fn/quadratic_probe_fn_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/ranged_hash_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/ranged_probe_fn.hpp
+
+pb_headers4 = \
+	${pb_srcdir}/detail/hash_fn/sample_probe_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/sample_ranged_hash_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/sample_ranged_probe_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/sample_range_hashing.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/const_iterator.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/point_const_iterator.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/node.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/constructor_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/entry_metadata_base.hpp \
+	${pb_srcdir}/detail/list_update_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/lu_map_.hpp \
+	${pb_srcdir}/detail/list_update_map_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_policy/lu_counter_metadata.hpp \
+	${pb_srcdir}/detail/list_update_policy/sample_update_policy.hpp \
+	${pb_srcdir}/detail/debug_map_base.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/node_iterators.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/ov_tree_map_.hpp
+
+pb_headers5 = \
+	${pb_srcdir}/detail/ov_tree_map_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/traits.hpp \
+	${pb_srcdir}/detail/pairing_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/pairing_heap_.hpp \
+	${pb_srcdir}/detail/pairing_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/insert_join_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/pat_trie_.hpp \
+	${pb_srcdir}/detail/pat_trie_/pat_trie_base.hpp \
+	${pb_srcdir}/detail/pat_trie_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/r_erase_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/rotate_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/split_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/synth_access_traits.hpp \
+	${pb_srcdir}/detail/pat_trie_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/traits.hpp \
+	${pb_srcdir}/detail/pat_trie_/update_fn_imps.hpp \
+	${pb_srcdir}/detail/priority_queue_base_dispatch.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/debug_fn_imps.hpp
+
+pb_headers6 = \
+	${pb_srcdir}/detail/rb_tree_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/node.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/rb_tree_.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/traits.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/rc_binomial_heap_.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/rc.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_exponential_size_policy_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_prime_size_policy_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_standard_resize_policy_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/sample_resize_policy.hpp \
+	${pb_srcdir}/detail/resize_policy/sample_resize_trigger.hpp \
+	${pb_srcdir}/detail/resize_policy/sample_size_policy.hpp \
+	${pb_srcdir}/detail/splay_tree_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/node.hpp \
+	${pb_srcdir}/detail/splay_tree_/splay_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/splay_tree_.hpp \
+	${pb_srcdir}/detail/splay_tree_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/traits.hpp \
+	${pb_srcdir}/detail/standard_policies.hpp \
+	${pb_srcdir}/detail/thin_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/erase_fn_imps.hpp
+
+pb_headers7 = \
+	${pb_srcdir}/detail/thin_heap_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/thin_heap_.hpp \
+	${pb_srcdir}/detail/thin_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/tree_policy/node_metadata_selector.hpp \
+	${pb_srcdir}/detail/tree_policy/order_statistics_imp.hpp \
+	${pb_srcdir}/detail/tree_policy/sample_tree_node_update.hpp \
+	${pb_srcdir}/detail/tree_trace_base.hpp \
+	${pb_srcdir}/detail/trie_policy/node_metadata_selector.hpp \
+	${pb_srcdir}/detail/trie_policy/order_statistics_imp.hpp \
+	${pb_srcdir}/detail/trie_policy/prefix_search_node_update_imp.hpp \
+	${pb_srcdir}/detail/trie_policy/sample_trie_access_traits.hpp \
+	${pb_srcdir}/detail/trie_policy/sample_trie_node_update.hpp \
+	${pb_srcdir}/detail/trie_policy/trie_string_access_traits_imp.hpp \
+	${pb_srcdir}/detail/trie_policy/trie_policy_base.hpp \
+	${pb_srcdir}/detail/types_traits.hpp \
+	${pb_srcdir}/detail/type_utils.hpp \
+	${pb_srcdir}/detail/unordered_iterator/const_iterator.hpp \
+	${pb_srcdir}/detail/unordered_iterator/point_const_iterator.hpp \
+	${pb_srcdir}/detail/unordered_iterator/iterator.hpp \
+	${pb_srcdir}/detail/unordered_iterator/point_iterator.hpp
+
+
+ext_srcdir = ${glibcxx_srcdir}/include/ext
+ext_builddir = ./ext
+ext_headers = \
+	${ext_srcdir}/algorithm \
+	${ext_srcdir}/aligned_buffer.h \
+	${ext_srcdir}/alloc_traits.h \
+	${ext_srcdir}/atomicity.h \
+	${ext_srcdir}/array_allocator.h \
+	${ext_srcdir}/bitmap_allocator.h \
+	${ext_srcdir}/cast.h \
+	${ext_srcdir}/cmath \
+	${ext_srcdir}/codecvt_specializations.h \
+	${ext_srcdir}/concurrence.h \
+	${ext_srcdir}/debug_allocator.h \
+	${ext_srcdir}/enc_filebuf.h \
+	${ext_srcdir}/extptr_allocator.h \
+	${ext_srcdir}/stdio_filebuf.h \
+	${ext_srcdir}/stdio_sync_filebuf.h \
+	${ext_srcdir}/functional \
+	${ext_srcdir}/iterator \
+	${ext_srcdir}/malloc_allocator.h \
+	${ext_srcdir}/memory \
+	${ext_srcdir}/mt_allocator.h \
+	${ext_srcdir}/new_allocator.h \
+	${ext_srcdir}/numeric \
+	${ext_srcdir}/numeric_traits.h \
+	${ext_srcdir}/pod_char_traits.h \
+	${ext_srcdir}/pointer.h \
+	${ext_srcdir}/pool_allocator.h \
+	${ext_srcdir}/rb_tree \
+	${ext_srcdir}/random \
+	${ext_srcdir}/random.tcc \
+	${ext_srcdir}/rope \
+	${ext_srcdir}/ropeimpl.h \
+	${ext_srcdir}/slist \
+	${ext_srcdir}/string_conversions.h \
+	${ext_srcdir}/throw_allocator.h \
+	${ext_srcdir}/typelist.h \
+	${ext_srcdir}/type_traits.h \
+	${ext_srcdir}/rc_string_base.h \
+	${ext_srcdir}/sso_string_base.h \
+	${ext_srcdir}/vstring.h \
+	${ext_srcdir}/vstring.tcc \
+	${ext_srcdir}/vstring_fwd.h \
+	${ext_srcdir}/vstring_util.h \
+	${ext_compat_headers}
+
+ext_compat_headers = \
+	${backward_srcdir}/hash_set \
+	${backward_srcdir}/hash_map
+
+ext_host_headers = \
+	${glibcxx_srcdir}/${CPU_OPT_EXT_RANDOM}
+
+tr1_srcdir = ${glibcxx_srcdir}/include/tr1
+tr1_builddir = ./tr1
+tr1_headers = \
+	${tr1_srcdir}/array \
+	${tr1_srcdir}/bessel_function.tcc \
+	${tr1_srcdir}/beta_function.tcc \
+	${tr1_srcdir}/ccomplex \
+	${tr1_srcdir}/cctype \
+	${tr1_srcdir}/cfenv \
+	${tr1_srcdir}/cfloat \
+	${tr1_srcdir}/cinttypes \
+	${tr1_srcdir}/climits \
+	${tr1_srcdir}/cmath \
+	${tr1_srcdir}/complex \
+	${tr1_srcdir}/complex.h \
+	${tr1_srcdir}/cstdarg \
+	${tr1_srcdir}/cstdbool \
+	${tr1_srcdir}/cstdint \
+	${tr1_srcdir}/cstdio \
+	${tr1_srcdir}/cstdlib \
+	${tr1_srcdir}/ctgmath \
+	${tr1_srcdir}/ctime \
+	${tr1_srcdir}/ctype.h \
+	${tr1_srcdir}/cwchar \
+	${tr1_srcdir}/cwctype \
+	${tr1_srcdir}/ell_integral.tcc \
+	${tr1_srcdir}/exp_integral.tcc \
+	${tr1_srcdir}/fenv.h \
+	${tr1_srcdir}/float.h \
+	${tr1_srcdir}/functional \
+	${tr1_srcdir}/functional_hash.h \
+	${tr1_srcdir}/gamma.tcc \
+	${tr1_srcdir}/hypergeometric.tcc \
+	${tr1_srcdir}/hashtable.h \
+	${tr1_srcdir}/hashtable_policy.h \
+	${tr1_srcdir}/inttypes.h \
+	${tr1_srcdir}/limits.h \
+	${tr1_srcdir}/math.h \
+	${tr1_srcdir}/memory \
+	${tr1_srcdir}/modified_bessel_func.tcc \
+	${tr1_srcdir}/poly_hermite.tcc \
+	${tr1_srcdir}/poly_laguerre.tcc \
+	${tr1_srcdir}/legendre_function.tcc \
+	${tr1_srcdir}/random \
+	${tr1_srcdir}/random.h \
+	${tr1_srcdir}/random.tcc \
+	${tr1_srcdir}/regex \
+	${tr1_srcdir}/riemann_zeta.tcc \
+	${tr1_srcdir}/shared_ptr.h \
+	${tr1_srcdir}/special_function_util.h \
+	${tr1_srcdir}/stdarg.h \
+	${tr1_srcdir}/stdbool.h \
+	${tr1_srcdir}/stdint.h \
+	${tr1_srcdir}/stdio.h \
+	${tr1_srcdir}/stdlib.h \
+	${tr1_srcdir}/tgmath.h \
+	${tr1_srcdir}/tuple \
+	${tr1_srcdir}/type_traits \
+	${tr1_srcdir}/unordered_map \
+	${tr1_srcdir}/unordered_map.h \
+	${tr1_srcdir}/unordered_set \
+	${tr1_srcdir}/unordered_set.h \
+	${tr1_srcdir}/utility \
+	${tr1_srcdir}/wchar.h \
+	${tr1_srcdir}/wctype.h
+
+tr2_srcdir = ${glibcxx_srcdir}/include/tr2
+tr2_builddir = ./tr2
+tr2_headers = \
+	${tr2_srcdir}/bool_set \
+	${tr2_srcdir}/bool_set.tcc \
+	${tr2_srcdir}/dynamic_bitset \
+	${tr2_srcdir}/dynamic_bitset.tcc \
+	${tr2_srcdir}/ratio \
+	${tr2_srcdir}/type_traits
+
+decimal_srcdir = ${glibcxx_srcdir}/include/decimal
+decimal_builddir = ./decimal
+decimal_headers = \
+	${decimal_srcdir}/decimal \
+	${decimal_srcdir}/decimal.h
+
+# Post-C++11 TS's
+experimental_srcdir = ${glibcxx_srcdir}/include/experimental
+experimental_builddir = ./experimental
+experimental_headers = \
+	${experimental_srcdir}/optional \
+	${experimental_srcdir}/string_view \
+	${experimental_srcdir}/string_view.tcc
+
+# This is the common subset of C++ files that all three "C" header models use.
+c_base_srcdir = $(C_INCLUDE_DIR)
+c_base_builddir = .
+c_base_headers = \
+	${c_base_srcdir}/cassert \
+	${c_base_srcdir}/ccomplex \
+	${c_base_srcdir}/cctype \
+	${c_base_srcdir}/cerrno \
+	${c_base_srcdir}/cfenv \
+	${c_base_srcdir}/cfloat \
+	${c_base_srcdir}/cinttypes \
+	${c_base_srcdir}/ciso646 \
+	${c_base_srcdir}/climits \
+	${c_base_srcdir}/clocale \
+	${c_base_srcdir}/cmath \
+	${c_base_srcdir}/csetjmp \
+	${c_base_srcdir}/csignal \
+	${c_base_srcdir}/cstdalign \
+	${c_base_srcdir}/cstdarg \
+	${c_base_srcdir}/cstdbool \
+	${c_base_srcdir}/cstddef \
+	${c_base_srcdir}/cstdint \
+	${c_base_srcdir}/cstdio \
+	${c_base_srcdir}/cstdlib \
+	${c_base_srcdir}/cstring \
+	${c_base_srcdir}/ctgmath \
+	${c_base_srcdir}/ctime \
+	${c_base_srcdir}/cwchar \
+	${c_base_srcdir}/cwctype
+
+# "C" compatibility headers.
+c_compatibility_srcdir = ${glibcxx_srcdir}/include/c_compatibility
+c_compatibility_builddir = .
+
+if GLIBCXX_C_HEADERS_C_STD
+c_compatibility_headers =
+endif
+
+if GLIBCXX_C_HEADERS_C_GLOBAL
+c_compatibility_headers = \
+	${c_compatibility_srcdir}/complex.h \
+	${c_compatibility_srcdir}/fenv.h \
+	${c_compatibility_srcdir}/tgmath.h
+endif
+
+if GLIBCXX_C_HEADERS_C
+c_compatibility_headers = \
+	${c_compatibility_srcdir}/assert.h \
+	${c_compatibility_srcdir}/complex.h \
+	${c_compatibility_srcdir}/ctype.h \
+	${c_compatibility_srcdir}/errno.h \
+	${c_compatibility_srcdir}/fenv.h \
+	${c_compatibility_srcdir}/float.h \
+	${c_compatibility_srcdir}/inttypes.h \
+	${c_compatibility_srcdir}/iso646.h \
+	${c_compatibility_srcdir}/limits.h \
+	${c_compatibility_srcdir}/locale.h \
+	${c_compatibility_srcdir}/math.h \
+	${c_compatibility_srcdir}/setjmp.h \
+	${c_compatibility_srcdir}/signal.h \
+	${c_compatibility_srcdir}/stdarg.h \
+	${c_compatibility_srcdir}/stdbool.h \
+	${c_compatibility_srcdir}/stddef.h \
+	${c_compatibility_srcdir}/stdint.h \
+	${c_compatibility_srcdir}/stdio.h \
+	${c_compatibility_srcdir}/stdlib.h \
+	${c_compatibility_srcdir}/string.h \
+	${c_compatibility_srcdir}/tgmath.h \
+	${c_compatibility_srcdir}/time.h \
+	${c_compatibility_srcdir}/wchar.h \
+	${c_compatibility_srcdir}/wctype.h
+endif
+
+# Debug mode headers
+debug_srcdir = ${glibcxx_srcdir}/include/debug
+debug_builddir = ./debug
+debug_headers = \
+	${debug_srcdir}/array \
+	${debug_srcdir}/bitset \
+	${debug_srcdir}/debug.h \
+	${debug_srcdir}/deque \
+	${debug_srcdir}/formatter.h \
+	${debug_srcdir}/forward_list \
+	${debug_srcdir}/functions.h \
+	${debug_srcdir}/list \
+	${debug_srcdir}/map \
+	${debug_srcdir}/macros.h \
+	${debug_srcdir}/map.h \
+	${debug_srcdir}/multimap.h \
+	${debug_srcdir}/multiset.h \
+	${debug_srcdir}/safe_base.h \
+	${debug_srcdir}/safe_iterator.h \
+	${debug_srcdir}/safe_iterator.tcc \
+	${debug_srcdir}/safe_local_iterator.h \
+	${debug_srcdir}/safe_local_iterator.tcc \
+	${debug_srcdir}/safe_sequence.h \
+	${debug_srcdir}/safe_sequence.tcc \
+	${debug_srcdir}/safe_unordered_base.h \
+	${debug_srcdir}/safe_unordered_container.h \
+	${debug_srcdir}/safe_unordered_container.tcc \
+	${debug_srcdir}/set \
+	${debug_srcdir}/set.h \
+	${debug_srcdir}/string \
+	${debug_srcdir}/unordered_map \
+	${debug_srcdir}/unordered_set \
+	${debug_srcdir}/vector
+
+# Parallel mode headers
+parallel_srcdir = ${glibcxx_srcdir}/include/parallel
+parallel_builddir = ./parallel
+parallel_headers = \
+	${parallel_srcdir}/algo.h \
+	${parallel_srcdir}/algobase.h \
+	${parallel_srcdir}/algorithm \
+	${parallel_srcdir}/algorithmfwd.h \
+	${parallel_srcdir}/balanced_quicksort.h \
+	${parallel_srcdir}/base.h \
+	${parallel_srcdir}/basic_iterator.h \
+	${parallel_srcdir}/checkers.h \
+	${parallel_srcdir}/compatibility.h \
+	${parallel_srcdir}/compiletime_settings.h \
+	${parallel_srcdir}/equally_split.h \
+	${parallel_srcdir}/features.h \
+	${parallel_srcdir}/find.h \
+	${parallel_srcdir}/find_selectors.h \
+	${parallel_srcdir}/for_each.h \
+	${parallel_srcdir}/for_each_selectors.h \
+	${parallel_srcdir}/iterator.h \
+	${parallel_srcdir}/list_partition.h \
+	${parallel_srcdir}/losertree.h \
+	${parallel_srcdir}/merge.h \
+	${parallel_srcdir}/multiseq_selection.h \
+	${parallel_srcdir}/multiway_merge.h \
+	${parallel_srcdir}/multiway_mergesort.h \
+	${parallel_srcdir}/numeric \
+	${parallel_srcdir}/numericfwd.h \
+	${parallel_srcdir}/omp_loop.h \
+	${parallel_srcdir}/omp_loop_static.h \
+	${parallel_srcdir}/par_loop.h \
+	${parallel_srcdir}/parallel.h \
+	${parallel_srcdir}/partial_sum.h \
+	${parallel_srcdir}/partition.h \
+	${parallel_srcdir}/queue.h \
+	${parallel_srcdir}/quicksort.h \
+	${parallel_srcdir}/random_number.h \
+	${parallel_srcdir}/random_shuffle.h \
+	${parallel_srcdir}/search.h \
+	${parallel_srcdir}/set_operations.h \
+	${parallel_srcdir}/settings.h \
+	${parallel_srcdir}/sort.h \
+	${parallel_srcdir}/tags.h \
+	${parallel_srcdir}/types.h \
+	${parallel_srcdir}/unique_copy.h \
+	${parallel_srcdir}/workstealing.h
+
+# Profile mode headers
+profile_srcdir = ${glibcxx_srcdir}/include/profile
+profile_builddir = ./profile
+profile_headers = \
+	${profile_srcdir}/array \
+	${profile_srcdir}/base.h \
+	${profile_srcdir}/unordered_base.h \
+	${profile_srcdir}/unordered_map \
+	${profile_srcdir}/unordered_set \
+	${profile_srcdir}/vector \
+	${profile_srcdir}/bitset \
+	${profile_srcdir}/deque \
+	${profile_srcdir}/forward_list \
+	${profile_srcdir}/list \
+	${profile_srcdir}/map \
+	${profile_srcdir}/map.h \
+	${profile_srcdir}/multimap.h \
+	${profile_srcdir}/multiset.h \
+	${profile_srcdir}/set \
+	${profile_srcdir}/set.h \
+	${profile_srcdir}/iterator_tracker.h
+profile_impl_srcdir = ${glibcxx_srcdir}/include/profile/impl
+profile_impl_builddir = ./profile/impl
+profile_impl_headers = \
+	${profile_impl_srcdir}/profiler.h \
+	${profile_impl_srcdir}/profiler_algos.h \
+	${profile_impl_srcdir}/profiler_container_size.h \
+	${profile_impl_srcdir}/profiler_hash_func.h \
+	${profile_impl_srcdir}/profiler_hashtable_size.h \
+	${profile_impl_srcdir}/profiler_map_to_unordered_map.h \
+	${profile_impl_srcdir}/profiler_node.h \
+	${profile_impl_srcdir}/profiler_state.h \
+	${profile_impl_srcdir}/profiler_trace.h \
+	${profile_impl_srcdir}/profiler_vector_size.h \
+	${profile_impl_srcdir}/profiler_vector_to_list.h \
+	${profile_impl_srcdir}/profiler_list_to_vector.h \
+	${profile_impl_srcdir}/profiler_list_to_slist.h
+
+# Some "C" header schemes require the "C" compatibility headers.
+# For --enable-cheaders=c_std
+if GLIBCXX_C_HEADERS_COMPATIBILITY
+c_compatibility_headers_extra = ${c_compatibility_headers}
+else
+c_compatibility_headers_extra =
+endif
+
+host_srcdir = ${glibcxx_srcdir}/$(OS_INC_SRCDIR)
+host_builddir = ./${host_alias}/bits
+host_installdir = ${gxx_include_dir}/${host_alias}$(MULTISUBDIR)/bits
+host_headers = \
+	${host_srcdir}/ctype_base.h \
+	${host_srcdir}/ctype_inline.h \
+	${host_srcdir}/os_defines.h \
+	${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \
+	${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
+	${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \
+	${glibcxx_srcdir}/$(ERROR_CONSTANTS_SRCDIR)/error_constants.h \
+	${glibcxx_srcdir}/include/precompiled/stdc++.h \
+	${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \
+	${glibcxx_srcdir}/include/precompiled/extc++.h
+
+# Non-installed host_header files.
+COMPATIBILITY_H = config/abi/compatibility.h
+host_headers_noinst = \
+	${glibcxx_srcdir}/$(CLOCALE_INTERNAL_H) \
+	${glibcxx_srcdir}/$(COMPATIBILITY_H)
+
+# These host_headers_extra files are all built with ad hoc naming rules.
+host_headers_extra = \
+	${host_builddir}/basic_file.h \
+	${host_builddir}/c++config.h \
+	${host_builddir}/c++allocator.h \
+	${host_builddir}/c++io.h \
+	${host_builddir}/c++locale.h \
+	${host_builddir}/messages_members.h \
+	${host_builddir}/time_members.h
+
+thread_host_headers = \
+	${host_builddir}/gthr.h \
+	${host_builddir}/gthr-single.h \
+	${host_builddir}/gthr-posix.h \
+	${host_builddir}/gthr-default.h
+
+
+pch1_source = ${glibcxx_srcdir}/include/precompiled/stdc++.h
+pch1_output_builddir = ${host_builddir}/stdc++.h.gch
+pch1_output_anchor = ${host_builddir}/stdc++.h
+pch1_output_installdir = ${host_installdir}/stdc++.h.gch
+pch1a_output = ${pch1_output_builddir}/O2ggnu++0x.gch
+pch1b_output = ${pch1_output_builddir}/O2g.gch
+pch1_output = ${pch1a_output} ${pch1b_output}
+
+pch2_source = ${glibcxx_srcdir}/include/precompiled/stdtr1c++.h
+pch2_output_builddir = ${host_builddir}/stdtr1c++.h.gch
+pch2_output_anchor = ${host_builddir}/stdtr1c++.h
+pch2_output_installdir = ${host_installdir}/stdtr1c++.h.gch
+pch2_output = ${pch2_output_builddir}/O2g.gch
+
+pch3_source = ${glibcxx_srcdir}/include/precompiled/extc++.h
+pch3_output_builddir = ${host_builddir}/extc++.h.gch
+pch3_output_anchor = ${host_builddir}/extc++.h
+pch3_output_installdir = ${host_installdir}/extc++.h.gch
+pch3_output = ${pch3_output_builddir}/O2g.gch
+
+
+pch_output = ${pch1_output} ${pch2_output} ${pch3_output}
+pch_output_dirs = \
+	${pch1_output_builddir} ${pch2_output_builddir} ${pch3_output_builddir}
+pch_output_anchors = \
+	${pch1_output_anchor} ${pch2_output_anchor} ${pch3_output_anchor}
+PCHFLAGS=-x c++-header -nostdinc++ $(CXXFLAGS) $(VTV_PCH_CXXFLAGS)
+if GLIBCXX_BUILD_PCH
+pch_build = ${pch_output}
+else
+pch_build =
+endif
+
+# List of all timestamp files.  By keeping only one copy of this list, both
+# CLEANFILES and all-local are kept up-to-date.
+allstamped = \
+	stamp-std stamp-bits stamp-bits-sup stamp-c_base stamp-c_compatibility \
+	stamp-backward stamp-ext stamp-pb stamp-tr1 stamp-tr2 stamp-decimal \
+	stamp-experimental stamp-debug stamp-parallel stamp-profile \
+	stamp-profile-impl stamp-host
+
+# List of all files that are created by explicit building, editing, or
+# catenation.
+allcreated = \
+	${host_builddir}/c++config.h \
+	${thread_host_headers} \
+	${pch_build}
+
+# Here are the rules for building the headers
+all-local: ${allstamped} ${allcreated}
+
+# Ignore errors from 'mkdir -p' to avoid parallel make failure on
+# systems with broken mkdir.  Call mkdir unconditionally because
+# it is just as cheap to avoid going through the shell.
+# Ignore errors from $(LN_S) because the links may already exist.
+stamp-std: ${std_headers}
+	@-mkdir -p ${std_builddir}
+	@-cd ${std_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-std
+
+stamp-bits: ${bits_headers}
+	@-mkdir -p ${bits_builddir}
+	@-cd ${bits_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-bits
+
+stamp-bits-sup: stamp-bits ${bits_sup_headers}
+	@-cd ${bits_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-bits-sup
+
+stamp-c_base: ${c_base_headers}
+	@-mkdir -p ${c_base_builddir}
+	@-cd ${c_base_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-c_base
+
+stamp-c_base_extra: ${c_base_headers_extra}
+	@-mkdir -p ${bits_builddir}
+	@-cd ${bits_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-c_base_extra
+
+stamp-c_compatibility: ${c_compatibility_headers_extra}
+	@-mkdir -p ${c_compatibility_builddir}
+	@-if [ ! -z "${c_compatibility_headers_extra}" ]; then \
+	  cd ${c_compatibility_builddir} && $(LN_S) $? . 2>/dev/null ;\
+	fi
+	@$(STAMP) stamp-c_compatibility
+
+stamp-backward: ${backward_headers}
+	@-mkdir -p ${backward_builddir}
+	@-cd ${backward_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-backward
+
+stamp-ext: ${ext_headers}
+	@-mkdir -p ${ext_builddir}
+	@-cd ${ext_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-ext
+
+# Have to deal with nested include directories, gah! Strip off source
+# directory before making the link.
+# XXX check  ${pb_headers}
+stamp-pb:
+	@if [ ! -d "${pb_builddir}" ]; then \
+	    mkdir -p ${pb_subdirs} ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers1}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers2}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers3}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers4}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers5}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers6}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers7}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	$(STAMP) stamp-pb
+
+stamp-tr1: ${tr1_headers}
+	@-mkdir -p ${tr1_builddir}
+	@-cd ${tr1_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-tr1
+
+stamp-tr2: ${tr2_headers}
+	@-mkdir -p ${tr2_builddir}
+	@-cd ${tr2_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-tr2
+
+stamp-decimal: ${decimal_headers}
+	@-mkdir -p ${decimal_builddir}
+	@-cd ${decimal_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-decimal
+
+stamp-experimental: ${experimental_headers}
+	@-mkdir -p ${experimental_builddir}
+	@-cd ${experimental_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-experimental
+
+stamp-debug: ${debug_headers}
+	@-mkdir -p ${debug_builddir}
+	@-cd ${debug_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-debug
+
+stamp-parallel: ${parallel_headers}
+	@-mkdir -p ${parallel_builddir}
+	@-cd ${parallel_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-parallel
+
+stamp-profile: ${profile_headers}
+	@-mkdir -p ${profile_builddir}
+	@-cd ${profile_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-profile
+
+stamp-profile-impl: ${profile_impl_headers}
+	@-mkdir -p ${profile_impl_builddir}
+	@-cd ${profile_impl_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-profile-impl
+
+stamp-${host_alias}:
+	@-mkdir -p ${host_builddir}
+	@-mkdir -p ${host_builddir}/../ext
+	@$(STAMP) stamp-${host_alias}
+
+# Host includes static.
+# XXX Missing dependency info for {host_headers_extra}
+stamp-host: ${host_headers} ${bits_host_headers} ${ext_host_headers} ${host_headers_noinst} stamp-${host_alias}
+	@cd ${host_builddir} && {\
+	  $(LN_S) ${host_headers} ${bits_host_headers} . || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(BASIC_FILE_H) basic_file.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(ALLOCATOR_H) c++allocator.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CSTDIO_H) c++io.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CLOCALE_H) c++locale.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CLOCALE_INTERNAL_H) . || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(COMPATIBILITY_H) . || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CMESSAGES_H) messages_members.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CTIME_H) time_members.h || true;\
+	} 2>/dev/null
+	@cd ${host_builddir}/../ext && {\
+	  $(LN_S) ${ext_host_headers} . || true ;\
+	} 2>/dev/null
+	$(STAMP) stamp-host
+
+# Host includes dynamic.
+if ENABLE_SYMVERS_GNU_NAMESPACE
+stamp-namespace-version:
+	echo 1 > stamp-namespace-version
+else
+stamp-namespace-version:
+	echo 0 > stamp-namespace-version
+endif
+
+if ENABLE_EXTERN_TEMPLATE
+stamp-extern-template:
+	echo 1 > stamp-extern-template
+else
+stamp-extern-template:
+	echo 0 > stamp-extern-template
+endif
+
+if ENABLE_VISIBILITY
+stamp-visibility:
+	echo 1 > stamp-visibility
+else
+stamp-visibility:
+	echo 0 > stamp-visibility
+endif
+
+# NB: The non-empty default ldbl_compat works around an AIX sed
+# oddity, see libstdc++/31957 for details.
+${host_builddir}/c++config.h: ${CONFIG_HEADER} \
+			      ${glibcxx_srcdir}/include/bits/c++config \
+			      stamp-${host_alias} \
+			      ${toplevel_srcdir}/gcc/DATESTAMP \
+			      stamp-namespace-version \
+			      stamp-visibility \
+			      stamp-extern-template
+	@date=`cat ${toplevel_srcdir}/gcc/DATESTAMP` ;\
+	ns_version=`cat stamp-namespace-version` ;\
+	visibility=`cat stamp-visibility` ;\
+	externtemplate=`cat stamp-extern-template` ;\
+	ldbl_compat='s,g,g,' ;\
+	grep "^[	 ]*#[	 ]*define[	 ][	 ]*_GLIBCXX_LONG_DOUBLE_COMPAT[	 ][	 ]*1[	 ]*$$" \
+	${CONFIG_HEADER} > /dev/null 2>&1 \
+	&& ldbl_compat='s,^#undef _GLIBCXX_LONG_DOUBLE_COMPAT$$,#define _GLIBCXX_LONG_DOUBLE_COMPAT 1,' ;\
+	sed -e "s,define __GLIBCXX__,define __GLIBCXX__ $$date," \
+	-e "s,define _GLIBCXX_INLINE_VERSION, define _GLIBCXX_INLINE_VERSION $$ns_version," \
+	-e "s,define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY, define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY $$visibility," \
+	-e "s,define _GLIBCXX_EXTERN_TEMPLATE$$, define _GLIBCXX_EXTERN_TEMPLATE $$externtemplate," \
+	-e "$$ldbl_compat" \
+	    < ${glibcxx_srcdir}/include/bits/c++config > $@ ;\
+	sed -e 's/HAVE_/_GLIBCXX_HAVE_/g' \
+	    -e 's/PACKAGE/_GLIBCXX_PACKAGE/g' \
+	    -e 's/VERSION/_GLIBCXX_VERSION/g' \
+	    -e 's/WORDS_/_GLIBCXX_WORDS_/g' \
+	    -e 's/ICONV_CONST/_GLIBCXX_ICONV_CONST/g' \
+	    -e '/[	 ]_GLIBCXX_LONG_DOUBLE_COMPAT[	 ]/d' \
+	    < ${CONFIG_HEADER} >> $@ ;\
+	echo "" >> $@ ;\
+	echo "#endif // _GLIBCXX_CXX_CONFIG_H" >> $@
+
+# Host includes for threads
+uppercase = [ABCDEFGHIJKLMNOPQRSTUVWXYZ_]
+
+${host_builddir}/gthr.h: ${toplevel_srcdir}/libgcc/gthr.h stamp-${host_alias}
+	sed -e '/^#pragma/b' \
+	    -e '/^#/s/\(${uppercase}${uppercase}*\)/_GLIBCXX_\1/g' \
+	    -e 's/_GLIBCXX_SUPPORTS_WEAK/__GXX_WEAK__/g' \
+	    -e 's/_GLIBCXX___MINGW32_GLIBCXX___/__MINGW32__/g' \
+	    -e 's,^#include "\(.*\)",#include <bits/\1>,g' \
+	    < $< > $@
+
+${host_builddir}/gthr-single.h: ${toplevel_srcdir}/libgcc/gthr-single.h \
+				  stamp-${host_alias}
+	sed -e 's/\(UNUSED\)/_GLIBCXX_\1/g' \
+	    -e 's/\(GCC${uppercase}*_H\)/_GLIBCXX_\1/g' \
+	    < $< > $@
+
+${host_builddir}/gthr-posix.h: ${toplevel_srcdir}/libgcc/gthr-posix.h \
+				   stamp-${host_alias}
+	sed -e 's/\(UNUSED\)/_GLIBCXX_\1/g' \
+	    -e 's/\(GCC${uppercase}*_H\)/_GLIBCXX_\1/g' \
+	    -e 's/SUPPORTS_WEAK/__GXX_WEAK__/g' \
+	    -e 's/\(${uppercase}*USE_WEAK\)/_GLIBCXX_\1/g' \
+	    < $< > $@
+
+${host_builddir}/gthr-default.h: ${toplevel_srcdir}/libgcc/${thread_header} \
+				   stamp-${host_alias}
+	sed -e 's/\(UNUSED\)/_GLIBCXX_\1/g' \
+	    -e 's/\(GCC${uppercase}*_H\)/_GLIBCXX_\1/g' \
+	    -e 's/SUPPORTS_WEAK/__GXX_WEAK__/g' \
+	    -e 's/\(${uppercase}*USE_WEAK\)/_GLIBCXX_\1/g' \
+	    -e 's,^#include "\(.*\)",#include <bits/\1>,g' \
+	    < $< > $@
+
+# Build two precompiled C++ includes, stdc++.h.gch/*.gch
+${pch1a_output}: ${allstamped} ${host_builddir}/c++config.h ${pch1_source}
+	-mkdir -p ${pch1_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g -std=gnu++0x ${pch1_source} \
+	-o $@
+
+${pch1b_output}: ${allstamped} ${host_builddir}/c++config.h ${pch1_source}
+	-mkdir -p ${pch1_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch1_source} -o $@
+
+# Build a precompiled TR1 include, stdtr1c++.h.gch/O2.gch
+${pch2_output}: ${pch2_source} ${pch1_output}
+	-mkdir -p ${pch2_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch2_source} -o $@
+
+# Build a precompiled extension include, extc++.h.gch/O2.gch
+${pch3_output}: ${pch3_source} ${pch2_output}
+	-mkdir -p ${pch3_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@
+
+# For robustness sake (in light of junk files or in-source
+# configuration), copy from the build or source tree to the install
+# tree using only the human-maintained file lists and directory
+# components.  Yes, with minor differences, this is sheer duplication
+# of the staging rules above using $(INSTALL_DATA) instead of LN_S and
+# `$(mkinstalldirs)' instead of `mkdir -p'.  In particular,
+# host_headers_extra are taken out of the build tree staging area;
+# the rest are taken from the original source tree.
+
+if GLIBCXX_HOSTED
+install-data-local: install-headers
+else
+install-data-local: install-freestanding-headers
+endif
+
+# This is a subset of the full install-headers rule.  We only need <cstddef>,
+# <limits>, <cstdlib>, <cstdarg>, <new>, <typeinfo>, <exception>, and any
+# files which they include (and which we provide).  The last three headers
+# are installed by libsupc++, so only the first four and the sub-includes
+# are copied here.
+install-freestanding-headers:
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/bits
+	$(mkinstalldirs) $(DESTDIR)${host_installdir}
+	$(INSTALL_DATA) ${glibcxx_srcdir}/include/bits/c++0x_warning.h \
+	  $(DESTDIR)${gxx_include_dir}/bits
+	for file in ${host_srcdir}/os_defines.h ${host_builddir}/c++config.h \
+	  ${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
+	  ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${std_builddir}
+	$(INSTALL_DATA) ${std_builddir}/limits $(DESTDIR)${gxx_include_dir}/${std_builddir}
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
+	for file in cstddef cstdlib cstdarg; do \
+	  $(INSTALL_DATA) ${c_base_builddir}/$${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
+
+# The real deal.
+install-headers:
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${bits_builddir}
+	for file in ${bits_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${bits_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${backward_builddir}
+	for file in ${backward_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${backward_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${ext_builddir}
+	for file in ${ext_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${ext_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${pb_builddir}
+	for dir in ${pb_subdirs}; do \
+	  $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/$${dir} ; done
+	for file in ${pb_headers1}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers2}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers3}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers4}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers5}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers6}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers7}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_builddir}
+	for file in ${tr1_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr2_builddir}
+	for file in ${tr2_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr2_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${decimal_builddir}
+	for file in ${decimal_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${decimal_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${experimental_builddir}
+	for file in ${experimental_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${experimental_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
+	for file in ${c_base_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
+	c_base_headers_extra_install='$(c_base_headers_extra)';\
+	for file in $$c_base_headers_extra_install; do \
+	  $(INSTALL_DATA) $$file $(DESTDIR)${gxx_include_dir}/${bits_builddir}; done
+	c_compatibility_headers_install='$(c_compatibility_headers_extra)';\
+	for file in $$c_compatibility_headers_install; do \
+	  $(INSTALL_DATA) $$file $(DESTDIR)${gxx_include_dir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${std_builddir}
+	for file in ${std_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${std_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${debug_builddir}
+	for file in ${debug_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${debug_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${parallel_builddir}
+	for file in ${parallel_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${parallel_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_builddir}
+	for file in ${profile_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir}
+	for file in ${profile_impl_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${host_installdir}
+	for file in ${host_headers} ${bits_host_headers} ${host_headers_extra} \
+	 ${thread_host_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
+	$(mkinstalldirs) $(DESTDIR)${host_installdir}/../ext
+	for file in ${ext_host_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}/../ext; done
+
+# By adding these files here, automake will remove them for 'make clean'
+CLEANFILES = ${pch_output} ${pch_output_anchors} stamp-host
+
+# To remove directories.
+clean-local:
+	rm -rf ${pch_output_dirs}
+
+# Stop implicit '.o' make rules from ever stomping on extensionless
+# headers, in the improbable case where some foolish, crack-addled
+# developer tries to create them via make in the include build
+# directory. (This is more of an example of how this kind of rule can
+# be made.)
+.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr2_headers)
+	   $(decimal_headers) $(ext_headers) $(experimental_headers)
+$(std_headers): ; @:
+$(c_base_headers): ; @:
+$(tr1_headers): ; @:
+$(decimal_headers): ; @:
+$(ext_headers): ; @:
+$(experimental_headers): ; @:
diff --git a/gcc-4.9/libstdc++-v3/include/Makefile.in b/gcc-4.9/libstdc++-v3/include/Makefile.in
new file mode 100644
index 0000000..c726583
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/Makefile.in
@@ -0,0 +1,1753 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+DIST_COMMON = $(top_srcdir)/fragment.am $(srcdir)/Makefile.in \
+	$(srcdir)/Makefile.am
+subdir = include
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \
+	$(top_srcdir)/../config/enable.m4 \
+	$(top_srcdir)/../config/futex.m4 \
+	$(top_srcdir)/../config/iconv.m4 \
+	$(top_srcdir)/../config/lead-dot.m4 \
+	$(top_srcdir)/../config/lib-ld.m4 \
+	$(top_srcdir)/../config/lib-link.m4 \
+	$(top_srcdir)/../config/lib-prefix.m4 \
+	$(top_srcdir)/../config/lthostflags.m4 \
+	$(top_srcdir)/../config/multi.m4 \
+	$(top_srcdir)/../config/no-executables.m4 \
+	$(top_srcdir)/../config/override.m4 \
+	$(top_srcdir)/../config/stdint.m4 \
+	$(top_srcdir)/../config/unwind_ipinfo.m4 \
+	$(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \
+	$(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \
+	$(top_srcdir)/../lt~obsolete.m4 $(top_srcdir)/crossconfig.m4 \
+	$(top_srcdir)/linkage.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/../config/gc++filt.m4 \
+	$(top_srcdir)/../config/tls.m4 $(top_srcdir)/../config/gthr.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+depcomp =
+am__depfiles_maybe =
+SOURCES =
+ABI_TWEAKS_SRCDIR = @ABI_TWEAKS_SRCDIR@
+ACLOCAL = @ACLOCAL@
+ALLOCATOR_H = @ALLOCATOR_H@
+ALLOCATOR_NAME = @ALLOCATOR_NAME@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+ATOMICITY_SRCDIR = @ATOMICITY_SRCDIR@
+ATOMIC_FLAGS = @ATOMIC_FLAGS@
+ATOMIC_WORD_SRCDIR = @ATOMIC_WORD_SRCDIR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BASIC_FILE_CC = @BASIC_FILE_CC@
+BASIC_FILE_H = @BASIC_FILE_H@
+CC = @CC@
+CCODECVT_CC = @CCODECVT_CC@
+CCOLLATE_CC = @CCOLLATE_CC@
+CCTYPE_CC = @CCTYPE_CC@
+CFLAGS = @CFLAGS@
+CLOCALE_CC = @CLOCALE_CC@
+CLOCALE_H = @CLOCALE_H@
+CLOCALE_INTERNAL_H = @CLOCALE_INTERNAL_H@
+CMESSAGES_CC = @CMESSAGES_CC@
+CMESSAGES_H = @CMESSAGES_H@
+CMONEY_CC = @CMONEY_CC@
+CNUMERIC_CC = @CNUMERIC_CC@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPU_DEFINES_SRCDIR = @CPU_DEFINES_SRCDIR@
+CPU_OPT_BITS_RANDOM = @CPU_OPT_BITS_RANDOM@
+CPU_OPT_EXT_RANDOM = @CPU_OPT_EXT_RANDOM@
+CSTDIO_H = @CSTDIO_H@
+CTIME_CC = @CTIME_CC@
+CTIME_H = @CTIME_H@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXFILT = @CXXFILT@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+C_INCLUDE_DIR = @C_INCLUDE_DIR@
+DBLATEX = @DBLATEX@
+DEBUG_FLAGS = @DEBUG_FLAGS@
+DEFS = @DEFS@
+DOT = @DOT@
+DOXYGEN = @DOXYGEN@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ERROR_CONSTANTS_SRCDIR = @ERROR_CONSTANTS_SRCDIR@
+EXEEXT = @EXEEXT@
+EXTRA_CXX_FLAGS = @EXTRA_CXX_FLAGS@
+FGREP = @FGREP@
+GLIBCXX_INCLUDES = @GLIBCXX_INCLUDES@
+GLIBCXX_LIBS = @GLIBCXX_LIBS@
+GREP = @GREP@
+HWCAP_FLAGS = @HWCAP_FLAGS@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBICONV = @LIBICONV@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OPTIMIZE_CXXFLAGS = @OPTIMIZE_CXXFLAGS@
+OPT_LDFLAGS = @OPT_LDFLAGS@
+OS_INC_SRCDIR = @OS_INC_SRCDIR@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PDFLATEX = @PDFLATEX@
+RANLIB = @RANLIB@
+SECTION_FLAGS = @SECTION_FLAGS@
+SECTION_LDFLAGS = @SECTION_LDFLAGS@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+SYMVER_FILE = @SYMVER_FILE@
+TOPLEVEL_INCLUDES = @TOPLEVEL_INCLUDES@
+USE_NLS = @USE_NLS@
+VERSION = @VERSION@
+VTV_CXXFLAGS = @VTV_CXXFLAGS@
+VTV_CXXLINKFLAGS = @VTV_CXXLINKFLAGS@
+VTV_PCH_CXXFLAGS = @VTV_PCH_CXXFLAGS@
+WARN_FLAGS = @WARN_FLAGS@
+WERROR = @WERROR@
+XMLLINT = @XMLLINT@
+XSLTPROC = @XSLTPROC@
+XSL_STYLE_DIR = @XSL_STYLE_DIR@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__leading_dot = @am__leading_dot@
+am__tar = @am__tar@
+am__untar = @am__untar@
+baseline_dir = @baseline_dir@
+baseline_subdir_switch = @baseline_subdir_switch@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+check_msgfmt = @check_msgfmt@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+enable_shared = @enable_shared@
+enable_static = @enable_static@
+exec_prefix = @exec_prefix@
+glibcxx_MOFILES = @glibcxx_MOFILES@
+glibcxx_PCHFLAGS = @glibcxx_PCHFLAGS@
+glibcxx_POFILES = @glibcxx_POFILES@
+glibcxx_builddir = @glibcxx_builddir@
+glibcxx_compiler_pic_flag = @glibcxx_compiler_pic_flag@
+glibcxx_compiler_shared_flag = @glibcxx_compiler_shared_flag@
+glibcxx_localedir = @glibcxx_localedir@
+glibcxx_lt_pic_flag = @glibcxx_lt_pic_flag@
+glibcxx_prefixdir = @glibcxx_prefixdir@
+glibcxx_srcdir = @glibcxx_srcdir@
+glibcxx_toolexecdir = @glibcxx_toolexecdir@
+glibcxx_toolexeclibdir = @glibcxx_toolexeclibdir@
+gxx_include_dir = @gxx_include_dir@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libtool_VERSION = @libtool_VERSION@
+localedir = @localedir@
+localstatedir = @localstatedir@
+lt_host_flags = @lt_host_flags@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+multi_basedir = @multi_basedir@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+port_specific_symbol_files = @port_specific_symbol_files@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+python_mod_dir = @python_mod_dir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_os = @target_os@
+target_vendor = @target_vendor@
+thread_header = @thread_header@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+toplevel_builddir = @toplevel_builddir@
+toplevel_srcdir = @toplevel_srcdir@
+
+# May be used by various substitution variables.
+gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER)
+MAINT_CHARSET = latin1
+mkinstalldirs = $(SHELL) $(toplevel_srcdir)/mkinstalldirs
+PWD_COMMAND = $${PWDCMD-pwd}
+STAMP = echo timestamp >
+toolexecdir = $(glibcxx_toolexecdir)
+toolexeclibdir = $(glibcxx_toolexeclibdir)
+@ENABLE_WERROR_FALSE@WERROR_FLAG = 
+@ENABLE_WERROR_TRUE@WERROR_FLAG = $(WERROR)
+@ENABLE_EXTERN_TEMPLATE_FALSE@XTEMPLATE_FLAGS = 
+@ENABLE_EXTERN_TEMPLATE_TRUE@XTEMPLATE_FLAGS = -fno-implicit-templates
+
+# These bits are all figured out from configure.  Look in acinclude.m4
+# or configure.ac to see how they are set.  See GLIBCXX_EXPORT_FLAGS.
+CONFIG_CXXFLAGS = \
+	$(SECTION_FLAGS) $(HWCAP_FLAGS) -frandom-seed=$@
+
+WARN_CXXFLAGS = \
+	$(WARN_FLAGS) $(WERROR_FLAG) -fdiagnostics-show-location=once 
+
+
+# -I/-D flags to pass when compiling.
+AM_CPPFLAGS = $(GLIBCXX_INCLUDES)
+
+# Standard C++ includes.
+std_srcdir = ${glibcxx_srcdir}/include/std
+std_builddir = .
+std_headers = \
+	${std_srcdir}/algorithm \
+	${std_srcdir}/array \
+	${std_srcdir}/atomic \
+	${std_srcdir}/bitset \
+	${std_srcdir}/chrono \
+	${std_srcdir}/complex \
+	${std_srcdir}/condition_variable \
+	${std_srcdir}/deque \
+	${std_srcdir}/forward_list \
+	${std_srcdir}/fstream \
+	${std_srcdir}/functional \
+	${std_srcdir}/future \
+	${std_srcdir}/iomanip \
+	${std_srcdir}/ios \
+	${std_srcdir}/iosfwd \
+	${std_srcdir}/iostream \
+	${std_srcdir}/istream \
+	${std_srcdir}/iterator \
+	${std_srcdir}/limits \
+	${std_srcdir}/list \
+	${std_srcdir}/locale \
+	${std_srcdir}/map \
+	${std_srcdir}/memory \
+	${std_srcdir}/mutex \
+	${std_srcdir}/numeric \
+	${std_srcdir}/ostream \
+	${std_srcdir}/queue \
+	${std_srcdir}/random \
+	${std_srcdir}/ratio \
+	${std_srcdir}/regex \
+	${std_srcdir}/scoped_allocator \
+	${std_srcdir}/set \
+	${std_srcdir}/shared_mutex \
+	${std_srcdir}/sstream \
+	${std_srcdir}/stack \
+	${std_srcdir}/stdexcept \
+	${std_srcdir}/streambuf \
+	${std_srcdir}/string \
+	${std_srcdir}/system_error \
+	${std_srcdir}/thread \
+	${std_srcdir}/tuple \
+	${std_srcdir}/typeindex \
+	${std_srcdir}/type_traits \
+	${std_srcdir}/unordered_map \
+	${std_srcdir}/unordered_set \
+	${std_srcdir}/utility \
+	${std_srcdir}/valarray \
+	${std_srcdir}/vector
+
+bits_srcdir = ${glibcxx_srcdir}/include/bits
+bits_builddir = ./bits
+bits_headers = \
+	${bits_srcdir}/algorithmfwd.h \
+	${bits_srcdir}/alloc_traits.h \
+	${bits_srcdir}/allocator.h \
+	${bits_srcdir}/atomic_base.h \
+	${bits_srcdir}/basic_ios.h \
+	${bits_srcdir}/basic_ios.tcc \
+	${bits_srcdir}/basic_string.h \
+	${bits_srcdir}/basic_string.tcc \
+	${bits_srcdir}/boost_concept_check.h \
+	${bits_srcdir}/c++0x_warning.h \
+	${bits_srcdir}/c++14_warning.h \
+	${bits_srcdir}/char_traits.h \
+	${bits_srcdir}/codecvt.h \
+	${bits_srcdir}/concept_check.h \
+	${bits_srcdir}/cpp_type_traits.h \
+	${bits_srcdir}/deque.tcc \
+	${bits_srcdir}/enable_special_members.h \
+	${bits_srcdir}/forward_list.h \
+	${bits_srcdir}/forward_list.tcc \
+	${bits_srcdir}/fstream.tcc \
+	${bits_srcdir}/functexcept.h \
+	${bits_srcdir}/functional_hash.h \
+	${bits_srcdir}/gslice.h \
+	${bits_srcdir}/gslice_array.h \
+	${bits_srcdir}/hashtable.h \
+	${bits_srcdir}/hashtable_policy.h \
+	${bits_srcdir}/indirect_array.h \
+	${bits_srcdir}/ios_base.h \
+	${bits_srcdir}/istream.tcc \
+	${bits_srcdir}/list.tcc \
+	${bits_srcdir}/locale_classes.h \
+	${bits_srcdir}/locale_classes.tcc \
+	${bits_srcdir}/locale_facets.h \
+	${bits_srcdir}/locale_facets.tcc \
+	${bits_srcdir}/locale_facets_nonio.h \
+	${bits_srcdir}/locale_facets_nonio.tcc \
+	${bits_srcdir}/localefwd.h \
+	${bits_srcdir}/mask_array.h \
+	${bits_srcdir}/memoryfwd.h \
+	${bits_srcdir}/move.h \
+	${bits_srcdir}/ostream.tcc \
+	${bits_srcdir}/ostream_insert.h \
+	${bits_srcdir}/parse_numbers.h \
+	${bits_srcdir}/postypes.h \
+	${bits_srcdir}/predefined_ops.h \
+	${bits_srcdir}/ptr_traits.h \
+	${bits_srcdir}/random.h \
+	${bits_srcdir}/random.tcc \
+	${bits_srcdir}/range_access.h \
+	${bits_srcdir}/regex.h \
+	${bits_srcdir}/regex.tcc \
+	${bits_srcdir}/regex_constants.h \
+	${bits_srcdir}/regex_error.h \
+	${bits_srcdir}/regex_scanner.h \
+	${bits_srcdir}/regex_scanner.tcc \
+	${bits_srcdir}/regex_automaton.h \
+	${bits_srcdir}/regex_automaton.tcc \
+	${bits_srcdir}/regex_compiler.h \
+	${bits_srcdir}/regex_compiler.tcc \
+	${bits_srcdir}/regex_executor.h \
+	${bits_srcdir}/regex_executor.tcc \
+	${bits_srcdir}/stream_iterator.h \
+	${bits_srcdir}/streambuf_iterator.h \
+	${bits_srcdir}/shared_ptr.h \
+	${bits_srcdir}/shared_ptr_base.h \
+	${bits_srcdir}/slice_array.h \
+	${bits_srcdir}/sstream.tcc \
+	${bits_srcdir}/stl_algo.h \
+	${bits_srcdir}/stl_algobase.h \
+	${bits_srcdir}/stl_bvector.h \
+	${bits_srcdir}/stl_construct.h \
+	${bits_srcdir}/stl_deque.h \
+	${bits_srcdir}/stl_function.h \
+	${bits_srcdir}/stl_heap.h \
+	${bits_srcdir}/stl_iterator.h \
+	${bits_srcdir}/stl_iterator_base_funcs.h \
+	${bits_srcdir}/stl_iterator_base_types.h \
+	${bits_srcdir}/stl_list.h \
+	${bits_srcdir}/stl_map.h \
+	${bits_srcdir}/stl_multimap.h \
+	${bits_srcdir}/stl_multiset.h \
+	${bits_srcdir}/stl_numeric.h \
+	${bits_srcdir}/stl_pair.h \
+	${bits_srcdir}/stl_queue.h \
+	${bits_srcdir}/stl_raw_storage_iter.h \
+	${bits_srcdir}/stl_relops.h \
+	${bits_srcdir}/stl_set.h \
+	${bits_srcdir}/stl_stack.h \
+	${bits_srcdir}/stl_tempbuf.h \
+	${bits_srcdir}/stl_tree.h \
+	${bits_srcdir}/stl_uninitialized.h \
+	${bits_srcdir}/stl_vector.h \
+	${bits_srcdir}/streambuf.tcc \
+	${bits_srcdir}/stringfwd.h \
+	${bits_srcdir}/unique_ptr.h \
+	${bits_srcdir}/unordered_map.h \
+	${bits_srcdir}/unordered_set.h \
+	${bits_srcdir}/uses_allocator.h \
+	${bits_srcdir}/valarray_array.h \
+	${bits_srcdir}/valarray_array.tcc \
+	${bits_srcdir}/valarray_before.h \
+	${bits_srcdir}/valarray_after.h \
+	${bits_srcdir}/vector.tcc
+
+bits_host_headers = \
+	${glibcxx_srcdir}/${CPU_OPT_BITS_RANDOM}
+
+bits_sup_srcdir = ${glibcxx_srcdir}/libsupc++
+bits_sup_headers = \
+	${bits_sup_srcdir}/atomic_lockfree_defines.h \
+	${bits_sup_srcdir}/cxxabi_forced.h \
+	${bits_sup_srcdir}/exception_defines.h \
+	${bits_sup_srcdir}/exception_ptr.h \
+	${bits_sup_srcdir}/hash_bytes.h \
+	${bits_sup_srcdir}/nested_exception.h
+
+backward_srcdir = ${glibcxx_srcdir}/include/backward
+backward_builddir = ./backward
+backward_headers = \
+	${backward_srcdir}/auto_ptr.h \
+	${backward_srcdir}/backward_warning.h \
+	${backward_srcdir}/binders.h \
+	${backward_srcdir}/hash_map \
+	${backward_srcdir}/hash_set \
+	${backward_srcdir}/hash_fun.h \
+	${backward_srcdir}/hashtable.h \
+	${backward_srcdir}/strstream
+
+pb_srcdir = ${glibcxx_srcdir}/include/ext/pb_ds
+pb_builddir = ./ext/pb_ds
+pb_subdirs = \
+	${pb_builddir}/detail \
+	${pb_builddir}/detail/pairing_heap_ \
+	${pb_builddir}/detail/splay_tree_ \
+	${pb_builddir}/detail/list_update_map_ \
+	${pb_builddir}/detail/branch_policy \
+	${pb_builddir}/detail/trie_policy \
+	${pb_builddir}/detail/gp_hash_table_map_ \
+	${pb_builddir}/detail/tree_policy \
+	${pb_builddir}/detail/binomial_heap_base_ \
+	${pb_builddir}/detail/resize_policy \
+	${pb_builddir}/detail/bin_search_tree_ \
+	${pb_builddir}/detail/binomial_heap_ \
+	${pb_builddir}/detail/thin_heap_ \
+	${pb_builddir}/detail/pat_trie_ \
+	${pb_builddir}/detail/cc_hash_table_map_ \
+	${pb_builddir}/detail/rc_binomial_heap_ \
+	${pb_builddir}/detail/left_child_next_sibling_heap_ \
+	${pb_builddir}/detail/unordered_iterator \
+	${pb_builddir}/detail/binary_heap_ \
+	${pb_builddir}/detail/ov_tree_map_ \
+	${pb_builddir}/detail/hash_fn \
+	${pb_builddir}/detail/eq_fn \
+	${pb_builddir}/detail/rb_tree_map_ \
+	${pb_builddir}/detail/list_update_policy
+
+
+# The ability for make and the underlying host to deal with this
+# unwieldy list as one entire entity is not a sure thing, and may
+# cause build errors. Thus, split one list into many smaller
+# mini-lists, with the maximum size per mini-list of no more than 42.
+pb_headers1 = \
+	${pb_srcdir}/assoc_container.hpp \
+	${pb_srcdir}/exception.hpp \
+	${pb_srcdir}/hash_policy.hpp \
+	${pb_srcdir}/list_update_policy.hpp \
+	${pb_srcdir}/priority_queue.hpp \
+	${pb_srcdir}/tag_and_trait.hpp \
+	${pb_srcdir}/tree_policy.hpp \
+	${pb_srcdir}/trie_policy.hpp \
+	${pb_srcdir}/detail/branch_policy/branch_policy.hpp \
+	${pb_srcdir}/detail/branch_policy/null_node_metadata.hpp \
+	${pb_srcdir}/detail/branch_policy/traits.hpp \
+	${pb_srcdir}/detail/binary_heap_/binary_heap_.hpp \
+	${pb_srcdir}/detail/binary_heap_/const_iterator.hpp \
+	${pb_srcdir}/detail/binary_heap_/point_const_iterator.hpp \
+	${pb_srcdir}/detail/binary_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/entry_cmp.hpp \
+	${pb_srcdir}/detail/binary_heap_/entry_pred.hpp \
+	${pb_srcdir}/detail/binary_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/resize_policy.hpp \
+	${pb_srcdir}/detail/binary_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/binary_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/binomial_heap_base_.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_base_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_/binomial_heap_.hpp \
+	${pb_srcdir}/detail/binomial_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/binomial_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/bin_search_tree_.hpp
+
+pb_headers2 = \
+	${pb_srcdir}/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/node_iterators.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/point_iterators.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/r_erase_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/rotate_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/bin_search_tree_/traits.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/cc_ht_map_.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/cmp_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/cond_key_dtor_entry_dealtor.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/entry_list_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/find_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/resize_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/resize_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/cc_hash_table_map_/size_fn_imps.hpp
+
+pb_headers3 = \
+	${pb_srcdir}/detail/cc_hash_table_map_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/cond_dealtor.hpp \
+	${pb_srcdir}/detail/container_base_dispatch.hpp \
+	${pb_srcdir}/detail/eq_fn/eq_by_less.hpp \
+	${pb_srcdir}/detail/eq_fn/hash_eq_fn.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/find_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/find_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/gp_ht_map_.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/iterator_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/resize_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp \
+	${pb_srcdir}/detail/gp_hash_table_map_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/hash_fn/direct_mask_range_hashing_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/direct_mod_range_hashing_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/linear_probe_fn_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/mask_based_range_hashing.hpp \
+	${pb_srcdir}/detail/hash_fn/mod_based_range_hashing.hpp \
+	${pb_srcdir}/detail/hash_fn/probe_fn_base.hpp \
+	${pb_srcdir}/detail/hash_fn/quadratic_probe_fn_imp.hpp \
+	${pb_srcdir}/detail/hash_fn/ranged_hash_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/ranged_probe_fn.hpp
+
+pb_headers4 = \
+	${pb_srcdir}/detail/hash_fn/sample_probe_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/sample_ranged_hash_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/sample_ranged_probe_fn.hpp \
+	${pb_srcdir}/detail/hash_fn/sample_range_hashing.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/const_iterator.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/point_const_iterator.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/node.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/constructor_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/entry_metadata_base.hpp \
+	${pb_srcdir}/detail/list_update_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_map_/lu_map_.hpp \
+	${pb_srcdir}/detail/list_update_map_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/list_update_policy/lu_counter_metadata.hpp \
+	${pb_srcdir}/detail/list_update_policy/sample_update_policy.hpp \
+	${pb_srcdir}/detail/debug_map_base.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/node_iterators.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/ov_tree_map_.hpp
+
+pb_headers5 = \
+	${pb_srcdir}/detail/ov_tree_map_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/ov_tree_map_/traits.hpp \
+	${pb_srcdir}/detail/pairing_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/pairing_heap_/pairing_heap_.hpp \
+	${pb_srcdir}/detail/pairing_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/insert_join_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/iterators_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/pat_trie_.hpp \
+	${pb_srcdir}/detail/pat_trie_/pat_trie_base.hpp \
+	${pb_srcdir}/detail/pat_trie_/policy_access_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/r_erase_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/rotate_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/split_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/synth_access_traits.hpp \
+	${pb_srcdir}/detail/pat_trie_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/pat_trie_/traits.hpp \
+	${pb_srcdir}/detail/pat_trie_/update_fn_imps.hpp \
+	${pb_srcdir}/detail/priority_queue_base_dispatch.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/debug_fn_imps.hpp
+
+pb_headers6 = \
+	${pb_srcdir}/detail/rb_tree_map_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/node.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/rb_tree_.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/rb_tree_map_/traits.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/rc_binomial_heap_.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/rc.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/rc_binomial_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_exponential_size_policy_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_prime_size_policy_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/hash_standard_resize_policy_imp.hpp \
+	${pb_srcdir}/detail/resize_policy/sample_resize_policy.hpp \
+	${pb_srcdir}/detail/resize_policy/sample_resize_trigger.hpp \
+	${pb_srcdir}/detail/resize_policy/sample_size_policy.hpp \
+	${pb_srcdir}/detail/splay_tree_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/erase_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/info_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/node.hpp \
+	${pb_srcdir}/detail/splay_tree_/splay_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/splay_tree_.hpp \
+	${pb_srcdir}/detail/splay_tree_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/splay_tree_/traits.hpp \
+	${pb_srcdir}/detail/standard_policies.hpp \
+	${pb_srcdir}/detail/thin_heap_/constructors_destructor_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/debug_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/erase_fn_imps.hpp
+
+pb_headers7 = \
+	${pb_srcdir}/detail/thin_heap_/find_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/insert_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/split_join_fn_imps.hpp \
+	${pb_srcdir}/detail/thin_heap_/thin_heap_.hpp \
+	${pb_srcdir}/detail/thin_heap_/trace_fn_imps.hpp \
+	${pb_srcdir}/detail/tree_policy/node_metadata_selector.hpp \
+	${pb_srcdir}/detail/tree_policy/order_statistics_imp.hpp \
+	${pb_srcdir}/detail/tree_policy/sample_tree_node_update.hpp \
+	${pb_srcdir}/detail/tree_trace_base.hpp \
+	${pb_srcdir}/detail/trie_policy/node_metadata_selector.hpp \
+	${pb_srcdir}/detail/trie_policy/order_statistics_imp.hpp \
+	${pb_srcdir}/detail/trie_policy/prefix_search_node_update_imp.hpp \
+	${pb_srcdir}/detail/trie_policy/sample_trie_access_traits.hpp \
+	${pb_srcdir}/detail/trie_policy/sample_trie_node_update.hpp \
+	${pb_srcdir}/detail/trie_policy/trie_string_access_traits_imp.hpp \
+	${pb_srcdir}/detail/trie_policy/trie_policy_base.hpp \
+	${pb_srcdir}/detail/types_traits.hpp \
+	${pb_srcdir}/detail/type_utils.hpp \
+	${pb_srcdir}/detail/unordered_iterator/const_iterator.hpp \
+	${pb_srcdir}/detail/unordered_iterator/point_const_iterator.hpp \
+	${pb_srcdir}/detail/unordered_iterator/iterator.hpp \
+	${pb_srcdir}/detail/unordered_iterator/point_iterator.hpp
+
+ext_srcdir = ${glibcxx_srcdir}/include/ext
+ext_builddir = ./ext
+ext_headers = \
+	${ext_srcdir}/algorithm \
+	${ext_srcdir}/aligned_buffer.h \
+	${ext_srcdir}/alloc_traits.h \
+	${ext_srcdir}/atomicity.h \
+	${ext_srcdir}/array_allocator.h \
+	${ext_srcdir}/bitmap_allocator.h \
+	${ext_srcdir}/cast.h \
+	${ext_srcdir}/cmath \
+	${ext_srcdir}/codecvt_specializations.h \
+	${ext_srcdir}/concurrence.h \
+	${ext_srcdir}/debug_allocator.h \
+	${ext_srcdir}/enc_filebuf.h \
+	${ext_srcdir}/extptr_allocator.h \
+	${ext_srcdir}/stdio_filebuf.h \
+	${ext_srcdir}/stdio_sync_filebuf.h \
+	${ext_srcdir}/functional \
+	${ext_srcdir}/iterator \
+	${ext_srcdir}/malloc_allocator.h \
+	${ext_srcdir}/memory \
+	${ext_srcdir}/mt_allocator.h \
+	${ext_srcdir}/new_allocator.h \
+	${ext_srcdir}/numeric \
+	${ext_srcdir}/numeric_traits.h \
+	${ext_srcdir}/pod_char_traits.h \
+	${ext_srcdir}/pointer.h \
+	${ext_srcdir}/pool_allocator.h \
+	${ext_srcdir}/rb_tree \
+	${ext_srcdir}/random \
+	${ext_srcdir}/random.tcc \
+	${ext_srcdir}/rope \
+	${ext_srcdir}/ropeimpl.h \
+	${ext_srcdir}/slist \
+	${ext_srcdir}/string_conversions.h \
+	${ext_srcdir}/throw_allocator.h \
+	${ext_srcdir}/typelist.h \
+	${ext_srcdir}/type_traits.h \
+	${ext_srcdir}/rc_string_base.h \
+	${ext_srcdir}/sso_string_base.h \
+	${ext_srcdir}/vstring.h \
+	${ext_srcdir}/vstring.tcc \
+	${ext_srcdir}/vstring_fwd.h \
+	${ext_srcdir}/vstring_util.h \
+	${ext_compat_headers}
+
+ext_compat_headers = \
+	${backward_srcdir}/hash_set \
+	${backward_srcdir}/hash_map
+
+ext_host_headers = \
+	${glibcxx_srcdir}/${CPU_OPT_EXT_RANDOM}
+
+tr1_srcdir = ${glibcxx_srcdir}/include/tr1
+tr1_builddir = ./tr1
+tr1_headers = \
+	${tr1_srcdir}/array \
+	${tr1_srcdir}/bessel_function.tcc \
+	${tr1_srcdir}/beta_function.tcc \
+	${tr1_srcdir}/ccomplex \
+	${tr1_srcdir}/cctype \
+	${tr1_srcdir}/cfenv \
+	${tr1_srcdir}/cfloat \
+	${tr1_srcdir}/cinttypes \
+	${tr1_srcdir}/climits \
+	${tr1_srcdir}/cmath \
+	${tr1_srcdir}/complex \
+	${tr1_srcdir}/complex.h \
+	${tr1_srcdir}/cstdarg \
+	${tr1_srcdir}/cstdbool \
+	${tr1_srcdir}/cstdint \
+	${tr1_srcdir}/cstdio \
+	${tr1_srcdir}/cstdlib \
+	${tr1_srcdir}/ctgmath \
+	${tr1_srcdir}/ctime \
+	${tr1_srcdir}/ctype.h \
+	${tr1_srcdir}/cwchar \
+	${tr1_srcdir}/cwctype \
+	${tr1_srcdir}/ell_integral.tcc \
+	${tr1_srcdir}/exp_integral.tcc \
+	${tr1_srcdir}/fenv.h \
+	${tr1_srcdir}/float.h \
+	${tr1_srcdir}/functional \
+	${tr1_srcdir}/functional_hash.h \
+	${tr1_srcdir}/gamma.tcc \
+	${tr1_srcdir}/hypergeometric.tcc \
+	${tr1_srcdir}/hashtable.h \
+	${tr1_srcdir}/hashtable_policy.h \
+	${tr1_srcdir}/inttypes.h \
+	${tr1_srcdir}/limits.h \
+	${tr1_srcdir}/math.h \
+	${tr1_srcdir}/memory \
+	${tr1_srcdir}/modified_bessel_func.tcc \
+	${tr1_srcdir}/poly_hermite.tcc \
+	${tr1_srcdir}/poly_laguerre.tcc \
+	${tr1_srcdir}/legendre_function.tcc \
+	${tr1_srcdir}/random \
+	${tr1_srcdir}/random.h \
+	${tr1_srcdir}/random.tcc \
+	${tr1_srcdir}/regex \
+	${tr1_srcdir}/riemann_zeta.tcc \
+	${tr1_srcdir}/shared_ptr.h \
+	${tr1_srcdir}/special_function_util.h \
+	${tr1_srcdir}/stdarg.h \
+	${tr1_srcdir}/stdbool.h \
+	${tr1_srcdir}/stdint.h \
+	${tr1_srcdir}/stdio.h \
+	${tr1_srcdir}/stdlib.h \
+	${tr1_srcdir}/tgmath.h \
+	${tr1_srcdir}/tuple \
+	${tr1_srcdir}/type_traits \
+	${tr1_srcdir}/unordered_map \
+	${tr1_srcdir}/unordered_map.h \
+	${tr1_srcdir}/unordered_set \
+	${tr1_srcdir}/unordered_set.h \
+	${tr1_srcdir}/utility \
+	${tr1_srcdir}/wchar.h \
+	${tr1_srcdir}/wctype.h
+
+tr2_srcdir = ${glibcxx_srcdir}/include/tr2
+tr2_builddir = ./tr2
+tr2_headers = \
+	${tr2_srcdir}/bool_set \
+	${tr2_srcdir}/bool_set.tcc \
+	${tr2_srcdir}/dynamic_bitset \
+	${tr2_srcdir}/dynamic_bitset.tcc \
+	${tr2_srcdir}/ratio \
+	${tr2_srcdir}/type_traits
+
+decimal_srcdir = ${glibcxx_srcdir}/include/decimal
+decimal_builddir = ./decimal
+decimal_headers = \
+	${decimal_srcdir}/decimal \
+	${decimal_srcdir}/decimal.h
+
+
+# Post-C++11 TS's
+experimental_srcdir = ${glibcxx_srcdir}/include/experimental
+experimental_builddir = ./experimental
+experimental_headers = \
+	${experimental_srcdir}/optional \
+	${experimental_srcdir}/string_view \
+	${experimental_srcdir}/string_view.tcc
+
+
+# This is the common subset of C++ files that all three "C" header models use.
+c_base_srcdir = $(C_INCLUDE_DIR)
+c_base_builddir = .
+c_base_headers = \
+	${c_base_srcdir}/cassert \
+	${c_base_srcdir}/ccomplex \
+	${c_base_srcdir}/cctype \
+	${c_base_srcdir}/cerrno \
+	${c_base_srcdir}/cfenv \
+	${c_base_srcdir}/cfloat \
+	${c_base_srcdir}/cinttypes \
+	${c_base_srcdir}/ciso646 \
+	${c_base_srcdir}/climits \
+	${c_base_srcdir}/clocale \
+	${c_base_srcdir}/cmath \
+	${c_base_srcdir}/csetjmp \
+	${c_base_srcdir}/csignal \
+	${c_base_srcdir}/cstdalign \
+	${c_base_srcdir}/cstdarg \
+	${c_base_srcdir}/cstdbool \
+	${c_base_srcdir}/cstddef \
+	${c_base_srcdir}/cstdint \
+	${c_base_srcdir}/cstdio \
+	${c_base_srcdir}/cstdlib \
+	${c_base_srcdir}/cstring \
+	${c_base_srcdir}/ctgmath \
+	${c_base_srcdir}/ctime \
+	${c_base_srcdir}/cwchar \
+	${c_base_srcdir}/cwctype
+
+
+# "C" compatibility headers.
+c_compatibility_srcdir = ${glibcxx_srcdir}/include/c_compatibility
+c_compatibility_builddir = .
+@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@c_compatibility_headers = \
+@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@	${c_compatibility_srcdir}/complex.h \
+@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@	${c_compatibility_srcdir}/fenv.h \
+@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@	${c_compatibility_srcdir}/tgmath.h
+
+@GLIBCXX_C_HEADERS_C_STD_TRUE@c_compatibility_headers = 
+@GLIBCXX_C_HEADERS_C_TRUE@c_compatibility_headers = \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/assert.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/complex.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/ctype.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/errno.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/fenv.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/float.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/inttypes.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/iso646.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/limits.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/locale.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/math.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/setjmp.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/signal.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/stdarg.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/stdbool.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/stddef.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/stdint.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/stdio.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/stdlib.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/string.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/tgmath.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/time.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/wchar.h \
+@GLIBCXX_C_HEADERS_C_TRUE@	${c_compatibility_srcdir}/wctype.h
+
+
+# Debug mode headers
+debug_srcdir = ${glibcxx_srcdir}/include/debug
+debug_builddir = ./debug
+debug_headers = \
+	${debug_srcdir}/array \
+	${debug_srcdir}/bitset \
+	${debug_srcdir}/debug.h \
+	${debug_srcdir}/deque \
+	${debug_srcdir}/formatter.h \
+	${debug_srcdir}/forward_list \
+	${debug_srcdir}/functions.h \
+	${debug_srcdir}/list \
+	${debug_srcdir}/map \
+	${debug_srcdir}/macros.h \
+	${debug_srcdir}/map.h \
+	${debug_srcdir}/multimap.h \
+	${debug_srcdir}/multiset.h \
+	${debug_srcdir}/safe_base.h \
+	${debug_srcdir}/safe_iterator.h \
+	${debug_srcdir}/safe_iterator.tcc \
+	${debug_srcdir}/safe_local_iterator.h \
+	${debug_srcdir}/safe_local_iterator.tcc \
+	${debug_srcdir}/safe_sequence.h \
+	${debug_srcdir}/safe_sequence.tcc \
+	${debug_srcdir}/safe_unordered_base.h \
+	${debug_srcdir}/safe_unordered_container.h \
+	${debug_srcdir}/safe_unordered_container.tcc \
+	${debug_srcdir}/set \
+	${debug_srcdir}/set.h \
+	${debug_srcdir}/string \
+	${debug_srcdir}/unordered_map \
+	${debug_srcdir}/unordered_set \
+	${debug_srcdir}/vector
+
+
+# Parallel mode headers
+parallel_srcdir = ${glibcxx_srcdir}/include/parallel
+parallel_builddir = ./parallel
+parallel_headers = \
+	${parallel_srcdir}/algo.h \
+	${parallel_srcdir}/algobase.h \
+	${parallel_srcdir}/algorithm \
+	${parallel_srcdir}/algorithmfwd.h \
+	${parallel_srcdir}/balanced_quicksort.h \
+	${parallel_srcdir}/base.h \
+	${parallel_srcdir}/basic_iterator.h \
+	${parallel_srcdir}/checkers.h \
+	${parallel_srcdir}/compatibility.h \
+	${parallel_srcdir}/compiletime_settings.h \
+	${parallel_srcdir}/equally_split.h \
+	${parallel_srcdir}/features.h \
+	${parallel_srcdir}/find.h \
+	${parallel_srcdir}/find_selectors.h \
+	${parallel_srcdir}/for_each.h \
+	${parallel_srcdir}/for_each_selectors.h \
+	${parallel_srcdir}/iterator.h \
+	${parallel_srcdir}/list_partition.h \
+	${parallel_srcdir}/losertree.h \
+	${parallel_srcdir}/merge.h \
+	${parallel_srcdir}/multiseq_selection.h \
+	${parallel_srcdir}/multiway_merge.h \
+	${parallel_srcdir}/multiway_mergesort.h \
+	${parallel_srcdir}/numeric \
+	${parallel_srcdir}/numericfwd.h \
+	${parallel_srcdir}/omp_loop.h \
+	${parallel_srcdir}/omp_loop_static.h \
+	${parallel_srcdir}/par_loop.h \
+	${parallel_srcdir}/parallel.h \
+	${parallel_srcdir}/partial_sum.h \
+	${parallel_srcdir}/partition.h \
+	${parallel_srcdir}/queue.h \
+	${parallel_srcdir}/quicksort.h \
+	${parallel_srcdir}/random_number.h \
+	${parallel_srcdir}/random_shuffle.h \
+	${parallel_srcdir}/search.h \
+	${parallel_srcdir}/set_operations.h \
+	${parallel_srcdir}/settings.h \
+	${parallel_srcdir}/sort.h \
+	${parallel_srcdir}/tags.h \
+	${parallel_srcdir}/types.h \
+	${parallel_srcdir}/unique_copy.h \
+	${parallel_srcdir}/workstealing.h
+
+
+# Profile mode headers
+profile_srcdir = ${glibcxx_srcdir}/include/profile
+profile_builddir = ./profile
+profile_headers = \
+	${profile_srcdir}/array \
+	${profile_srcdir}/base.h \
+	${profile_srcdir}/unordered_base.h \
+	${profile_srcdir}/unordered_map \
+	${profile_srcdir}/unordered_set \
+	${profile_srcdir}/vector \
+	${profile_srcdir}/bitset \
+	${profile_srcdir}/deque \
+	${profile_srcdir}/forward_list \
+	${profile_srcdir}/list \
+	${profile_srcdir}/map \
+	${profile_srcdir}/map.h \
+	${profile_srcdir}/multimap.h \
+	${profile_srcdir}/multiset.h \
+	${profile_srcdir}/set \
+	${profile_srcdir}/set.h \
+	${profile_srcdir}/iterator_tracker.h
+
+profile_impl_srcdir = ${glibcxx_srcdir}/include/profile/impl
+profile_impl_builddir = ./profile/impl
+profile_impl_headers = \
+	${profile_impl_srcdir}/profiler.h \
+	${profile_impl_srcdir}/profiler_algos.h \
+	${profile_impl_srcdir}/profiler_container_size.h \
+	${profile_impl_srcdir}/profiler_hash_func.h \
+	${profile_impl_srcdir}/profiler_hashtable_size.h \
+	${profile_impl_srcdir}/profiler_map_to_unordered_map.h \
+	${profile_impl_srcdir}/profiler_node.h \
+	${profile_impl_srcdir}/profiler_state.h \
+	${profile_impl_srcdir}/profiler_trace.h \
+	${profile_impl_srcdir}/profiler_vector_size.h \
+	${profile_impl_srcdir}/profiler_vector_to_list.h \
+	${profile_impl_srcdir}/profiler_list_to_vector.h \
+	${profile_impl_srcdir}/profiler_list_to_slist.h
+
+@GLIBCXX_C_HEADERS_COMPATIBILITY_FALSE@c_compatibility_headers_extra = 
+
+# Some "C" header schemes require the "C" compatibility headers.
+# For --enable-cheaders=c_std
+@GLIBCXX_C_HEADERS_COMPATIBILITY_TRUE@c_compatibility_headers_extra = ${c_compatibility_headers}
+host_srcdir = ${glibcxx_srcdir}/$(OS_INC_SRCDIR)
+host_builddir = ./${host_alias}/bits
+host_installdir = ${gxx_include_dir}/${host_alias}$(MULTISUBDIR)/bits
+host_headers = \
+	${host_srcdir}/ctype_base.h \
+	${host_srcdir}/ctype_inline.h \
+	${host_srcdir}/os_defines.h \
+	${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \
+	${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
+	${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \
+	${glibcxx_srcdir}/$(ERROR_CONSTANTS_SRCDIR)/error_constants.h \
+	${glibcxx_srcdir}/include/precompiled/stdc++.h \
+	${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \
+	${glibcxx_srcdir}/include/precompiled/extc++.h
+
+
+# Non-installed host_header files.
+COMPATIBILITY_H = config/abi/compatibility.h
+host_headers_noinst = \
+	${glibcxx_srcdir}/$(CLOCALE_INTERNAL_H) \
+	${glibcxx_srcdir}/$(COMPATIBILITY_H)
+
+
+# These host_headers_extra files are all built with ad hoc naming rules.
+host_headers_extra = \
+	${host_builddir}/basic_file.h \
+	${host_builddir}/c++config.h \
+	${host_builddir}/c++allocator.h \
+	${host_builddir}/c++io.h \
+	${host_builddir}/c++locale.h \
+	${host_builddir}/messages_members.h \
+	${host_builddir}/time_members.h
+
+thread_host_headers = \
+	${host_builddir}/gthr.h \
+	${host_builddir}/gthr-single.h \
+	${host_builddir}/gthr-posix.h \
+	${host_builddir}/gthr-default.h
+
+pch1_source = ${glibcxx_srcdir}/include/precompiled/stdc++.h
+pch1_output_builddir = ${host_builddir}/stdc++.h.gch
+pch1_output_anchor = ${host_builddir}/stdc++.h
+pch1_output_installdir = ${host_installdir}/stdc++.h.gch
+pch1a_output = ${pch1_output_builddir}/O2ggnu++0x.gch
+pch1b_output = ${pch1_output_builddir}/O2g.gch
+pch1_output = ${pch1a_output} ${pch1b_output}
+pch2_source = ${glibcxx_srcdir}/include/precompiled/stdtr1c++.h
+pch2_output_builddir = ${host_builddir}/stdtr1c++.h.gch
+pch2_output_anchor = ${host_builddir}/stdtr1c++.h
+pch2_output_installdir = ${host_installdir}/stdtr1c++.h.gch
+pch2_output = ${pch2_output_builddir}/O2g.gch
+pch3_source = ${glibcxx_srcdir}/include/precompiled/extc++.h
+pch3_output_builddir = ${host_builddir}/extc++.h.gch
+pch3_output_anchor = ${host_builddir}/extc++.h
+pch3_output_installdir = ${host_installdir}/extc++.h.gch
+pch3_output = ${pch3_output_builddir}/O2g.gch
+pch_output = ${pch1_output} ${pch2_output} ${pch3_output}
+pch_output_dirs = \
+	${pch1_output_builddir} ${pch2_output_builddir} ${pch3_output_builddir}
+
+pch_output_anchors = \
+	${pch1_output_anchor} ${pch2_output_anchor} ${pch3_output_anchor}
+
+PCHFLAGS = -x c++-header -nostdinc++ $(CXXFLAGS) $(VTV_PCH_CXXFLAGS)
+@GLIBCXX_BUILD_PCH_FALSE@pch_build = 
+@GLIBCXX_BUILD_PCH_TRUE@pch_build = ${pch_output}
+
+# List of all timestamp files.  By keeping only one copy of this list, both
+# CLEANFILES and all-local are kept up-to-date.
+allstamped = \
+	stamp-std stamp-bits stamp-bits-sup stamp-c_base stamp-c_compatibility \
+	stamp-backward stamp-ext stamp-pb stamp-tr1 stamp-tr2 stamp-decimal \
+	stamp-experimental stamp-debug stamp-parallel stamp-profile \
+	stamp-profile-impl stamp-host
+
+
+# List of all files that are created by explicit building, editing, or
+# catenation.
+allcreated = \
+	${host_builddir}/c++config.h \
+	${thread_host_headers} \
+	${pch_build}
+
+
+# Host includes for threads
+uppercase = [ABCDEFGHIJKLMNOPQRSTUVWXYZ_]
+
+# By adding these files here, automake will remove them for 'make clean'
+CLEANFILES = ${pch_output} ${pch_output_anchors} stamp-host
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(top_srcdir)/fragment.am $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign --ignore-deps include/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign --ignore-deps include/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+tags: TAGS
+TAGS:
+
+ctags: CTAGS
+CTAGS:
+
+check-am: all-am
+check: check-am
+all-am: Makefile all-local
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-local mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-data-local
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: install-am install-strip
+
+.PHONY: all all-am all-local check check-am clean clean-generic \
+	clean-libtool clean-local distclean distclean-generic \
+	distclean-libtool dvi dvi-am html html-am info info-am install \
+	install-am install-data install-data-am install-data-local \
+	install-dvi install-dvi-am install-exec install-exec-am \
+	install-html install-html-am install-info install-info-am \
+	install-man install-pdf install-pdf-am install-ps \
+	install-ps-am install-strip installcheck installcheck-am \
+	installdirs maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
+	ps ps-am uninstall uninstall-am
+
+
+# Here are the rules for building the headers
+all-local: ${allstamped} ${allcreated}
+
+# Ignore errors from 'mkdir -p' to avoid parallel make failure on
+# systems with broken mkdir.  Call mkdir unconditionally because
+# it is just as cheap to avoid going through the shell.
+# Ignore errors from $(LN_S) because the links may already exist.
+stamp-std: ${std_headers}
+	@-mkdir -p ${std_builddir}
+	@-cd ${std_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-std
+
+stamp-bits: ${bits_headers}
+	@-mkdir -p ${bits_builddir}
+	@-cd ${bits_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-bits
+
+stamp-bits-sup: stamp-bits ${bits_sup_headers}
+	@-cd ${bits_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-bits-sup
+
+stamp-c_base: ${c_base_headers}
+	@-mkdir -p ${c_base_builddir}
+	@-cd ${c_base_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-c_base
+
+stamp-c_base_extra: ${c_base_headers_extra}
+	@-mkdir -p ${bits_builddir}
+	@-cd ${bits_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-c_base_extra
+
+stamp-c_compatibility: ${c_compatibility_headers_extra}
+	@-mkdir -p ${c_compatibility_builddir}
+	@-if [ ! -z "${c_compatibility_headers_extra}" ]; then \
+	  cd ${c_compatibility_builddir} && $(LN_S) $? . 2>/dev/null ;\
+	fi
+	@$(STAMP) stamp-c_compatibility
+
+stamp-backward: ${backward_headers}
+	@-mkdir -p ${backward_builddir}
+	@-cd ${backward_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-backward
+
+stamp-ext: ${ext_headers}
+	@-mkdir -p ${ext_builddir}
+	@-cd ${ext_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-ext
+
+# Have to deal with nested include directories, gah! Strip off source
+# directory before making the link.
+# XXX check  ${pb_headers}
+stamp-pb:
+	@if [ ! -d "${pb_builddir}" ]; then \
+	    mkdir -p ${pb_subdirs} ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers1}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers2}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers3}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers4}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers5}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers6}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	@if [ ! -f stamp-pb ]; then \
+	    cd ${pb_builddir} && for h in ${pb_headers7}; do \
+		build_name=`echo $$h | sed -e "s|${pb_srcdir}|.|g"` ;\
+		$(LN_S) $$h $${build_name} || true ;\
+	      done ;\
+	fi
+	$(STAMP) stamp-pb
+
+stamp-tr1: ${tr1_headers}
+	@-mkdir -p ${tr1_builddir}
+	@-cd ${tr1_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-tr1
+
+stamp-tr2: ${tr2_headers}
+	@-mkdir -p ${tr2_builddir}
+	@-cd ${tr2_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-tr2
+
+stamp-decimal: ${decimal_headers}
+	@-mkdir -p ${decimal_builddir}
+	@-cd ${decimal_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-decimal
+
+stamp-experimental: ${experimental_headers}
+	@-mkdir -p ${experimental_builddir}
+	@-cd ${experimental_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-experimental
+
+stamp-debug: ${debug_headers}
+	@-mkdir -p ${debug_builddir}
+	@-cd ${debug_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-debug
+
+stamp-parallel: ${parallel_headers}
+	@-mkdir -p ${parallel_builddir}
+	@-cd ${parallel_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-parallel
+
+stamp-profile: ${profile_headers}
+	@-mkdir -p ${profile_builddir}
+	@-cd ${profile_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-profile
+
+stamp-profile-impl: ${profile_impl_headers}
+	@-mkdir -p ${profile_impl_builddir}
+	@-cd ${profile_impl_builddir} && $(LN_S) $? . 2>/dev/null
+	@$(STAMP) stamp-profile-impl
+
+stamp-${host_alias}:
+	@-mkdir -p ${host_builddir}
+	@-mkdir -p ${host_builddir}/../ext
+	@$(STAMP) stamp-${host_alias}
+
+# Host includes static.
+# XXX Missing dependency info for {host_headers_extra}
+stamp-host: ${host_headers} ${bits_host_headers} ${ext_host_headers} ${host_headers_noinst} stamp-${host_alias}
+	@cd ${host_builddir} && {\
+	  $(LN_S) ${host_headers} ${bits_host_headers} . || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(BASIC_FILE_H) basic_file.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(ALLOCATOR_H) c++allocator.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CSTDIO_H) c++io.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CLOCALE_H) c++locale.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CLOCALE_INTERNAL_H) . || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(COMPATIBILITY_H) . || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CMESSAGES_H) messages_members.h || true ;\
+	  $(LN_S) ${glibcxx_srcdir}/$(CTIME_H) time_members.h || true;\
+	} 2>/dev/null
+	@cd ${host_builddir}/../ext && {\
+	  $(LN_S) ${ext_host_headers} . || true ;\
+	} 2>/dev/null
+	$(STAMP) stamp-host
+
+# Host includes dynamic.
+@ENABLE_SYMVERS_GNU_NAMESPACE_TRUE@stamp-namespace-version:
+@ENABLE_SYMVERS_GNU_NAMESPACE_TRUE@	echo 1 > stamp-namespace-version
+@ENABLE_SYMVERS_GNU_NAMESPACE_FALSE@stamp-namespace-version:
+@ENABLE_SYMVERS_GNU_NAMESPACE_FALSE@	echo 0 > stamp-namespace-version
+
+@ENABLE_EXTERN_TEMPLATE_TRUE@stamp-extern-template:
+@ENABLE_EXTERN_TEMPLATE_TRUE@	echo 1 > stamp-extern-template
+@ENABLE_EXTERN_TEMPLATE_FALSE@stamp-extern-template:
+@ENABLE_EXTERN_TEMPLATE_FALSE@	echo 0 > stamp-extern-template
+
+@ENABLE_VISIBILITY_TRUE@stamp-visibility:
+@ENABLE_VISIBILITY_TRUE@	echo 1 > stamp-visibility
+@ENABLE_VISIBILITY_FALSE@stamp-visibility:
+@ENABLE_VISIBILITY_FALSE@	echo 0 > stamp-visibility
+
+# NB: The non-empty default ldbl_compat works around an AIX sed
+# oddity, see libstdc++/31957 for details.
+${host_builddir}/c++config.h: ${CONFIG_HEADER} \
+			      ${glibcxx_srcdir}/include/bits/c++config \
+			      stamp-${host_alias} \
+			      ${toplevel_srcdir}/gcc/DATESTAMP \
+			      stamp-namespace-version \
+			      stamp-visibility \
+			      stamp-extern-template
+	@date=`cat ${toplevel_srcdir}/gcc/DATESTAMP` ;\
+	ns_version=`cat stamp-namespace-version` ;\
+	visibility=`cat stamp-visibility` ;\
+	externtemplate=`cat stamp-extern-template` ;\
+	ldbl_compat='s,g,g,' ;\
+	grep "^[	 ]*#[	 ]*define[	 ][	 ]*_GLIBCXX_LONG_DOUBLE_COMPAT[	 ][	 ]*1[	 ]*$$" \
+	${CONFIG_HEADER} > /dev/null 2>&1 \
+	&& ldbl_compat='s,^#undef _GLIBCXX_LONG_DOUBLE_COMPAT$$,#define _GLIBCXX_LONG_DOUBLE_COMPAT 1,' ;\
+	sed -e "s,define __GLIBCXX__,define __GLIBCXX__ $$date," \
+	-e "s,define _GLIBCXX_INLINE_VERSION, define _GLIBCXX_INLINE_VERSION $$ns_version," \
+	-e "s,define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY, define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY $$visibility," \
+	-e "s,define _GLIBCXX_EXTERN_TEMPLATE$$, define _GLIBCXX_EXTERN_TEMPLATE $$externtemplate," \
+	-e "$$ldbl_compat" \
+	    < ${glibcxx_srcdir}/include/bits/c++config > $@ ;\
+	sed -e 's/HAVE_/_GLIBCXX_HAVE_/g' \
+	    -e 's/PACKAGE/_GLIBCXX_PACKAGE/g' \
+	    -e 's/VERSION/_GLIBCXX_VERSION/g' \
+	    -e 's/WORDS_/_GLIBCXX_WORDS_/g' \
+	    -e 's/ICONV_CONST/_GLIBCXX_ICONV_CONST/g' \
+	    -e '/[	 ]_GLIBCXX_LONG_DOUBLE_COMPAT[	 ]/d' \
+	    < ${CONFIG_HEADER} >> $@ ;\
+	echo "" >> $@ ;\
+	echo "#endif // _GLIBCXX_CXX_CONFIG_H" >> $@
+
+${host_builddir}/gthr.h: ${toplevel_srcdir}/libgcc/gthr.h stamp-${host_alias}
+	sed -e '/^#pragma/b' \
+	    -e '/^#/s/\(${uppercase}${uppercase}*\)/_GLIBCXX_\1/g' \
+	    -e 's/_GLIBCXX_SUPPORTS_WEAK/__GXX_WEAK__/g' \
+	    -e 's/_GLIBCXX___MINGW32_GLIBCXX___/__MINGW32__/g' \
+	    -e 's,^#include "\(.*\)",#include <bits/\1>,g' \
+	    < $< > $@
+
+${host_builddir}/gthr-single.h: ${toplevel_srcdir}/libgcc/gthr-single.h \
+				  stamp-${host_alias}
+	sed -e 's/\(UNUSED\)/_GLIBCXX_\1/g' \
+	    -e 's/\(GCC${uppercase}*_H\)/_GLIBCXX_\1/g' \
+	    < $< > $@
+
+${host_builddir}/gthr-posix.h: ${toplevel_srcdir}/libgcc/gthr-posix.h \
+				   stamp-${host_alias}
+	sed -e 's/\(UNUSED\)/_GLIBCXX_\1/g' \
+	    -e 's/\(GCC${uppercase}*_H\)/_GLIBCXX_\1/g' \
+	    -e 's/SUPPORTS_WEAK/__GXX_WEAK__/g' \
+	    -e 's/\(${uppercase}*USE_WEAK\)/_GLIBCXX_\1/g' \
+	    < $< > $@
+
+${host_builddir}/gthr-default.h: ${toplevel_srcdir}/libgcc/${thread_header} \
+				   stamp-${host_alias}
+	sed -e 's/\(UNUSED\)/_GLIBCXX_\1/g' \
+	    -e 's/\(GCC${uppercase}*_H\)/_GLIBCXX_\1/g' \
+	    -e 's/SUPPORTS_WEAK/__GXX_WEAK__/g' \
+	    -e 's/\(${uppercase}*USE_WEAK\)/_GLIBCXX_\1/g' \
+	    -e 's,^#include "\(.*\)",#include <bits/\1>,g' \
+	    < $< > $@
+
+# Build two precompiled C++ includes, stdc++.h.gch/*.gch
+${pch1a_output}: ${allstamped} ${host_builddir}/c++config.h ${pch1_source}
+	-mkdir -p ${pch1_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g -std=gnu++0x ${pch1_source} \
+	-o $@
+
+${pch1b_output}: ${allstamped} ${host_builddir}/c++config.h ${pch1_source}
+	-mkdir -p ${pch1_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch1_source} -o $@
+
+# Build a precompiled TR1 include, stdtr1c++.h.gch/O2.gch
+${pch2_output}: ${pch2_source} ${pch1_output}
+	-mkdir -p ${pch2_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch2_source} -o $@
+
+# Build a precompiled extension include, extc++.h.gch/O2.gch
+${pch3_output}: ${pch3_source} ${pch2_output}
+	-mkdir -p ${pch3_output_builddir}
+	$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@
+
+# For robustness sake (in light of junk files or in-source
+# configuration), copy from the build or source tree to the install
+# tree using only the human-maintained file lists and directory
+# components.  Yes, with minor differences, this is sheer duplication
+# of the staging rules above using $(INSTALL_DATA) instead of LN_S and
+# `$(mkinstalldirs)' instead of `mkdir -p'.  In particular,
+# host_headers_extra are taken out of the build tree staging area;
+# the rest are taken from the original source tree.
+
+@GLIBCXX_HOSTED_TRUE@install-data-local: install-headers
+@GLIBCXX_HOSTED_FALSE@install-data-local: install-freestanding-headers
+
+# This is a subset of the full install-headers rule.  We only need <cstddef>,
+# <limits>, <cstdlib>, <cstdarg>, <new>, <typeinfo>, <exception>, and any
+# files which they include (and which we provide).  The last three headers
+# are installed by libsupc++, so only the first four and the sub-includes
+# are copied here.
+install-freestanding-headers:
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/bits
+	$(mkinstalldirs) $(DESTDIR)${host_installdir}
+	$(INSTALL_DATA) ${glibcxx_srcdir}/include/bits/c++0x_warning.h \
+	  $(DESTDIR)${gxx_include_dir}/bits
+	for file in ${host_srcdir}/os_defines.h ${host_builddir}/c++config.h \
+	  ${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
+	  ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${std_builddir}
+	$(INSTALL_DATA) ${std_builddir}/limits $(DESTDIR)${gxx_include_dir}/${std_builddir}
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
+	for file in cstddef cstdlib cstdarg; do \
+	  $(INSTALL_DATA) ${c_base_builddir}/$${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
+
+# The real deal.
+install-headers:
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${bits_builddir}
+	for file in ${bits_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${bits_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${backward_builddir}
+	for file in ${backward_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${backward_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${ext_builddir}
+	for file in ${ext_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${ext_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${pb_builddir}
+	for dir in ${pb_subdirs}; do \
+	  $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/$${dir} ; done
+	for file in ${pb_headers1}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers2}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers3}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers4}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers5}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers6}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	for file in ${pb_headers7}; do \
+	  install_base=$(DESTDIR)${gxx_include_dir}/${pb_builddir} ; \
+	  relative_name=`echo $$file | sed -e "s|${pb_srcdir}|.|g"` ;\
+	  $(INSTALL_DATA) $${file} $${install_base}/$${relative_name} ; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr1_builddir}
+	for file in ${tr1_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr1_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${tr2_builddir}
+	for file in ${tr2_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${tr2_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${decimal_builddir}
+	for file in ${decimal_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${decimal_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${experimental_builddir}
+	for file in ${experimental_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${experimental_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
+	for file in ${c_base_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
+	c_base_headers_extra_install='$(c_base_headers_extra)';\
+	for file in $$c_base_headers_extra_install; do \
+	  $(INSTALL_DATA) $$file $(DESTDIR)${gxx_include_dir}/${bits_builddir}; done
+	c_compatibility_headers_install='$(c_compatibility_headers_extra)';\
+	for file in $$c_compatibility_headers_install; do \
+	  $(INSTALL_DATA) $$file $(DESTDIR)${gxx_include_dir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${std_builddir}
+	for file in ${std_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${std_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${debug_builddir}
+	for file in ${debug_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${debug_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${parallel_builddir}
+	for file in ${parallel_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${parallel_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_builddir}
+	for file in ${profile_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir}
+	for file in ${profile_impl_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${profile_impl_builddir}; done
+	$(mkinstalldirs) $(DESTDIR)${host_installdir}
+	for file in ${host_headers} ${bits_host_headers} ${host_headers_extra} \
+	 ${thread_host_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
+	$(mkinstalldirs) $(DESTDIR)${host_installdir}/../ext
+	for file in ${ext_host_headers}; do \
+	  $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}/../ext; done
+
+# To remove directories.
+clean-local:
+	rm -rf ${pch_output_dirs}
+
+# Stop implicit '.o' make rules from ever stomping on extensionless
+# headers, in the improbable case where some foolish, crack-addled
+# developer tries to create them via make in the include build
+# directory. (This is more of an example of how this kind of rule can
+# be made.)
+.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr2_headers)
+	   $(decimal_headers) $(ext_headers) $(experimental_headers)
+$(std_headers): ; @:
+$(c_base_headers): ; @:
+$(tr1_headers): ; @:
+$(decimal_headers): ; @:
+$(ext_headers): ; @:
+$(experimental_headers): ; @:
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/gcc-4.9/libstdc++-v3/include/backward/auto_ptr.h b/gcc-4.9/libstdc++-v3/include/backward/auto_ptr.h
new file mode 100644
index 0000000..d7ae487
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/auto_ptr.h
@@ -0,0 +1,329 @@
+// auto_ptr implementation -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file backward/auto_ptr.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _BACKWARD_AUTO_PTR_H
+#define _BACKWARD_AUTO_PTR_H 1
+
+#include <bits/c++config.h>
+#include <debug/debug.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  A wrapper class to provide auto_ptr with reference semantics.
+   *  For example, an auto_ptr can be assigned (or constructed from)
+   *  the result of a function which returns an auto_ptr by value.
+   *
+   *  All the auto_ptr_ref stuff should happen behind the scenes.
+   */
+  template<typename _Tp1>
+    struct auto_ptr_ref
+    {
+      _Tp1* _M_ptr;
+      
+      explicit
+      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
+    } _GLIBCXX_DEPRECATED;
+
+
+  /**
+   *  @brief  A simple smart pointer providing strict ownership semantics.
+   *
+   *  The Standard says:
+   *  <pre>
+   *  An @c auto_ptr owns the object it holds a pointer to.  Copying
+   *  an @c auto_ptr copies the pointer and transfers ownership to the
+   *  destination.  If more than one @c auto_ptr owns the same object
+   *  at the same time the behavior of the program is undefined.
+   *
+   *  The uses of @c auto_ptr include providing temporary
+   *  exception-safety for dynamically allocated memory, passing
+   *  ownership of dynamically allocated memory to a function, and
+   *  returning dynamically allocated memory from a function.  @c
+   *  auto_ptr does not meet the CopyConstructible and Assignable
+   *  requirements for Standard Library <a
+   *  href="tables.html#65">container</a> elements and thus
+   *  instantiating a Standard Library container with an @c auto_ptr
+   *  results in undefined behavior.
+   *  </pre>
+   *  Quoted from [20.4.5]/3.
+   *
+   *  Good examples of what can and cannot be done with auto_ptr can
+   *  be found in the libstdc++ testsuite.
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  127.  auto_ptr<> conversion issues
+   *  These resolutions have all been incorporated.
+   */
+  template<typename _Tp>
+    class auto_ptr
+    {
+    private:
+      _Tp* _M_ptr;
+      
+    public:
+      /// The pointed-to type.
+      typedef _Tp element_type;
+      
+      /**
+       *  @brief  An %auto_ptr is usually constructed from a raw pointer.
+       *  @param  __p  A pointer (defaults to NULL).
+       *
+       *  This object now @e owns the object pointed to by @a __p.
+       */
+      explicit
+      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
+
+      /**
+       *  @brief  An %auto_ptr can be constructed from another %auto_ptr.
+       *  @param  __a  Another %auto_ptr of the same type.
+       *
+       *  This object now @e owns the object previously owned by @a __a,
+       *  which has given up ownership.
+       */
+      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
+
+      /**
+       *  @brief  An %auto_ptr can be constructed from another %auto_ptr.
+       *  @param  __a  Another %auto_ptr of a different but related type.
+       *
+       *  A pointer-to-Tp1 must be convertible to a
+       *  pointer-to-Tp/element_type.
+       *
+       *  This object now @e owns the object previously owned by @a __a,
+       *  which has given up ownership.
+       */
+      template<typename _Tp1>
+        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
+
+      /**
+       *  @brief  %auto_ptr assignment operator.
+       *  @param  __a  Another %auto_ptr of the same type.
+       *
+       *  This object now @e owns the object previously owned by @a __a,
+       *  which has given up ownership.  The object that this one @e
+       *  used to own and track has been deleted.
+       */
+      auto_ptr&
+      operator=(auto_ptr& __a) throw()
+      {
+	reset(__a.release());
+	return *this;
+      }
+
+      /**
+       *  @brief  %auto_ptr assignment operator.
+       *  @param  __a  Another %auto_ptr of a different but related type.
+       *
+       *  A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
+       *
+       *  This object now @e owns the object previously owned by @a __a,
+       *  which has given up ownership.  The object that this one @e
+       *  used to own and track has been deleted.
+       */
+      template<typename _Tp1>
+        auto_ptr&
+        operator=(auto_ptr<_Tp1>& __a) throw()
+        {
+	  reset(__a.release());
+	  return *this;
+	}
+
+      /**
+       *  When the %auto_ptr goes out of scope, the object it owns is
+       *  deleted.  If it no longer owns anything (i.e., @c get() is
+       *  @c NULL), then this has no effect.
+       *
+       *  The C++ standard says there is supposed to be an empty throw
+       *  specification here, but omitting it is standard conforming.  Its
+       *  presence can be detected only if _Tp::~_Tp() throws, but this is
+       *  prohibited.  [17.4.3.6]/2
+       */
+      ~auto_ptr() { delete _M_ptr; }
+      
+      /**
+       *  @brief  Smart pointer dereferencing.
+       *
+       *  If this %auto_ptr no longer owns anything, then this
+       *  operation will crash.  (For a smart pointer, <em>no longer owns
+       *  anything</em> is the same as being a null pointer, and you know
+       *  what happens when you dereference one of those...)
+       */
+      element_type&
+      operator*() const throw() 
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	return *_M_ptr; 
+      }
+      
+      /**
+       *  @brief  Smart pointer dereferencing.
+       *
+       *  This returns the pointer itself, which the language then will
+       *  automatically cause to be dereferenced.
+       */
+      element_type*
+      operator->() const throw() 
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	return _M_ptr; 
+      }
+      
+      /**
+       *  @brief  Bypassing the smart pointer.
+       *  @return  The raw pointer being managed.
+       *
+       *  You can get a copy of the pointer that this object owns, for
+       *  situations such as passing to a function which only accepts
+       *  a raw pointer.
+       *
+       *  @note  This %auto_ptr still owns the memory.
+       */
+      element_type*
+      get() const throw() { return _M_ptr; }
+      
+      /**
+       *  @brief  Bypassing the smart pointer.
+       *  @return  The raw pointer being managed.
+       *
+       *  You can get a copy of the pointer that this object owns, for
+       *  situations such as passing to a function which only accepts
+       *  a raw pointer.
+       *
+       *  @note  This %auto_ptr no longer owns the memory.  When this object
+       *  goes out of scope, nothing will happen.
+       */
+      element_type*
+      release() throw()
+      {
+	element_type* __tmp = _M_ptr;
+	_M_ptr = 0;
+	return __tmp;
+      }
+      
+      /**
+       *  @brief  Forcibly deletes the managed object.
+       *  @param  __p  A pointer (defaults to NULL).
+       *
+       *  This object now @e owns the object pointed to by @a __p.  The
+       *  previous object has been deleted.
+       */
+      void
+      reset(element_type* __p = 0) throw()
+      {
+	if (__p != _M_ptr)
+	  {
+	    delete _M_ptr;
+	    _M_ptr = __p;
+	  }
+      }
+      
+      /** 
+       *  @brief  Automatic conversions
+       *
+       *  These operations convert an %auto_ptr into and from an auto_ptr_ref
+       *  automatically as needed.  This allows constructs such as
+       *  @code
+       *    auto_ptr<Derived>  func_returning_auto_ptr(.....);
+       *    ...
+       *    auto_ptr<Base> ptr = func_returning_auto_ptr(.....);
+       *  @endcode
+       */
+      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
+      : _M_ptr(__ref._M_ptr) { }
+      
+      auto_ptr&
+      operator=(auto_ptr_ref<element_type> __ref) throw()
+      {
+	if (__ref._M_ptr != this->get())
+	  {
+	    delete _M_ptr;
+	    _M_ptr = __ref._M_ptr;
+	  }
+	return *this;
+      }
+      
+      template<typename _Tp1>
+        operator auto_ptr_ref<_Tp1>() throw()
+        { return auto_ptr_ref<_Tp1>(this->release()); }
+
+      template<typename _Tp1>
+        operator auto_ptr<_Tp1>() throw()
+        { return auto_ptr<_Tp1>(this->release()); }
+    } _GLIBCXX_DEPRECATED;
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 541. shared_ptr template assignment and void
+  template<>
+    class auto_ptr<void>
+    {
+    public:
+      typedef void element_type;
+    } _GLIBCXX_DEPRECATED;
+
+#if __cplusplus >= 201103L
+  template<_Lock_policy _Lp>
+  template<typename _Tp>
+    inline
+    __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
+    : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
+    { __r.release(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+  template<typename _Tp1>
+    inline
+    __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
+    : _M_ptr(__r.get()), _M_refcount()
+    {
+      __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+      static_assert( sizeof(_Tp1) > 0, "incomplete type" );
+      _Tp1* __tmp = __r.get();
+      _M_refcount = __shared_count<_Lp>(std::move(__r));
+      __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
+    }
+
+  template<typename _Tp>
+  template<typename _Tp1>
+    inline
+    shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
+    : __shared_ptr<_Tp>(std::move(__r)) { }
+
+  template<typename _Tp, typename _Dp>
+  template<typename _Up, typename>
+    inline
+    unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
+    : _M_t(__u.release(), deleter_type()) { }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _BACKWARD_AUTO_PTR_H */
diff --git a/gcc-4.9/libstdc++-v3/include/backward/backward_warning.h b/gcc-4.9/libstdc++-v3/include/backward/backward_warning.h
new file mode 100644
index 0000000..d1afed3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/backward_warning.h
@@ -0,0 +1,60 @@
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file backward/backward_warning.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iosfwd}
+ */
+
+#ifndef _BACKWARD_BACKWARD_WARNING_H
+#define _BACKWARD_BACKWARD_WARNING_H 1
+
+#ifdef __DEPRECATED
+#warning \
+  This file includes at least one deprecated or antiquated header which \
+  may be removed without further notice at a future date. Please use a \
+  non-deprecated interface with equivalent functionality instead. For a \
+  listing of replacement headers and interfaces, consult the file \
+  backward_warning.h. To disable this warning use -Wno-deprecated.
+
+/*
+  A list of valid replacements is as follows:
+
+  Use:					Instead of:
+  <sstream>, basic_stringbuf	   	<strstream>, strstreambuf
+  <sstream>, basic_istringstream	<strstream>, istrstream
+  <sstream>, basic_ostringstream	<strstream>, ostrstream
+  <sstream>, basic_stringstream		<strstream>, strstream
+  <unordered_set>, unordered_set     	<ext/hash_set>, hash_set
+  <unordered_set>, unordered_multiset	<ext/hash_set>, hash_multiset
+  <unordered_map>, unordered_map	<ext/hash_map>, hash_map
+  <unordered_map>, unordered_multimap	<ext/hash_map>, hash_multimap
+  <functional>, bind			<functional>, binder1st
+  <functional>, bind			<functional>, binder2nd
+  <functional>, bind			<functional>, bind1st
+  <functional>, bind			<functional>, bind2nd
+  <memory>, unique_ptr       		<memory>, auto_ptr
+*/
+
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/backward/binders.h b/gcc-4.9/libstdc++-v3/include/backward/binders.h
new file mode 100644
index 0000000..bda52ed
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/binders.h
@@ -0,0 +1,176 @@
+// Functor implementations -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file backward/binders.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _BACKWARD_BINDERS_H
+#define _BACKWARD_BINDERS_H 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 20.3.6 binders
+  /** @defgroup binders Binder Classes
+   * @ingroup functors
+   *
+   *  Binders turn functions/functors with two arguments into functors
+   *  with a single argument, storing an argument to be applied later.
+   *  For example, a variable @c B of type @c binder1st is constructed
+   *  from a functor @c f and an argument @c x. Later, B's @c
+   *  operator() is called with a single argument @c y. The return
+   *  value is the value of @c f(x,y). @c B can be @a called with
+   *  various arguments (y1, y2, ...) and will in turn call @c
+   *  f(x,y1), @c f(x,y2), ...
+   *
+   *  The function @c bind1st is provided to save some typing. It takes the
+   *  function and an argument as parameters, and returns an instance of
+   *  @c binder1st.
+   *
+   *  The type @c binder2nd and its creator function @c bind2nd do the same
+   *  thing, but the stored argument is passed as the second parameter instead
+   *  of the first, e.g., @c bind2nd(std::minus<float>(),1.3) will create a
+   *  functor whose @c operator() accepts a floating-point number, subtracts
+   *  1.3 from it, and returns the result. (If @c bind1st had been used,
+   *  the functor would perform <em>1.3 - x</em> instead.
+   *
+   *  Creator-wrapper functions like @c bind1st are intended to be used in
+   *  calling algorithms. Their return values will be temporary objects.
+   *  (The goal is to not require you to type names like
+   *  @c std::binder1st<std::plus<int>> for declaring a variable to hold the
+   *  return value from @c bind1st(std::plus<int>(),5).
+   *
+   *  These become more useful when combined with the composition functions.
+   *
+   *  These functions are deprecated in C++11 and can be replaced by
+   *  @c std::bind (or @c std::tr1::bind) which is more powerful and flexible,
+   *  supporting functions with any number of arguments.  Uses of @c bind1st
+   *  can be replaced by @c std::bind(f, x, std::placeholders::_1) and
+   *  @c bind2nd by @c std::bind(f, std::placeholders::_1, x).
+   *  @{
+   */
+  /// One of the @link binders binder functors@endlink.
+  template<typename _Operation>
+    class binder1st
+    : public unary_function<typename _Operation::second_argument_type,
+			    typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::first_argument_type value;
+
+    public:
+      binder1st(const _Operation& __x,
+		const typename _Operation::first_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 109.  Missing binders for non-const sequence elements
+      typename _Operation::result_type
+      operator()(typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+    } _GLIBCXX_DEPRECATED;
+
+  /// One of the @link binders binder functors@endlink.
+  template<typename _Operation, typename _Tp>
+    inline binder1st<_Operation>
+    bind1st(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::first_argument_type _Arg1_type;
+      return binder1st<_Operation>(__fn, _Arg1_type(__x));
+    }
+
+  /// One of the @link binders binder functors@endlink.
+  template<typename _Operation>
+    class binder2nd
+    : public unary_function<typename _Operation::first_argument_type,
+			    typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::second_argument_type value;
+
+    public:
+      binder2nd(const _Operation& __x,
+		const typename _Operation::second_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 109.  Missing binders for non-const sequence elements
+      typename _Operation::result_type
+      operator()(typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+    } _GLIBCXX_DEPRECATED;
+
+  /// One of the @link binders binder functors@endlink.
+  template<typename _Operation, typename _Tp>
+    inline binder2nd<_Operation>
+    bind2nd(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::second_argument_type _Arg2_type;
+      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+    } 
+  /** @}  */
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _BACKWARD_BINDERS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/backward/hash_fun.h b/gcc-4.9/libstdc++-v3/include/backward/hash_fun.h
new file mode 100644
index 0000000..473babc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/hash_fun.h
@@ -0,0 +1,170 @@
+// 'struct hash' from SGI -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file backward/hash_fun.h
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _BACKWARD_HASH_FUN_H
+#define _BACKWARD_HASH_FUN_H 1
+
+#include <bits/c++config.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+
+  template<class _Key>
+    struct hash { };
+
+  inline size_t
+  __stl_hash_string(const char* __s)
+  {
+    unsigned long __h = 0;
+    for ( ; *__s; ++__s)
+      __h = 5 * __h + *__s;
+    return size_t(__h);
+  }
+
+  template<>
+    struct hash<char*>
+    {
+      size_t
+      operator()(const char* __s) const
+      { return __stl_hash_string(__s); }
+    };
+
+  template<>
+    struct hash<const char*>
+    {
+      size_t
+      operator()(const char* __s) const
+      { return __stl_hash_string(__s); }
+    };
+
+  template<>
+    struct hash<char>
+    { 
+      size_t
+      operator()(char __x) const
+      { return __x; }
+    };
+
+  template<>
+    struct hash<unsigned char>
+    { 
+      size_t
+      operator()(unsigned char __x) const
+      { return __x; }
+    };
+
+  template<>
+    struct hash<signed char>
+    {
+      size_t
+      operator()(unsigned char __x) const
+      { return __x; }
+    };
+
+  template<>
+    struct hash<short>
+    {
+      size_t
+      operator()(short __x) const
+      { return __x; }
+    };
+
+  template<>
+    struct hash<unsigned short>
+    {
+      size_t
+      operator()(unsigned short __x) const
+      { return __x; }
+    };
+
+  template<>
+    struct hash<int>
+    { 
+      size_t 
+      operator()(int __x) const 
+      { return __x; }
+    };
+
+  template<>
+    struct hash<unsigned int>
+    { 
+      size_t
+      operator()(unsigned int __x) const
+      { return __x; }
+    };
+
+  template<>
+    struct hash<long>
+    {
+      size_t
+      operator()(long __x) const
+      { return __x; }
+    };
+
+  template<>
+    struct hash<unsigned long>
+    {
+      size_t
+      operator()(unsigned long __x) const
+      { return __x; }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/backward/hash_map b/gcc-4.9/libstdc++-v3/include/backward/hash_map
new file mode 100644
index 0000000..90019cf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/hash_map
@@ -0,0 +1,599 @@
+// Hashing map implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file backward/hash_map
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _BACKWARD_HASH_MAP
+#define _BACKWARD_HASH_MAP 1
+
+#ifndef _GLIBCXX_PERMIT_BACKWARD_HASH
+#include "backward_warning.h"
+#endif
+
+#include <bits/c++config.h>
+#include <backward/hashtable.h>
+#include <bits/concept_check.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::equal_to;
+  using std::allocator;
+  using std::pair;
+  using std::_Select1st;
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+   */
+  template<class _Key, class _Tp, class _HashFn = hash<_Key>,
+	   class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> >
+    class hash_map
+    {
+    private:
+      typedef hashtable<pair<const _Key, _Tp>,_Key, _HashFn,
+			_Select1st<pair<const _Key, _Tp> >,
+			_EqualKey, _Alloc> _Ht;
+
+      _Ht _M_ht;
+
+    public:
+      typedef typename _Ht::key_type key_type;
+      typedef _Tp data_type;
+      typedef _Tp mapped_type;
+      typedef typename _Ht::value_type value_type;
+      typedef typename _Ht::hasher hasher;
+      typedef typename _Ht::key_equal key_equal;
+      
+      typedef typename _Ht::size_type size_type;
+      typedef typename _Ht::difference_type difference_type;
+      typedef typename _Ht::pointer pointer;
+      typedef typename _Ht::const_pointer const_pointer;
+      typedef typename _Ht::reference reference;
+      typedef typename _Ht::const_reference const_reference;
+      
+      typedef typename _Ht::iterator iterator;
+      typedef typename _Ht::const_iterator const_iterator;
+      
+      typedef typename _Ht::allocator_type allocator_type;
+      
+      hasher
+      hash_funct() const
+      { return _M_ht.hash_funct(); }
+
+      key_equal
+      key_eq() const
+      { return _M_ht.key_eq(); }
+
+      allocator_type
+      get_allocator() const
+      { return _M_ht.get_allocator(); }
+
+      hash_map()
+      : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+  
+      explicit
+      hash_map(size_type __n)
+      : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+
+      hash_map(size_type __n, const hasher& __hf)
+      : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+
+      hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
+	       const allocator_type& __a = allocator_type())
+      : _M_ht(__n, __hf, __eql, __a) {}
+
+      template<class _InputIterator>
+        hash_map(_InputIterator __f, _InputIterator __l)
+	: _M_ht(100, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_unique(__f, __l); }
+
+      template<class _InputIterator>
+        hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
+	: _M_ht(__n, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_unique(__f, __l); }
+
+      template<class _InputIterator>
+        hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+		 const hasher& __hf)
+	: _M_ht(__n, __hf, key_equal(), allocator_type())
+        { _M_ht.insert_unique(__f, __l); }
+
+      template<class _InputIterator>
+        hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+		 const hasher& __hf, const key_equal& __eql,
+		 const allocator_type& __a = allocator_type())
+	: _M_ht(__n, __hf, __eql, __a)
+        { _M_ht.insert_unique(__f, __l); }
+
+      size_type
+      size() const
+      { return _M_ht.size(); }
+      
+      size_type
+      max_size() const
+      { return _M_ht.max_size(); }
+      
+      bool
+      empty() const
+      { return _M_ht.empty(); }
+  
+      void
+      swap(hash_map& __hs)
+      { _M_ht.swap(__hs._M_ht); }
+
+      template<class _K1, class _T1, class _HF, class _EqK, class _Al>
+        friend bool
+        operator== (const hash_map<_K1, _T1, _HF, _EqK, _Al>&,
+		    const hash_map<_K1, _T1, _HF, _EqK, _Al>&);
+
+      iterator
+      begin()
+      { return _M_ht.begin(); }
+
+      iterator
+      end()
+      { return _M_ht.end(); }
+
+      const_iterator
+      begin() const
+      { return _M_ht.begin(); }
+
+      const_iterator
+      end() const
+      { return _M_ht.end(); }
+
+      pair<iterator, bool>
+      insert(const value_type& __obj)
+      { return _M_ht.insert_unique(__obj); }
+
+      template<class _InputIterator>
+        void
+        insert(_InputIterator __f, _InputIterator __l)
+        { _M_ht.insert_unique(__f, __l); }
+
+      pair<iterator, bool>
+      insert_noresize(const value_type& __obj)
+      { return _M_ht.insert_unique_noresize(__obj); }
+
+      iterator
+      find(const key_type& __key)
+      { return _M_ht.find(__key); }
+
+      const_iterator
+      find(const key_type& __key) const
+      { return _M_ht.find(__key); }
+
+      _Tp&
+      operator[](const key_type& __key)
+      { return _M_ht.find_or_insert(value_type(__key, _Tp())).second; }
+
+      size_type
+      count(const key_type& __key) const
+      { return _M_ht.count(__key); }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __key)
+      { return _M_ht.equal_range(__key); }
+
+      pair<const_iterator, const_iterator>
+      equal_range(const key_type& __key) const
+      { return _M_ht.equal_range(__key); }
+
+      size_type
+      erase(const key_type& __key)
+      {return _M_ht.erase(__key); }
+
+      void
+      erase(iterator __it)
+      { _M_ht.erase(__it); }
+
+      void
+      erase(iterator __f, iterator __l)
+      { _M_ht.erase(__f, __l); }
+
+      void
+      clear()
+      { _M_ht.clear(); }
+
+      void
+      resize(size_type __hint)
+      { _M_ht.resize(__hint); }
+
+      size_type
+      bucket_count() const
+      { return _M_ht.bucket_count(); }
+
+      size_type
+      max_bucket_count() const
+      { return _M_ht.max_bucket_count(); }
+
+      size_type
+      elems_in_bucket(size_type __n) const
+      { return _M_ht.elems_in_bucket(__n); }
+    };
+
+  template<class _Key, class _Tp, class _HashFn, class _EqlKey, class _Alloc>
+    inline bool
+    operator==(const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1,
+	       const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2)
+    { return __hm1._M_ht == __hm2._M_ht; }
+
+  template<class _Key, class _Tp, class _HashFn, class _EqlKey, class _Alloc>
+    inline bool
+    operator!=(const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1,
+	       const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2)
+    { return !(__hm1 == __hm2); }
+
+  template<class _Key, class _Tp, class _HashFn, class _EqlKey, class _Alloc>
+    inline void
+    swap(hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1,
+	 hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2)
+    { __hm1.swap(__hm2); }
+
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+   */
+  template<class _Key, class _Tp,
+	   class _HashFn = hash<_Key>,
+	   class _EqualKey = equal_to<_Key>,
+	   class _Alloc = allocator<_Tp> >
+    class hash_multimap
+    {
+      // concept requirements
+      __glibcxx_class_requires(_Key, _SGIAssignableConcept)
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires3(_HashFn, size_t, _Key, _UnaryFunctionConcept)
+      __glibcxx_class_requires3(_EqualKey, _Key, _Key, _BinaryPredicateConcept)
+	
+    private:
+      typedef hashtable<pair<const _Key, _Tp>, _Key, _HashFn,
+			_Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc>
+          _Ht;
+
+      _Ht _M_ht;
+
+    public:
+      typedef typename _Ht::key_type key_type;
+      typedef _Tp data_type;
+      typedef _Tp mapped_type;
+      typedef typename _Ht::value_type value_type;
+      typedef typename _Ht::hasher hasher;
+      typedef typename _Ht::key_equal key_equal;
+      
+      typedef typename _Ht::size_type size_type;
+      typedef typename _Ht::difference_type difference_type;
+      typedef typename _Ht::pointer pointer;
+      typedef typename _Ht::const_pointer const_pointer;
+      typedef typename _Ht::reference reference;
+      typedef typename _Ht::const_reference const_reference;
+      
+      typedef typename _Ht::iterator iterator;
+      typedef typename _Ht::const_iterator const_iterator;
+      
+      typedef typename _Ht::allocator_type allocator_type;
+      
+      hasher
+      hash_funct() const
+      { return _M_ht.hash_funct(); }
+
+      key_equal
+      key_eq() const
+      { return _M_ht.key_eq(); }
+
+      allocator_type
+      get_allocator() const
+      { return _M_ht.get_allocator(); }
+
+      hash_multimap()
+      : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+
+      explicit
+      hash_multimap(size_type __n)
+      : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+
+      hash_multimap(size_type __n, const hasher& __hf)
+      : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+
+      hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
+		    const allocator_type& __a = allocator_type())
+      : _M_ht(__n, __hf, __eql, __a) {}
+
+      template<class _InputIterator>
+        hash_multimap(_InputIterator __f, _InputIterator __l)
+	: _M_ht(100, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_equal(__f, __l); }
+
+      template<class _InputIterator>
+        hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
+	: _M_ht(__n, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_equal(__f, __l); }
+
+      template<class _InputIterator>
+        hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+		      const hasher& __hf)
+	: _M_ht(__n, __hf, key_equal(), allocator_type())
+        { _M_ht.insert_equal(__f, __l); }
+
+      template<class _InputIterator>
+        hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+		      const hasher& __hf, const key_equal& __eql,
+		      const allocator_type& __a = allocator_type())
+	: _M_ht(__n, __hf, __eql, __a)
+        { _M_ht.insert_equal(__f, __l); }
+
+      size_type
+      size() const
+      { return _M_ht.size(); }
+
+      size_type
+      max_size() const
+      { return _M_ht.max_size(); }
+
+      bool
+      empty() const
+      { return _M_ht.empty(); }
+
+      void
+      swap(hash_multimap& __hs)
+      { _M_ht.swap(__hs._M_ht); }
+
+      template<class _K1, class _T1, class _HF, class _EqK, class _Al>
+        friend bool
+        operator==(const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&,
+		   const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&);
+
+      iterator
+      begin()
+      { return _M_ht.begin(); }
+
+      iterator
+      end()
+      { return _M_ht.end(); }
+
+      const_iterator
+      begin() const
+      { return _M_ht.begin(); }
+
+      const_iterator
+      end() const
+      { return _M_ht.end(); }
+
+      iterator
+      insert(const value_type& __obj)
+      { return _M_ht.insert_equal(__obj); }
+
+      template<class _InputIterator>
+        void
+        insert(_InputIterator __f, _InputIterator __l)
+        { _M_ht.insert_equal(__f,__l); }
+
+      iterator
+      insert_noresize(const value_type& __obj)
+      { return _M_ht.insert_equal_noresize(__obj); }
+
+      iterator
+      find(const key_type& __key)
+      { return _M_ht.find(__key); }
+
+      const_iterator
+      find(const key_type& __key) const
+      { return _M_ht.find(__key); }
+
+      size_type
+      count(const key_type& __key) const
+      { return _M_ht.count(__key); }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __key)
+      { return _M_ht.equal_range(__key); }
+
+      pair<const_iterator, const_iterator>
+      equal_range(const key_type& __key) const
+      { return _M_ht.equal_range(__key); }
+
+      size_type
+      erase(const key_type& __key)
+      { return _M_ht.erase(__key); }
+
+      void
+      erase(iterator __it)
+      { _M_ht.erase(__it); }
+
+      void
+      erase(iterator __f, iterator __l)
+      { _M_ht.erase(__f, __l); }
+
+      void
+      clear()
+      { _M_ht.clear(); }
+
+      void
+      resize(size_type __hint)
+      { _M_ht.resize(__hint); }
+
+      size_type
+      bucket_count() const
+      { return _M_ht.bucket_count(); }
+
+      size_type
+      max_bucket_count() const
+      { return _M_ht.max_bucket_count(); }
+      
+      size_type
+      elems_in_bucket(size_type __n) const
+      { return _M_ht.elems_in_bucket(__n); }
+    };
+
+  template<class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
+    inline bool
+    operator==(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1,
+	       const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2)
+    { return __hm1._M_ht == __hm2._M_ht; }
+
+  template<class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
+    inline bool
+    operator!=(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1,
+	       const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2)
+    { return !(__hm1 == __hm2); }
+
+  template<class _Key, class _Tp, class _HashFn, class _EqlKey, class _Alloc>
+    inline void
+    swap(hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1,
+	 hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2)
+    { __hm1.swap(__hm2); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Specialization of insert_iterator so that it will work for hash_map
+  // and hash_multimap.
+  template<class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
+    class insert_iterator<__gnu_cxx::hash_map<_Key, _Tp, _HashFn, 
+					      _EqKey, _Alloc> >
+    {
+    protected:
+      typedef __gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>
+        _Container;
+      _Container* container;
+
+    public:
+      typedef _Container          container_type;
+      typedef output_iterator_tag iterator_category;
+      typedef void                value_type;
+      typedef void                difference_type;
+      typedef void                pointer;
+      typedef void                reference;
+      
+      insert_iterator(_Container& __x)
+      : container(&__x) {}
+
+      insert_iterator(_Container& __x, typename _Container::iterator)
+      : container(&__x) {}
+
+      insert_iterator<_Container>&
+      operator=(const typename _Container::value_type& __value)
+      {
+	container->insert(__value);
+	return *this;
+      }
+
+      insert_iterator<_Container>&
+      operator*()
+      { return *this; }
+
+      insert_iterator<_Container>&
+      operator++() { return *this; }
+
+      insert_iterator<_Container>&
+      operator++(int)
+      { return *this; }
+    };
+
+  template<class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
+    class insert_iterator<__gnu_cxx::hash_multimap<_Key, _Tp, _HashFn,
+						   _EqKey, _Alloc> >
+    {
+    protected:
+      typedef __gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc>
+        _Container;
+      _Container* container;
+      typename _Container::iterator iter;
+
+    public:
+      typedef _Container          container_type;
+      typedef output_iterator_tag iterator_category;
+      typedef void                value_type;
+      typedef void                difference_type;
+      typedef void                pointer;
+      typedef void                reference;
+
+      insert_iterator(_Container& __x)
+      : container(&__x) {}
+
+      insert_iterator(_Container& __x, typename _Container::iterator)
+      : container(&__x) {}
+
+      insert_iterator<_Container>&
+      operator=(const typename _Container::value_type& __value)
+      {
+	container->insert(__value);
+	return *this;
+      }
+
+      insert_iterator<_Container>&
+      operator*()
+      { return *this; }
+
+      insert_iterator<_Container>&
+      operator++()
+      { return *this; }
+
+      insert_iterator<_Container>&
+      operator++(int)
+      { return *this; }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/backward/hash_set b/gcc-4.9/libstdc++-v3/include/backward/hash_set
new file mode 100644
index 0000000..3e834db
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/hash_set
@@ -0,0 +1,567 @@
+// Hashing set implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file backward/hash_set
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _BACKWARD_HASH_SET
+#define _BACKWARD_HASH_SET 1
+
+#ifndef _GLIBCXX_PERMIT_BACKWARD_HASH
+#include "backward_warning.h"
+#endif
+
+#include <bits/c++config.h>
+#include <backward/hashtable.h>
+#include <bits/concept_check.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::equal_to;
+  using std::allocator;
+  using std::pair;
+  using std::_Identity;
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+   */
+  template<class _Value, class _HashFcn  = hash<_Value>,
+	   class _EqualKey = equal_to<_Value>,
+	   class _Alloc = allocator<_Value> >
+    class hash_set
+    {
+      // concept requirements
+      __glibcxx_class_requires(_Value, _SGIAssignableConcept)
+      __glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept)
+      __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept)
+
+    private:
+      typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
+			_EqualKey, _Alloc> _Ht;
+      _Ht _M_ht;
+
+    public:
+      typedef typename _Ht::key_type key_type;
+      typedef typename _Ht::value_type value_type;
+      typedef typename _Ht::hasher hasher;
+      typedef typename _Ht::key_equal key_equal;
+      
+      typedef typename _Ht::size_type size_type;
+      typedef typename _Ht::difference_type difference_type;
+      typedef typename _Alloc::pointer pointer;
+      typedef typename _Alloc::const_pointer const_pointer;
+      typedef typename _Alloc::reference reference;
+      typedef typename _Alloc::const_reference const_reference;
+      
+      typedef typename _Ht::const_iterator iterator;
+      typedef typename _Ht::const_iterator const_iterator;
+      
+      typedef typename _Ht::allocator_type allocator_type;
+      
+      hasher
+      hash_funct() const
+      { return _M_ht.hash_funct(); }
+
+      key_equal
+      key_eq() const
+      { return _M_ht.key_eq(); }
+
+      allocator_type
+      get_allocator() const
+      { return _M_ht.get_allocator(); }
+
+      hash_set()
+      : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+
+      explicit
+      hash_set(size_type __n)
+      : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+
+      hash_set(size_type __n, const hasher& __hf)
+      : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+
+      hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+	       const allocator_type& __a = allocator_type())
+      : _M_ht(__n, __hf, __eql, __a) {}
+
+      template<class _InputIterator>
+        hash_set(_InputIterator __f, _InputIterator __l)
+	: _M_ht(100, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_unique(__f, __l); }
+
+      template<class _InputIterator>
+        hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
+	: _M_ht(__n, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_unique(__f, __l); }
+
+      template<class _InputIterator>
+        hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+		 const hasher& __hf)
+	: _M_ht(__n, __hf, key_equal(), allocator_type())
+        { _M_ht.insert_unique(__f, __l); }
+
+      template<class _InputIterator>
+        hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+		 const hasher& __hf, const key_equal& __eql,
+		 const allocator_type& __a = allocator_type())
+	: _M_ht(__n, __hf, __eql, __a)
+        { _M_ht.insert_unique(__f, __l); }
+
+      size_type
+      size() const
+      { return _M_ht.size(); }
+
+      size_type
+      max_size() const
+      { return _M_ht.max_size(); }
+      
+      bool
+      empty() const
+      { return _M_ht.empty(); }
+      
+      void
+      swap(hash_set& __hs)
+      { _M_ht.swap(__hs._M_ht); }
+
+      template<class _Val, class _HF, class _EqK, class _Al>
+        friend bool
+        operator==(const hash_set<_Val, _HF, _EqK, _Al>&,
+		   const hash_set<_Val, _HF, _EqK, _Al>&);
+
+      iterator
+      begin() const
+      { return _M_ht.begin(); }
+      
+      iterator
+      end() const
+      { return _M_ht.end(); }
+
+      pair<iterator, bool>
+      insert(const value_type& __obj)
+      {
+	pair<typename _Ht::iterator, bool> __p = _M_ht.insert_unique(__obj);
+	return pair<iterator,bool>(__p.first, __p.second);
+      }
+
+      template<class _InputIterator>
+        void
+        insert(_InputIterator __f, _InputIterator __l)
+        { _M_ht.insert_unique(__f, __l); }
+
+      pair<iterator, bool>
+      insert_noresize(const value_type& __obj)
+      {
+	pair<typename _Ht::iterator, bool> __p
+	  = _M_ht.insert_unique_noresize(__obj);
+	return pair<iterator, bool>(__p.first, __p.second);
+      }
+
+      iterator
+      find(const key_type& __key) const
+      { return _M_ht.find(__key); }
+
+      size_type
+      count(const key_type& __key) const
+      { return _M_ht.count(__key); }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __key) const
+      { return _M_ht.equal_range(__key); }
+
+      size_type
+      erase(const key_type& __key)
+      {return _M_ht.erase(__key); }
+      
+      void
+      erase(iterator __it)
+      { _M_ht.erase(__it); }
+      
+      void
+      erase(iterator __f, iterator __l)
+      { _M_ht.erase(__f, __l); }
+      
+      void
+      clear()
+      { _M_ht.clear(); }
+
+      void
+      resize(size_type __hint)
+      { _M_ht.resize(__hint); }
+      
+      size_type
+      bucket_count() const
+      { return _M_ht.bucket_count(); }
+      
+      size_type
+      max_bucket_count() const
+      { return _M_ht.max_bucket_count(); }
+      
+      size_type
+      elems_in_bucket(size_type __n) const
+      { return _M_ht.elems_in_bucket(__n); }
+    };
+
+  template<class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+    inline bool
+    operator==(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1,
+	       const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2)
+    { return __hs1._M_ht == __hs2._M_ht; }
+
+  template<class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+    inline bool
+    operator!=(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1,
+	       const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2)
+    { return !(__hs1 == __hs2); }
+
+  template<class _Val, class _HashFcn, class _EqualKey, class _Alloc>
+    inline void
+    swap(hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
+	 hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
+    { __hs1.swap(__hs2); }
+
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+   */
+  template<class _Value,
+	   class _HashFcn = hash<_Value>,
+	   class _EqualKey = equal_to<_Value>,
+	   class _Alloc = allocator<_Value> >
+    class hash_multiset
+    {
+      // concept requirements
+      __glibcxx_class_requires(_Value, _SGIAssignableConcept)
+      __glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept)
+      __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept)
+
+    private:
+      typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
+			_EqualKey, _Alloc> _Ht;
+      _Ht _M_ht;
+
+    public:
+      typedef typename _Ht::key_type key_type;
+      typedef typename _Ht::value_type value_type;
+      typedef typename _Ht::hasher hasher;
+      typedef typename _Ht::key_equal key_equal;
+      
+      typedef typename _Ht::size_type size_type;
+      typedef typename _Ht::difference_type difference_type;
+      typedef typename _Alloc::pointer pointer;
+      typedef typename _Alloc::const_pointer const_pointer;
+      typedef typename _Alloc::reference reference;
+      typedef typename _Alloc::const_reference const_reference;
+
+      typedef typename _Ht::const_iterator iterator;
+      typedef typename _Ht::const_iterator const_iterator;
+      
+      typedef typename _Ht::allocator_type allocator_type;
+      
+      hasher
+      hash_funct() const
+      { return _M_ht.hash_funct(); }
+      
+      key_equal
+      key_eq() const
+      { return _M_ht.key_eq(); }
+      
+      allocator_type
+      get_allocator() const
+      { return _M_ht.get_allocator(); }
+
+      hash_multiset()
+      : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
+
+      explicit
+      hash_multiset(size_type __n)
+      : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+
+      hash_multiset(size_type __n, const hasher& __hf)
+      : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+      
+      hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
+		    const allocator_type& __a = allocator_type())
+      : _M_ht(__n, __hf, __eql, __a) {}
+
+      template<class _InputIterator>
+        hash_multiset(_InputIterator __f, _InputIterator __l)
+	: _M_ht(100, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_equal(__f, __l); }
+
+      template<class _InputIterator>
+        hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
+	: _M_ht(__n, hasher(), key_equal(), allocator_type())
+        { _M_ht.insert_equal(__f, __l); }
+
+      template<class _InputIterator>
+        hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+		      const hasher& __hf)
+	: _M_ht(__n, __hf, key_equal(), allocator_type())
+        { _M_ht.insert_equal(__f, __l); }
+
+      template<class _InputIterator>
+        hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+		      const hasher& __hf, const key_equal& __eql,
+		      const allocator_type& __a = allocator_type())
+	: _M_ht(__n, __hf, __eql, __a)
+        { _M_ht.insert_equal(__f, __l); }
+
+      size_type
+      size() const
+      { return _M_ht.size(); }
+
+      size_type
+      max_size() const
+      { return _M_ht.max_size(); }
+
+      bool
+      empty() const
+      { return _M_ht.empty(); }
+
+      void
+      swap(hash_multiset& hs)
+      { _M_ht.swap(hs._M_ht); }
+
+      template<class _Val, class _HF, class _EqK, class _Al>
+        friend bool
+        operator==(const hash_multiset<_Val, _HF, _EqK, _Al>&,
+		   const hash_multiset<_Val, _HF, _EqK, _Al>&);
+
+      iterator
+      begin() const
+      { return _M_ht.begin(); }
+      
+      iterator
+      end() const
+      { return _M_ht.end(); }
+
+      iterator
+      insert(const value_type& __obj)
+      { return _M_ht.insert_equal(__obj); }
+  
+      template<class _InputIterator>
+        void
+        insert(_InputIterator __f, _InputIterator __l)
+        { _M_ht.insert_equal(__f,__l); }
+  
+      iterator
+      insert_noresize(const value_type& __obj)
+      { return _M_ht.insert_equal_noresize(__obj); }
+
+      iterator
+      find(const key_type& __key) const
+      { return _M_ht.find(__key); }
+
+      size_type
+      count(const key_type& __key) const
+      { return _M_ht.count(__key); }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __key) const
+      { return _M_ht.equal_range(__key); }
+
+      size_type
+      erase(const key_type& __key)
+      { return _M_ht.erase(__key); }
+  
+      void
+      erase(iterator __it)
+      { _M_ht.erase(__it); }
+  
+      void
+      erase(iterator __f, iterator __l)
+      { _M_ht.erase(__f, __l); }
+  
+      void
+      clear()
+      { _M_ht.clear(); }
+
+      void
+      resize(size_type __hint)
+      { _M_ht.resize(__hint); }
+  
+      size_type
+      bucket_count() const
+      { return _M_ht.bucket_count(); }
+
+      size_type
+      max_bucket_count() const
+      { return _M_ht.max_bucket_count(); }
+
+      size_type
+      elems_in_bucket(size_type __n) const
+      { return _M_ht.elems_in_bucket(__n); }
+    };
+
+  template<class _Val, class _HashFcn, class _EqualKey, class _Alloc>
+    inline bool
+    operator==(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
+	       const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
+    { return __hs1._M_ht == __hs2._M_ht; }
+
+  template<class _Val, class _HashFcn, class _EqualKey, class _Alloc>
+    inline bool
+    operator!=(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
+	       const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
+    { return !(__hs1 == __hs2); }
+
+  template<class _Val, class _HashFcn, class _EqualKey, class _Alloc>
+    inline void
+    swap(hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
+	 hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
+    { __hs1.swap(__hs2); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Specialization of insert_iterator so that it will work for hash_set
+  // and hash_multiset.
+  template<class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+    class insert_iterator<__gnu_cxx::hash_set<_Value, _HashFcn,
+					      _EqualKey, _Alloc> >
+    {
+    protected:
+      typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc>
+        _Container;
+      _Container* container;
+
+    public:
+      typedef _Container          container_type;
+      typedef output_iterator_tag iterator_category;
+      typedef void                value_type;
+      typedef void                difference_type;
+      typedef void                pointer;
+      typedef void                reference;
+
+      insert_iterator(_Container& __x)
+      : container(&__x) {}
+      
+      insert_iterator(_Container& __x, typename _Container::iterator)
+      : container(&__x) {}
+
+      insert_iterator<_Container>&
+      operator=(const typename _Container::value_type& __value)
+      {
+	container->insert(__value);
+	return *this;
+      }
+
+      insert_iterator<_Container>&
+      operator*()
+      { return *this; }
+      
+      insert_iterator<_Container>&
+      operator++()
+      { return *this; }
+      
+      insert_iterator<_Container>&
+      operator++(int)
+      { return *this; }
+    };
+
+  template<class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+    class insert_iterator<__gnu_cxx::hash_multiset<_Value, _HashFcn,
+						   _EqualKey, _Alloc> >
+    {
+    protected:
+      typedef __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>
+        _Container;
+      _Container* container;
+      typename _Container::iterator iter;
+
+    public:
+      typedef _Container          container_type;
+      typedef output_iterator_tag iterator_category;
+      typedef void                value_type;
+      typedef void                difference_type;
+      typedef void                pointer;
+      typedef void                reference;
+      
+      insert_iterator(_Container& __x)
+      : container(&__x) {}
+      
+      insert_iterator(_Container& __x, typename _Container::iterator)
+      : container(&__x) {}
+
+      insert_iterator<_Container>&
+      operator=(const typename _Container::value_type& __value)
+      {
+	container->insert(__value);
+	return *this;
+      }
+
+      insert_iterator<_Container>&
+      operator*()
+      { return *this; }
+
+      insert_iterator<_Container>&
+      operator++()
+      { return *this; }
+
+      insert_iterator<_Container>&
+      operator++(int) { return *this; }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/backward/hashtable.h b/gcc-4.9/libstdc++-v3/include/backward/hashtable.h
new file mode 100644
index 0000000..86121af
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/hashtable.h
@@ -0,0 +1,1167 @@
+// Hashtable implementation used by containers -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file backward/hashtable.h
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _BACKWARD_HASHTABLE_H
+#define _BACKWARD_HASHTABLE_H 1
+
+// Hashtable class, used to implement the hashed associative containers
+// hash_set, hash_map, hash_multiset, and hash_multimap.
+
+#include <vector>
+#include <iterator>
+#include <algorithm>
+#include <bits/stl_function.h>
+#include <backward/hash_fun.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::ptrdiff_t;
+  using std::forward_iterator_tag;
+  using std::input_iterator_tag;
+  using std::_Construct;
+  using std::_Destroy;
+  using std::distance;
+  using std::vector;
+  using std::pair;
+  using std::__iterator_category;
+
+  template<class _Val>
+    struct _Hashtable_node
+    {
+      _Hashtable_node* _M_next;
+      _Val _M_val;
+    };
+
+  template<class _Val, class _Key, class _HashFcn, class _ExtractKey, 
+	   class _EqualKey, class _Alloc = std::allocator<_Val> >
+    class hashtable;
+
+  template<class _Val, class _Key, class _HashFcn,
+	   class _ExtractKey, class _EqualKey, class _Alloc>
+    struct _Hashtable_iterator;
+
+  template<class _Val, class _Key, class _HashFcn,
+	   class _ExtractKey, class _EqualKey, class _Alloc>
+    struct _Hashtable_const_iterator;
+
+  template<class _Val, class _Key, class _HashFcn,
+	   class _ExtractKey, class _EqualKey, class _Alloc>
+    struct _Hashtable_iterator
+    {
+      typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>
+        _Hashtable;
+      typedef _Hashtable_iterator<_Val, _Key, _HashFcn,
+				  _ExtractKey, _EqualKey, _Alloc>
+        iterator;
+      typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
+					_ExtractKey, _EqualKey, _Alloc>
+        const_iterator;
+      typedef _Hashtable_node<_Val> _Node;
+      typedef forward_iterator_tag iterator_category;
+      typedef _Val value_type;
+      typedef ptrdiff_t difference_type;
+      typedef size_t size_type;
+      typedef _Val& reference;
+      typedef _Val* pointer;
+      
+      _Node* _M_cur;
+      _Hashtable* _M_ht;
+
+      _Hashtable_iterator(_Node* __n, _Hashtable* __tab)
+      : _M_cur(__n), _M_ht(__tab) { }
+
+      _Hashtable_iterator() { }
+
+      reference
+      operator*() const
+      { return _M_cur->_M_val; }
+
+      pointer
+      operator->() const
+      { return &(operator*()); }
+
+      iterator&
+      operator++();
+
+      iterator
+      operator++(int);
+
+      bool
+      operator==(const iterator& __it) const
+      { return _M_cur == __it._M_cur; }
+
+      bool
+      operator!=(const iterator& __it) const
+      { return _M_cur != __it._M_cur; }
+    };
+
+  template<class _Val, class _Key, class _HashFcn,
+	   class _ExtractKey, class _EqualKey, class _Alloc>
+    struct _Hashtable_const_iterator
+    {
+      typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>
+        _Hashtable;
+      typedef _Hashtable_iterator<_Val,_Key,_HashFcn,
+				  _ExtractKey,_EqualKey,_Alloc>
+        iterator;
+      typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
+					_ExtractKey, _EqualKey, _Alloc>
+        const_iterator;
+      typedef _Hashtable_node<_Val> _Node;
+
+      typedef forward_iterator_tag iterator_category;
+      typedef _Val value_type;
+      typedef ptrdiff_t difference_type;
+      typedef size_t size_type;
+      typedef const _Val& reference;
+      typedef const _Val* pointer;
+      
+      const _Node* _M_cur;
+      const _Hashtable* _M_ht;
+
+      _Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab)
+      : _M_cur(__n), _M_ht(__tab) { }
+
+      _Hashtable_const_iterator() { }
+
+      _Hashtable_const_iterator(const iterator& __it)
+      : _M_cur(__it._M_cur), _M_ht(__it._M_ht) { }
+
+      reference
+      operator*() const
+      { return _M_cur->_M_val; }
+
+      pointer
+      operator->() const
+      { return &(operator*()); }
+
+      const_iterator&
+      operator++();
+
+      const_iterator
+      operator++(int);
+
+      bool
+      operator==(const const_iterator& __it) const
+      { return _M_cur == __it._M_cur; }
+
+      bool
+      operator!=(const const_iterator& __it) const
+      { return _M_cur != __it._M_cur; }
+    };
+
+  // Note: assumes long is at least 32 bits.
+  enum { _S_num_primes = 29 };
+
+  template<typename _PrimeType>
+    struct _Hashtable_prime_list
+    {
+      static const _PrimeType  __stl_prime_list[_S_num_primes];
+
+      static const _PrimeType*
+      _S_get_prime_list();
+    };
+
+  template<typename _PrimeType> const _PrimeType
+  _Hashtable_prime_list<_PrimeType>::__stl_prime_list[_S_num_primes] =
+    {
+      5ul,          53ul,         97ul,         193ul,       389ul,
+      769ul,        1543ul,       3079ul,       6151ul,      12289ul,
+      24593ul,      49157ul,      98317ul,      196613ul,    393241ul,
+      786433ul,     1572869ul,    3145739ul,    6291469ul,   12582917ul,
+      25165843ul,   50331653ul,   100663319ul,  201326611ul, 402653189ul,
+      805306457ul,  1610612741ul, 3221225473ul, 4294967291ul
+    };
+
+ template<class _PrimeType> inline const _PrimeType*
+ _Hashtable_prime_list<_PrimeType>::_S_get_prime_list()
+ {
+   return __stl_prime_list;
+ }
+
+  inline unsigned long
+  __stl_next_prime(unsigned long __n)
+  {
+    const unsigned long* __first = _Hashtable_prime_list<unsigned long>::_S_get_prime_list();
+    const unsigned long* __last = __first + (int)_S_num_primes;
+    const unsigned long* pos = std::lower_bound(__first, __last, __n);
+    return pos == __last ? *(__last - 1) : *pos;
+  }
+
+  // Forward declaration of operator==.  
+  template<class _Val, class _Key, class _HF, class _Ex,
+	   class _Eq, class _All>
+    class hashtable;
+
+  template<class _Val, class _Key, class _HF, class _Ex,
+	   class _Eq, class _All>
+    bool
+    operator==(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1,
+	       const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2);
+
+  // Hashtables handle allocators a bit differently than other
+  // containers do.  If we're using standard-conforming allocators, then
+  // a hashtable unconditionally has a member variable to hold its
+  // allocator, even if it so happens that all instances of the
+  // allocator type are identical.  This is because, for hashtables,
+  // this extra storage is negligible.  Additionally, a base class
+  // wouldn't serve any other purposes; it wouldn't, for example,
+  // simplify the exception-handling code.  
+  template<class _Val, class _Key, class _HashFcn,
+	   class _ExtractKey, class _EqualKey, class _Alloc>
+    class hashtable
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Val value_type;
+      typedef _HashFcn hasher;
+      typedef _EqualKey key_equal;
+
+      typedef size_t            size_type;
+      typedef ptrdiff_t         difference_type;
+      typedef value_type*       pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type&       reference;
+      typedef const value_type& const_reference;
+
+      hasher
+      hash_funct() const
+      { return _M_hash; }
+
+      key_equal
+      key_eq() const
+      { return _M_equals; }
+
+    private:
+      typedef _Hashtable_node<_Val> _Node;
+
+    public:
+      typedef typename _Alloc::template rebind<value_type>::other allocator_type;
+      allocator_type
+      get_allocator() const
+      { return _M_node_allocator; }
+
+    private:
+      typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc;
+      typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc;
+      typedef vector<_Node*, _Nodeptr_Alloc> _Vector_type;
+
+      _Node_Alloc _M_node_allocator;
+
+      _Node*
+      _M_get_node()
+      { return _M_node_allocator.allocate(1); }
+
+      void
+      _M_put_node(_Node* __p)
+      { _M_node_allocator.deallocate(__p, 1); }
+
+    private:
+      hasher                _M_hash;
+      key_equal             _M_equals;
+      _ExtractKey           _M_get_key;
+      _Vector_type          _M_buckets;
+      size_type             _M_num_elements;
+      
+    public:
+      typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey,
+				  _EqualKey, _Alloc>
+        iterator;
+      typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey,
+					_EqualKey, _Alloc>
+        const_iterator;
+
+      friend struct
+      _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+
+      friend struct
+      _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey,
+				_EqualKey, _Alloc>;
+
+    public:
+      hashtable(size_type __n, const _HashFcn& __hf,
+		const _EqualKey& __eql, const _ExtractKey& __ext,
+		const allocator_type& __a = allocator_type())
+      : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql),
+	_M_get_key(__ext), _M_buckets(__a), _M_num_elements(0)
+      { _M_initialize_buckets(__n); }
+
+      hashtable(size_type __n, const _HashFcn& __hf,
+		const _EqualKey& __eql,
+		const allocator_type& __a = allocator_type())
+      : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql),
+	_M_get_key(_ExtractKey()), _M_buckets(__a), _M_num_elements(0)
+      { _M_initialize_buckets(__n); }
+
+      hashtable(const hashtable& __ht)
+      : _M_node_allocator(__ht.get_allocator()), _M_hash(__ht._M_hash),
+      _M_equals(__ht._M_equals), _M_get_key(__ht._M_get_key),
+      _M_buckets(__ht.get_allocator()), _M_num_elements(0)
+      { _M_copy_from(__ht); }
+
+      hashtable&
+      operator= (const hashtable& __ht)
+      {
+	if (&__ht != this)
+	  {
+	    clear();
+	    _M_hash = __ht._M_hash;
+	    _M_equals = __ht._M_equals;
+	    _M_get_key = __ht._M_get_key;
+	    _M_copy_from(__ht);
+	  }
+	return *this;
+      }
+
+      ~hashtable()
+      { clear(); }
+
+      size_type
+      size() const
+      { return _M_num_elements; }
+
+      size_type
+      max_size() const
+      { return size_type(-1); }
+
+      bool
+      empty() const
+      { return size() == 0; }
+
+      void
+      swap(hashtable& __ht)
+      {
+	std::swap(_M_hash, __ht._M_hash);
+	std::swap(_M_equals, __ht._M_equals);
+	std::swap(_M_get_key, __ht._M_get_key);
+	_M_buckets.swap(__ht._M_buckets);
+	std::swap(_M_num_elements, __ht._M_num_elements);
+      }
+
+      iterator
+      begin()
+      {
+	for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
+	  if (_M_buckets[__n])
+	    return iterator(_M_buckets[__n], this);
+	return end();
+      }
+
+      iterator
+      end()
+      { return iterator(0, this); }
+
+      const_iterator
+      begin() const
+      {
+	for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
+	  if (_M_buckets[__n])
+	    return const_iterator(_M_buckets[__n], this);
+	return end();
+      }
+
+      const_iterator
+      end() const
+      { return const_iterator(0, this); }
+
+      template<class _Vl, class _Ky, class _HF, class _Ex, class _Eq,
+		class _Al>
+        friend bool
+        operator==(const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&,
+		   const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&);
+
+    public:
+      size_type
+      bucket_count() const
+      { return _M_buckets.size(); }
+
+      size_type
+      max_bucket_count() const
+      { return _Hashtable_prime_list<unsigned long>::
+               _S_get_prime_list()[(int)_S_num_primes - 1];
+      }
+
+      size_type
+      elems_in_bucket(size_type __bucket) const
+      {
+	size_type __result = 0;
+	for (_Node* __n = _M_buckets[__bucket]; __n; __n = __n->_M_next)
+	  __result += 1;
+	return __result;
+      }
+
+      pair<iterator, bool>
+      insert_unique(const value_type& __obj)
+      {
+	resize(_M_num_elements + 1);
+	return insert_unique_noresize(__obj);
+      }
+
+      iterator
+      insert_equal(const value_type& __obj)
+      {
+	resize(_M_num_elements + 1);
+	return insert_equal_noresize(__obj);
+      }
+
+      pair<iterator, bool>
+      insert_unique_noresize(const value_type& __obj);
+
+      iterator
+      insert_equal_noresize(const value_type& __obj);
+
+      template<class _InputIterator>
+        void
+        insert_unique(_InputIterator __f, _InputIterator __l)
+        { insert_unique(__f, __l, __iterator_category(__f)); }
+
+      template<class _InputIterator>
+        void
+        insert_equal(_InputIterator __f, _InputIterator __l)
+        { insert_equal(__f, __l, __iterator_category(__f)); }
+
+      template<class _InputIterator>
+        void
+        insert_unique(_InputIterator __f, _InputIterator __l,
+		      input_iterator_tag)
+        {
+	  for ( ; __f != __l; ++__f)
+	    insert_unique(*__f);
+	}
+
+      template<class _InputIterator>
+        void
+        insert_equal(_InputIterator __f, _InputIterator __l,
+		     input_iterator_tag)
+        {
+	  for ( ; __f != __l; ++__f)
+	    insert_equal(*__f);
+	}
+
+      template<class _ForwardIterator>
+        void
+        insert_unique(_ForwardIterator __f, _ForwardIterator __l,
+		      forward_iterator_tag)
+        {
+	  size_type __n = distance(__f, __l);
+	  resize(_M_num_elements + __n);
+	  for ( ; __n > 0; --__n, ++__f)
+	    insert_unique_noresize(*__f);
+	}
+
+      template<class _ForwardIterator>
+        void
+        insert_equal(_ForwardIterator __f, _ForwardIterator __l,
+		     forward_iterator_tag)
+        {
+	  size_type __n = distance(__f, __l);
+	  resize(_M_num_elements + __n);
+	  for ( ; __n > 0; --__n, ++__f)
+	    insert_equal_noresize(*__f);
+	}
+
+      reference
+      find_or_insert(const value_type& __obj);
+
+      iterator
+      find(const key_type& __key)
+      {
+	size_type __n = _M_bkt_num_key(__key);
+	_Node* __first;
+	for (__first = _M_buckets[__n];
+	     __first && !_M_equals(_M_get_key(__first->_M_val), __key);
+	     __first = __first->_M_next)
+	  { }
+	return iterator(__first, this);
+      }
+
+      const_iterator
+      find(const key_type& __key) const
+      {
+	size_type __n = _M_bkt_num_key(__key);
+	const _Node* __first;
+	for (__first = _M_buckets[__n];
+	     __first && !_M_equals(_M_get_key(__first->_M_val), __key);
+	     __first = __first->_M_next)
+	  { }
+	return const_iterator(__first, this);
+      }
+
+      size_type
+      count(const key_type& __key) const
+      {
+	const size_type __n = _M_bkt_num_key(__key);
+	size_type __result = 0;
+	
+	for (const _Node* __cur = _M_buckets[__n]; __cur;
+	     __cur = __cur->_M_next)
+	  if (_M_equals(_M_get_key(__cur->_M_val), __key))
+	    ++__result;
+	return __result;
+      }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __key);
+
+      pair<const_iterator, const_iterator>
+      equal_range(const key_type& __key) const;
+
+      size_type
+      erase(const key_type& __key);
+      
+      void
+      erase(const iterator& __it);
+
+      void
+      erase(iterator __first, iterator __last);
+
+      void
+      erase(const const_iterator& __it);
+
+      void
+      erase(const_iterator __first, const_iterator __last);
+
+      void
+      resize(size_type __num_elements_hint);
+
+      void
+      clear();
+
+    private:
+      size_type
+      _M_next_size(size_type __n) const
+      { return __stl_next_prime(__n); }
+
+      void
+      _M_initialize_buckets(size_type __n)
+      {
+	const size_type __n_buckets = _M_next_size(__n);
+	_M_buckets.reserve(__n_buckets);
+	_M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0);
+	_M_num_elements = 0;
+      }
+
+      size_type
+      _M_bkt_num_key(const key_type& __key) const
+      { return _M_bkt_num_key(__key, _M_buckets.size()); }
+
+      size_type
+      _M_bkt_num(const value_type& __obj) const
+      { return _M_bkt_num_key(_M_get_key(__obj)); }
+
+      size_type
+      _M_bkt_num_key(const key_type& __key, size_t __n) const
+      { return _M_hash(__key) % __n; }
+
+      size_type
+      _M_bkt_num(const value_type& __obj, size_t __n) const
+      { return _M_bkt_num_key(_M_get_key(__obj), __n); }
+
+      _Node*
+      _M_new_node(const value_type& __obj)
+      {
+	_Node* __n = _M_get_node();
+	__n->_M_next = 0;
+	__try
+	  {
+	    this->get_allocator().construct(&__n->_M_val, __obj);
+	    return __n;
+	  }
+	__catch(...)
+	  {
+	    _M_put_node(__n);
+	    __throw_exception_again;
+	  }
+      }
+
+      void
+      _M_delete_node(_Node* __n)
+      {
+	this->get_allocator().destroy(&__n->_M_val);
+	_M_put_node(__n);
+      }
+      
+      void
+      _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last);
+
+      void
+      _M_erase_bucket(const size_type __n, _Node* __last);
+
+      void
+      _M_copy_from(const hashtable& __ht);
+    };
+
+  template<class _Val, class _Key, class _HF, class _ExK, class _EqK,
+	    class _All>
+    _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>&
+    _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::
+    operator++()
+    {
+      const _Node* __old = _M_cur;
+      _M_cur = _M_cur->_M_next;
+      if (!_M_cur)
+	{
+	  size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
+	  while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
+	    _M_cur = _M_ht->_M_buckets[__bucket];
+	}
+      return *this;
+    }
+
+  template<class _Val, class _Key, class _HF, class _ExK, class _EqK,
+	    class _All>
+    inline _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>
+    _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::
+    operator++(int)
+    {
+      iterator __tmp = *this;
+      ++*this;
+      return __tmp;
+    }
+
+  template<class _Val, class _Key, class _HF, class _ExK, class _EqK,
+	    class _All>
+    _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>&
+    _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::
+    operator++()
+    {
+      const _Node* __old = _M_cur;
+      _M_cur = _M_cur->_M_next;
+      if (!_M_cur)
+	{
+	  size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
+	  while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
+	    _M_cur = _M_ht->_M_buckets[__bucket];
+	}
+      return *this;
+    }
+
+  template<class _Val, class _Key, class _HF, class _ExK, class _EqK,
+	    class _All>
+    inline _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>
+    _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::
+    operator++(int)
+    {
+      const_iterator __tmp = *this;
+      ++*this;
+      return __tmp;
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    bool
+    operator==(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1,
+	       const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2)
+    {
+      typedef typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::_Node _Node;
+
+      if (__ht1._M_buckets.size() != __ht2._M_buckets.size())
+	return false;
+
+      for (size_t __n = 0; __n < __ht1._M_buckets.size(); ++__n)
+	{
+	  _Node* __cur1 = __ht1._M_buckets[__n];
+	  _Node* __cur2 = __ht2._M_buckets[__n];
+	  // Check same length of lists
+	  for (; __cur1 && __cur2;
+	       __cur1 = __cur1->_M_next, __cur2 = __cur2->_M_next)
+	    { } 
+	  if (__cur1 || __cur2)
+	    return false;
+	  // Now check one's elements are in the other
+	  for (__cur1 = __ht1._M_buckets[__n] ; __cur1;
+	       __cur1 = __cur1->_M_next)
+	    {
+	      bool _found__cur1 = false;
+	      for (__cur2 = __ht2._M_buckets[__n];
+		   __cur2; __cur2 = __cur2->_M_next)
+		{
+		  if (__cur1->_M_val == __cur2->_M_val)
+		    {
+		      _found__cur1 = true;
+		      break;
+		    }
+		}
+	      if (!_found__cur1)
+		return false;
+	    }
+	}
+      return true;
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    inline bool
+    operator!=(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1,
+	       const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2)
+    { return !(__ht1 == __ht2); }
+
+  template<class _Val, class _Key, class _HF, class _Extract, class _EqKey,
+	    class _All>
+    inline void
+    swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1,
+	 hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht2)
+    { __ht1.swap(__ht2); }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator, bool>
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    insert_unique_noresize(const value_type& __obj)
+    {
+      const size_type __n = _M_bkt_num(__obj);
+      _Node* __first = _M_buckets[__n];
+      
+      for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
+	if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
+	  return pair<iterator, bool>(iterator(__cur, this), false);
+      
+      _Node* __tmp = _M_new_node(__obj);
+      __tmp->_M_next = __first;
+      _M_buckets[__n] = __tmp;
+      ++_M_num_elements;
+      return pair<iterator, bool>(iterator(__tmp, this), true);
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    insert_equal_noresize(const value_type& __obj)
+    {
+      const size_type __n = _M_bkt_num(__obj);
+      _Node* __first = _M_buckets[__n];
+      
+      for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
+	if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
+	  {
+	    _Node* __tmp = _M_new_node(__obj);
+	    __tmp->_M_next = __cur->_M_next;
+	    __cur->_M_next = __tmp;
+	    ++_M_num_elements;
+	    return iterator(__tmp, this);
+	  }
+
+      _Node* __tmp = _M_new_node(__obj);
+      __tmp->_M_next = __first;
+      _M_buckets[__n] = __tmp;
+      ++_M_num_elements;
+      return iterator(__tmp, this);
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::reference
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    find_or_insert(const value_type& __obj)
+    {
+      resize(_M_num_elements + 1);
+
+      size_type __n = _M_bkt_num(__obj);
+      _Node* __first = _M_buckets[__n];
+      
+      for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
+	if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
+	  return __cur->_M_val;
+      
+      _Node* __tmp = _M_new_node(__obj);
+      __tmp->_M_next = __first;
+      _M_buckets[__n] = __tmp;
+      ++_M_num_elements;
+      return __tmp->_M_val;
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator,
+	 typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator>
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    equal_range(const key_type& __key)
+    {
+      typedef pair<iterator, iterator> _Pii;
+      const size_type __n = _M_bkt_num_key(__key);
+
+      for (_Node* __first = _M_buckets[__n]; __first;
+	   __first = __first->_M_next)
+	if (_M_equals(_M_get_key(__first->_M_val), __key))
+	  {
+	    for (_Node* __cur = __first->_M_next; __cur;
+		 __cur = __cur->_M_next)
+	      if (!_M_equals(_M_get_key(__cur->_M_val), __key))
+		return _Pii(iterator(__first, this), iterator(__cur, this));
+	    for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
+	      if (_M_buckets[__m])
+		return _Pii(iterator(__first, this),
+			    iterator(_M_buckets[__m], this));
+	    return _Pii(iterator(__first, this), end());
+	  }
+      return _Pii(end(), end());
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator,
+	 typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator>
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    equal_range(const key_type& __key) const
+    {
+      typedef pair<const_iterator, const_iterator> _Pii;
+      const size_type __n = _M_bkt_num_key(__key);
+
+      for (const _Node* __first = _M_buckets[__n]; __first;
+	   __first = __first->_M_next)
+	{
+	  if (_M_equals(_M_get_key(__first->_M_val), __key))
+	    {
+	      for (const _Node* __cur = __first->_M_next; __cur;
+		   __cur = __cur->_M_next)
+		if (!_M_equals(_M_get_key(__cur->_M_val), __key))
+		  return _Pii(const_iterator(__first, this),
+			      const_iterator(__cur, this));
+	      for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
+		if (_M_buckets[__m])
+		  return _Pii(const_iterator(__first, this),
+			      const_iterator(_M_buckets[__m], this));
+	      return _Pii(const_iterator(__first, this), end());
+	    }
+	}
+      return _Pii(end(), end());
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::size_type
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    erase(const key_type& __key)
+    {
+      const size_type __n = _M_bkt_num_key(__key);
+      _Node* __first = _M_buckets[__n];
+      _Node* __saved_slot = 0;
+      size_type __erased = 0;
+
+      if (__first)
+	{
+	  _Node* __cur = __first;
+	  _Node* __next = __cur->_M_next;
+	  while (__next)
+	    {
+	      if (_M_equals(_M_get_key(__next->_M_val), __key))
+		{
+		  if (&_M_get_key(__next->_M_val) != &__key)
+		    {
+		      __cur->_M_next = __next->_M_next;
+		      _M_delete_node(__next);
+		      __next = __cur->_M_next;
+		      ++__erased;
+		      --_M_num_elements;
+		    }
+		  else
+		    {
+		      __saved_slot = __cur;
+		      __cur = __next;
+		      __next = __cur->_M_next;
+		    }
+		}
+	      else
+		{
+		  __cur = __next;
+		  __next = __cur->_M_next;
+		}
+	    }
+	  bool __delete_first = _M_equals(_M_get_key(__first->_M_val), __key);
+	  if (__saved_slot)
+	    {
+	      __next = __saved_slot->_M_next;
+	      __saved_slot->_M_next = __next->_M_next;
+	      _M_delete_node(__next);
+	      ++__erased;
+	      --_M_num_elements;
+	    }
+	  if (__delete_first)
+	    {
+	      _M_buckets[__n] = __first->_M_next;
+	      _M_delete_node(__first);
+	      ++__erased;
+	      --_M_num_elements;
+	    }
+	}
+      return __erased;
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    erase(const iterator& __it)
+    {
+      _Node* __p = __it._M_cur;
+      if (__p)
+	{
+	  const size_type __n = _M_bkt_num(__p->_M_val);
+	  _Node* __cur = _M_buckets[__n];
+	  
+	  if (__cur == __p)
+	    {
+	      _M_buckets[__n] = __cur->_M_next;
+	      _M_delete_node(__cur);
+	      --_M_num_elements;
+	    }
+	  else
+	    {
+	      _Node* __next = __cur->_M_next;
+	      while (__next)
+		{
+		  if (__next == __p)
+		    {
+		      __cur->_M_next = __next->_M_next;
+		      _M_delete_node(__next);
+		      --_M_num_elements;
+		      break;
+		    }
+		  else
+		    {
+		      __cur = __next;
+		      __next = __cur->_M_next;
+		    }
+		}
+	    }
+	}
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    erase(iterator __first, iterator __last)
+    {
+      size_type __f_bucket = __first._M_cur ? _M_bkt_num(__first._M_cur->_M_val)
+	                                    : _M_buckets.size();
+
+      size_type __l_bucket = __last._M_cur ? _M_bkt_num(__last._M_cur->_M_val)
+	                                   : _M_buckets.size();
+
+      if (__first._M_cur == __last._M_cur)
+	return;
+      else if (__f_bucket == __l_bucket)
+	_M_erase_bucket(__f_bucket, __first._M_cur, __last._M_cur);
+      else
+	{
+	  _M_erase_bucket(__f_bucket, __first._M_cur, 0);
+	  for (size_type __n = __f_bucket + 1; __n < __l_bucket; ++__n)
+	    _M_erase_bucket(__n, 0);
+	  if (__l_bucket != _M_buckets.size())
+	    _M_erase_bucket(__l_bucket, __last._M_cur);
+	}
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    inline void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    erase(const_iterator __first, const_iterator __last)
+    {
+      erase(iterator(const_cast<_Node*>(__first._M_cur),
+		     const_cast<hashtable*>(__first._M_ht)),
+	    iterator(const_cast<_Node*>(__last._M_cur),
+		     const_cast<hashtable*>(__last._M_ht)));
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    inline void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    erase(const const_iterator& __it)
+    { erase(iterator(const_cast<_Node*>(__it._M_cur),
+		     const_cast<hashtable*>(__it._M_ht))); }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    resize(size_type __num_elements_hint)
+    {
+      const size_type __old_n = _M_buckets.size();
+      if (__num_elements_hint > __old_n)
+	{
+	  const size_type __n = _M_next_size(__num_elements_hint);
+	  if (__n > __old_n)
+	    {
+	      _Vector_type __tmp(__n, (_Node*)(0), _M_buckets.get_allocator());
+	      __try
+		{
+		  for (size_type __bucket = 0; __bucket < __old_n; ++__bucket)
+		    {
+		      _Node* __first = _M_buckets[__bucket];
+		      while (__first)
+			{
+			  size_type __new_bucket = _M_bkt_num(__first->_M_val,
+							      __n);
+			  _M_buckets[__bucket] = __first->_M_next;
+			  __first->_M_next = __tmp[__new_bucket];
+			  __tmp[__new_bucket] = __first;
+			  __first = _M_buckets[__bucket];
+			}
+		    }
+		  _M_buckets.swap(__tmp);
+		}
+	      __catch(...)
+		{
+		  for (size_type __bucket = 0; __bucket < __tmp.size();
+		       ++__bucket)
+		    {
+		      while (__tmp[__bucket])
+			{
+			  _Node* __next = __tmp[__bucket]->_M_next;
+			  _M_delete_node(__tmp[__bucket]);
+			  __tmp[__bucket] = __next;
+			}
+		    }
+		  __throw_exception_again;
+		}
+	    }
+	}
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last)
+    {
+      _Node* __cur = _M_buckets[__n];
+      if (__cur == __first)
+	_M_erase_bucket(__n, __last);
+      else
+	{
+	  _Node* __next;
+	  for (__next = __cur->_M_next;
+	       __next != __first;
+	       __cur = __next, __next = __cur->_M_next)
+	    ;
+	  while (__next != __last)
+	    {
+	      __cur->_M_next = __next->_M_next;
+	      _M_delete_node(__next);
+	      __next = __cur->_M_next;
+	      --_M_num_elements;
+	    }
+	}
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    _M_erase_bucket(const size_type __n, _Node* __last)
+    {
+      _Node* __cur = _M_buckets[__n];
+      while (__cur != __last)
+	{
+	  _Node* __next = __cur->_M_next;
+	  _M_delete_node(__cur);
+	  __cur = __next;
+	  _M_buckets[__n] = __cur;
+	  --_M_num_elements;
+	}
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    clear()
+    {
+      if (_M_num_elements == 0)
+	return;
+
+      for (size_type __i = 0; __i < _M_buckets.size(); ++__i)
+	{
+	  _Node* __cur = _M_buckets[__i];
+	  while (__cur != 0)
+	    {
+	      _Node* __next = __cur->_M_next;
+	      _M_delete_node(__cur);
+	      __cur = __next;
+	    }
+	  _M_buckets[__i] = 0;
+	}
+      _M_num_elements = 0;
+    }
+
+  template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
+    void
+    hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
+    _M_copy_from(const hashtable& __ht)
+    {
+      _M_buckets.clear();
+      _M_buckets.reserve(__ht._M_buckets.size());
+      _M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0);
+      __try
+	{
+	  for (size_type __i = 0; __i < __ht._M_buckets.size(); ++__i) {
+	    const _Node* __cur = __ht._M_buckets[__i];
+	    if (__cur)
+	      {
+		_Node* __local_copy = _M_new_node(__cur->_M_val);
+		_M_buckets[__i] = __local_copy;
+		
+		for (_Node* __next = __cur->_M_next;
+		     __next;
+		     __cur = __next, __next = __cur->_M_next)
+		  {
+		    __local_copy->_M_next = _M_new_node(__next->_M_val);
+		    __local_copy = __local_copy->_M_next;
+		  }
+	      }
+	  }
+	  _M_num_elements = __ht._M_num_elements;
+	}
+      __catch(...)
+	{
+	  clear();
+	  __throw_exception_again;
+	}
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/backward/strstream b/gcc-4.9/libstdc++-v3/include/backward/strstream
new file mode 100644
index 0000000..6d126a5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/backward/strstream
@@ -0,0 +1,184 @@
+// Backward-compat support -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+// WARNING: The classes defined in this header are DEPRECATED.  This
+// header is defined in section D.7.1 of the C++ standard, and it
+// MAY BE REMOVED in a future standard revision.  One should use the
+// header <sstream> instead.
+
+/** @file backward/strstream
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{sstream}
+ */
+
+#ifndef _BACKWARD_STRSTREAM
+#define _BACKWARD_STRSTREAM
+
+#include "backward_warning.h"
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <ostream>
+#include <string>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Class strstreambuf, a streambuf class that manages an array of char.
+  // Note that this class is not a template.
+  class strstreambuf : public basic_streambuf<char, char_traits<char> >
+  {
+  public:
+    // Types.
+    typedef char_traits<char>              _Traits;
+    typedef basic_streambuf<char, _Traits> _Base;
+
+  public:
+    // Constructor, destructor
+    explicit strstreambuf(streamsize __initial_capacity = 0);
+    strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*));
+
+    strstreambuf(char* __get, streamsize __n, char* __put = 0) throw ();
+    strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0) throw ();
+    strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0) throw ();
+
+    strstreambuf(const char* __get, streamsize __n) throw ();
+    strstreambuf(const signed char* __get, streamsize __n) throw ();
+    strstreambuf(const unsigned char* __get, streamsize __n) throw ();
+
+    virtual ~strstreambuf();
+
+  public:
+    void freeze(bool = true) throw ();
+    char* str() throw ();
+    _GLIBCXX_PURE int pcount() const throw ();
+
+  protected:
+    virtual int_type overflow(int_type __c  = _Traits::eof());
+    virtual int_type pbackfail(int_type __c = _Traits::eof());
+    virtual int_type underflow();
+    virtual _Base* setbuf(char* __buf, streamsize __n);
+    virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir,
+			     ios_base::openmode __mode
+			     = ios_base::in | ios_base::out);
+    virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode
+			     = ios_base::in | ios_base::out);
+
+  private:
+    strstreambuf&
+    operator=(const strstreambuf&);
+
+    strstreambuf(const strstreambuf&);
+
+    // Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun.
+    char* _M_alloc(size_t);
+    void  _M_free(char*);
+
+    // Helper function used in constructors.
+    void _M_setup(char* __get, char* __put, streamsize __n) throw ();
+
+  private:
+    // Data members.
+    void* (*_M_alloc_fun)(size_t);
+    void  (*_M_free_fun)(void*);
+
+    bool _M_dynamic  : 1;
+    bool _M_frozen   : 1;
+    bool _M_constant : 1;
+  };
+
+  // Class istrstream, an istream that manages a strstreambuf.
+  class istrstream : public basic_istream<char>
+  {
+  public:
+    explicit istrstream(char*);
+    explicit istrstream(const char*);
+    istrstream(char* , streamsize);
+    istrstream(const char*, streamsize);
+    virtual ~istrstream();
+
+    _GLIBCXX_CONST strstreambuf* rdbuf() const throw ();
+    char* str() throw ();
+
+  private:
+    strstreambuf _M_buf;
+  };
+
+  // Class ostrstream
+  class ostrstream : public basic_ostream<char>
+  {
+  public:
+    ostrstream();
+    ostrstream(char*, int, ios_base::openmode = ios_base::out);
+    virtual ~ostrstream();
+
+    _GLIBCXX_CONST strstreambuf* rdbuf() const throw ();
+    void freeze(bool = true) throw();
+    char* str() throw ();
+    _GLIBCXX_PURE int pcount() const throw ();
+
+  private:
+    strstreambuf _M_buf;
+  };
+
+  // Class strstream
+  class strstream : public basic_iostream<char>
+  {
+  public:
+    typedef char                        char_type;
+    typedef char_traits<char>::int_type int_type;
+    typedef char_traits<char>::pos_type pos_type;
+    typedef char_traits<char>::off_type off_type;
+
+    strstream();
+    strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out);
+    virtual ~strstream();
+
+    _GLIBCXX_CONST strstreambuf* rdbuf() const throw ();
+    void freeze(bool = true) throw ();
+    _GLIBCXX_PURE int pcount() const throw ();
+    char* str() throw ();
+
+  private:
+    strstreambuf _M_buf;
+  };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/algorithmfwd.h b/gcc-4.9/libstdc++-v3/include/bits/algorithmfwd.h
new file mode 100644
index 0000000..aee1eec
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/algorithmfwd.h
@@ -0,0 +1,826 @@
+// <algorithm> Forward declarations  -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/algorithmfwd.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{algorithm}
+ */
+
+#ifndef _GLIBCXX_ALGORITHMFWD_H
+#define _GLIBCXX_ALGORITHMFWD_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stl_pair.h>
+#include <bits/stl_iterator_base_types.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /*
+    adjacent_find
+    all_of (C++0x)
+    any_of (C++0x)
+    binary_search
+    copy
+    copy_backward
+    copy_if (C++0x)
+    copy_n (C++0x)
+    count
+    count_if
+    equal
+    equal_range
+    fill
+    fill_n
+    find
+    find_end
+    find_first_of
+    find_if
+    find_if_not (C++0x)
+    for_each
+    generate
+    generate_n
+    includes
+    inplace_merge
+    is_heap (C++0x)
+    is_heap_until (C++0x)
+    is_partitioned (C++0x)
+    is_sorted (C++0x)
+    is_sorted_until (C++0x)
+    iter_swap
+    lexicographical_compare
+    lower_bound
+    make_heap
+    max
+    max_element
+    merge
+    min
+    min_element
+    minmax (C++0x)
+    minmax_element (C++0x)
+    mismatch
+    next_permutation
+    none_of (C++0x)
+    nth_element
+    partial_sort
+    partial_sort_copy
+    partition
+    partition_copy (C++0x)
+    partition_point (C++0x)
+    pop_heap
+    prev_permutation
+    push_heap
+    random_shuffle
+    remove
+    remove_copy
+    remove_copy_if
+    remove_if
+    replace
+    replace_copy
+    replace_copy_if
+    replace_if
+    reverse
+    reverse_copy
+    rotate
+    rotate_copy
+    search
+    search_n
+    set_difference
+    set_intersection
+    set_symmetric_difference
+    set_union
+    shuffle (C++0x)
+    sort
+    sort_heap
+    stable_partition
+    stable_sort
+    swap
+    swap_ranges
+    transform
+    unique
+    unique_copy
+    upper_bound
+  */
+
+  /**
+   * @defgroup algorithms Algorithms
+   *
+   * Components for performing algorithmic operations. Includes
+   * non-modifying sequence, modifying (mutating) sequence, sorting,
+   * searching, merge, partition, heap, set, minima, maxima, and
+   * permutation operations.
+   */
+
+  /**
+   * @defgroup mutating_algorithms Mutating
+   * @ingroup algorithms
+   */
+
+  /**
+   * @defgroup non_mutating_algorithms Non-Mutating
+   * @ingroup algorithms
+   */
+
+  /**
+   * @defgroup sorting_algorithms Sorting
+   * @ingroup algorithms
+   */
+
+  /**
+   * @defgroup set_algorithms Set Operation
+   * @ingroup sorting_algorithms
+   *
+   * These algorithms are common set operations performed on sequences
+   * that are already sorted. The number of comparisons will be
+   * linear.
+   */
+
+  /**
+   * @defgroup binary_search_algorithms Binary Search
+   * @ingroup sorting_algorithms
+   *
+   * These algorithms are variations of a classic binary search, and
+   * all assume that the sequence being searched is already sorted.
+   * 
+   * The number of comparisons will be logarithmic (and as few as
+   * possible).  The number of steps through the sequence will be
+   * logarithmic for random-access iterators (e.g., pointers), and
+   * linear otherwise.
+   * 
+   * The LWG has passed Defect Report 270, which notes: <em>The
+   * proposed resolution reinterprets binary search. Instead of
+   * thinking about searching for a value in a sorted range, we view
+   * that as an important special case of a more general algorithm:
+   * searching for the partition point in a partitioned range.  We
+   * also add a guarantee that the old wording did not: we ensure that
+   * the upper bound is no earlier than the lower bound, that the pair
+   * returned by equal_range is a valid range, and that the first part
+   * of that pair is the lower bound.</em>
+   *
+   * The actual effect of the first sentence is that a comparison
+   * functor passed by the user doesn't necessarily need to induce a
+   * strict weak ordering relation.  Rather, it partitions the range.
+   */
+
+  // adjacent_find
+
+#if __cplusplus >= 201103L
+  template<typename _IIter, typename _Predicate>
+    bool
+    all_of(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Predicate>
+    bool
+    any_of(_IIter, _IIter, _Predicate);
+#endif
+
+  template<typename _FIter, typename _Tp>
+    bool 
+    binary_search(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    bool 
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _IIter, typename _OIter>
+    _OIter 
+    copy(_IIter, _IIter, _OIter);
+
+  template<typename _BIter1, typename _BIter2>
+    _BIter2
+    copy_backward(_BIter1, _BIter1, _BIter2);
+
+#if __cplusplus >= 201103L
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+  template<typename _IIter, typename _Size, typename _OIter>
+    _OIter
+    copy_n(_IIter, _Size, _OIter);
+#endif
+
+  // count
+  // count_if
+
+  template<typename _FIter, typename _Tp>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter, typename _Tp>
+    void 
+    fill(_FIter, _FIter, const _Tp&);
+
+  template<typename _OIter, typename _Size, typename _Tp>
+    _OIter
+    fill_n(_OIter, _Size, const _Tp&);
+
+  // find
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  // find_first_of
+  // find_if
+
+#if __cplusplus >= 201103L
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if_not(_IIter, _IIter, _Predicate);
+#endif
+
+  // for_each
+  // generate
+  // generate_n
+
+  template<typename _IIter1, typename _IIter2>
+    bool 
+    includes(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool 
+    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _BIter>
+    void 
+    inplace_merge(_BIter, _BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    void 
+    inplace_merge(_BIter, _BIter, _BIter, _Compare);
+
+#if __cplusplus >= 201103L
+  template<typename _RAIter>
+    bool 
+    is_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    bool 
+    is_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    _RAIter 
+    is_heap_until(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    _RAIter 
+    is_heap_until(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _Predicate>
+    bool
+    is_partitioned(_IIter, _IIter, _Predicate);
+
+  template<typename _FIter1, typename _FIter2>
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2);
+
+  template<typename _FIter1, typename _FIter2,
+	   typename _BinaryPredicate>
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter>
+    bool 
+    is_sorted(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    bool 
+    is_sorted(_FIter, _FIter, _Compare);
+
+  template<typename _FIter>
+    _FIter 
+    is_sorted_until(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter 
+    is_sorted_until(_FIter, _FIter, _Compare);
+#endif
+
+  template<typename _FIter1, typename _FIter2>
+    void 
+    iter_swap(_FIter1, _FIter2);
+
+  template<typename _FIter, typename _Tp>
+    _FIter 
+    lower_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter 
+    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _RAIter>
+    void 
+    make_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    make_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _Tp> 
+    const _Tp& 
+    max(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    const _Tp& 
+    max(const _Tp&, const _Tp&, _Compare);
+
+  // max_element
+  // merge
+
+  template<typename _Tp> 
+    const _Tp& 
+    min(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    const _Tp& 
+    min(const _Tp&, const _Tp&, _Compare);
+
+  // min_element
+
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    pair<const _Tp&, const _Tp&> 
+    minmax(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&, _Compare);
+
+  template<typename _FIter>
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter, _Compare);
+
+  template<typename _Tp>
+    _Tp
+    min(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    _Tp
+    min(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    _Tp
+    max(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    _Tp
+    max(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>, _Compare);
+#endif
+
+  // mismatch
+
+  template<typename _BIter>
+    bool 
+    next_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool 
+    next_permutation(_BIter, _BIter, _Compare);
+
+#if __cplusplus >= 201103L
+  template<typename _IIter, typename _Predicate>
+    bool
+    none_of(_IIter, _IIter, _Predicate);
+#endif
+
+  // nth_element
+  // partial_sort
+
+  template<typename _IIter, typename _RAIter>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+
+  template<typename _IIter, typename _RAIter, typename _Compare>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+
+  // partition
+
+#if __cplusplus >= 201103L
+  template<typename _IIter, typename _OIter1,
+	   typename _OIter2, typename _Predicate>
+    pair<_OIter1, _OIter2>
+    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
+
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    partition_point(_FIter, _FIter, _Predicate);
+#endif
+
+  template<typename _RAIter>
+    void 
+    pop_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    pop_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter>
+    bool 
+    prev_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool 
+    prev_permutation(_BIter, _BIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    push_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    push_heap(_RAIter, _RAIter, _Compare);
+
+  // random_shuffle
+
+  template<typename _FIter, typename _Tp>
+    _FIter 
+    remove(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Predicate>
+    _FIter 
+    remove_if(_FIter, _FIter, _Predicate);
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter 
+    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter 
+    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+  // replace
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter 
+    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+
+  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
+    _OIter 
+    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+
+  // replace_if
+
+  template<typename _BIter>
+    void 
+    reverse(_BIter, _BIter);
+
+  template<typename _BIter, typename _OIter>
+    _OIter 
+    reverse_copy(_BIter, _BIter, _OIter);
+
+  template<typename _FIter>
+    void 
+    rotate(_FIter, _FIter, _FIter);
+
+  template<typename _FIter, typename _OIter>
+    _OIter 
+    rotate_copy(_FIter, _FIter, _FIter, _OIter);
+
+  // search
+  // search_n
+  // set_difference
+  // set_intersection
+  // set_symmetric_difference
+  // set_union
+
+#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
+  template<typename _RAIter, typename _UGenerator>
+    void
+    shuffle(_RAIter, _RAIter, _UGenerator&&);
+#endif
+
+  template<typename _RAIter>
+    void 
+    sort_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    sort_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter 
+    stable_partition(_BIter, _BIter, _Predicate);
+
+  template<typename _Tp> 
+    void 
+    swap(_Tp&, _Tp&)
+#if __cplusplus >= 201103L
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+	            is_nothrow_move_assignable<_Tp>>::value)
+#endif
+    ;
+
+  template<typename _Tp, size_t _Nm>
+    void
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+#if __cplusplus >= 201103L
+    noexcept(noexcept(swap(*__a, *__b)))
+#endif
+    ;
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter2 
+    swap_ranges(_FIter1, _FIter1, _FIter2);
+
+  // transform
+
+  template<typename _FIter>
+    _FIter 
+    unique(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter 
+    unique(_FIter, _FIter, _BinaryPredicate);
+
+  // unique_copy
+
+  template<typename _FIter, typename _Tp>
+    _FIter 
+    upper_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter 
+    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
+
+  template<typename _FIter>
+    _FIter 
+    adjacent_find(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter 
+    adjacent_find(_FIter, _FIter, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2>
+    bool 
+    equal(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    bool 
+    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+    _IIter 
+    find(_IIter, _IIter, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Funct>
+    _Funct 
+    for_each(_IIter, _IIter, _Funct);
+
+  template<typename _FIter, typename _Generator>
+    void 
+    generate(_FIter, _FIter, _Generator);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator);
+
+  template<typename _IIter1, typename _IIter2>
+    bool 
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool 
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _FIter>
+    _FIter 
+    max_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter 
+    max_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _Compare>
+    _OIter 
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _FIter>
+    _FIter 
+    min_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter 
+    min_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _RAIter>
+    void 
+    nth_element(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    partial_sort(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter 
+    partition(_BIter, _BIter, _Predicate);
+
+  template<typename _RAIter>
+    void 
+    random_shuffle(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Generator>
+    void 
+    random_shuffle(_RAIter, _RAIter,
+#if __cplusplus >= 201103L
+		   _Generator&&);
+#else
+		   _Generator&);
+#endif
+
+  template<typename _FIter, typename _Tp>
+    void 
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void 
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1 
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1 
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter, typename _Size, typename _Tp>
+    _FIter 
+    search_n(_FIter, _FIter, _Size, const _Tp&);
+
+  template<typename _FIter, typename _Size, typename _Tp, 
+	   typename _BinaryPredicate>
+    _FIter 
+    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _Compare>
+    _OIter 
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
+    _OIter 
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _Compare>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 
+			     _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
+    _OIter 
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void 
+    stable_sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void 
+    stable_sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter 
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter, 
+	   typename _BinaryOperation>
+    _OIter 
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+
+  template<typename _IIter, typename _OIter>
+    _OIter 
+    unique_copy(_IIter, _IIter, _OIter);
+
+  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
+    _OIter 
+    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
+
+#ifdef _GLIBCXX_PARALLEL
+# include <parallel/algorithmfwd.h>
+#endif
+
+#endif
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/alloc_traits.h b/gcc-4.9/libstdc++-v3/include/bits/alloc_traits.h
new file mode 100644
index 0000000..23fe8de
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/alloc_traits.h
@@ -0,0 +1,533 @@
+// Allocator traits -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/alloc_traits.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _ALLOC_TRAITS_H
+#define _ALLOC_TRAITS_H 1
+
+#if __cplusplus >= 201103L
+
+#include <bits/memoryfwd.h>
+#include <bits/ptr_traits.h>
+#include <ext/numeric_traits.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Alloc, typename _Tp>
+    class __alloctr_rebind_helper
+    {
+      template<typename _Alloc2, typename _Tp2>
+	static constexpr true_type
+	_S_chk(typename _Alloc2::template rebind<_Tp2>::other*);
+
+      template<typename, typename>
+	static constexpr false_type
+	_S_chk(...);
+
+    public:
+      using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr));
+    };
+
+  template<typename _Alloc, typename _Tp,
+	   bool = __alloctr_rebind_helper<_Alloc, _Tp>::__type::value>
+    struct __alloctr_rebind;
+
+  template<typename _Alloc, typename _Tp>
+    struct __alloctr_rebind<_Alloc, _Tp, true>
+    {
+      typedef typename _Alloc::template rebind<_Tp>::other __type;
+    };
+
+  template<template<typename, typename...> class _Alloc, typename _Tp,
+	   typename _Up, typename... _Args>
+    struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false>
+    {
+      typedef _Alloc<_Tp, _Args...> __type;
+    };
+
+  /**
+   * @brief  Uniform interface to all allocator types.
+   * @ingroup allocators
+  */
+  template<typename _Alloc>
+    struct allocator_traits
+    {
+      /// The allocator type
+      typedef _Alloc allocator_type;
+      /// The allocated type
+      typedef typename _Alloc::value_type value_type;
+
+#define _GLIBCXX_ALLOC_TR_NESTED_TYPE(_NTYPE, _ALT) \
+  private: \
+  template<typename _Tp> \
+    static typename _Tp::_NTYPE _S_##_NTYPE##_helper(_Tp*); \
+  static _ALT _S_##_NTYPE##_helper(...); \
+    typedef decltype(_S_##_NTYPE##_helper((_Alloc*)0)) __##_NTYPE; \
+  public:
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(pointer, value_type*)
+
+      /**
+       * @brief   The allocator's pointer type.
+       *
+       * @c Alloc::pointer if that type exists, otherwise @c value_type*
+      */
+      typedef __pointer pointer;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(const_pointer,
+  typename pointer_traits<pointer>::template rebind<const value_type>)
+
+      /**
+       * @brief   The allocator's const pointer type.
+       *
+       * @c Alloc::const_pointer if that type exists, otherwise
+       * <tt> pointer_traits<pointer>::rebind<const value_type> </tt>
+      */
+      typedef __const_pointer const_pointer;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(void_pointer,
+  typename pointer_traits<pointer>::template rebind<void>)
+
+      /**
+       * @brief   The allocator's void pointer type.
+       *
+       * @c Alloc::void_pointer if that type exists, otherwise
+       * <tt> pointer_traits<pointer>::rebind<void> </tt>
+      */
+      typedef __void_pointer void_pointer;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(const_void_pointer,
+  typename pointer_traits<pointer>::template rebind<const void>)
+
+      /**
+       * @brief   The allocator's const void pointer type.
+       *
+       * @c Alloc::const_void_pointer if that type exists, otherwise
+       * <tt> pointer_traits<pointer>::rebind<const void> </tt>
+      */
+      typedef __const_void_pointer const_void_pointer;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(difference_type,
+			      typename pointer_traits<pointer>::difference_type)
+
+      /**
+       * @brief   The allocator's difference type
+       *
+       * @c Alloc::difference_type if that type exists, otherwise
+       * <tt> pointer_traits<pointer>::difference_type </tt>
+      */
+      typedef __difference_type difference_type;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(size_type,
+			      typename make_unsigned<difference_type>::type)
+
+      /**
+       * @brief   The allocator's size type
+       *
+       * @c Alloc::size_type if that type exists, otherwise
+       * <tt> make_unsigned<difference_type>::type </tt>
+      */
+      typedef __size_type size_type;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_copy_assignment,
+			      false_type)
+
+      /**
+       * @brief   How the allocator is propagated on copy assignment
+       *
+       * @c Alloc::propagate_on_container_copy_assignment if that type exists,
+       * otherwise @c false_type
+      */
+      typedef __propagate_on_container_copy_assignment
+	propagate_on_container_copy_assignment;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_move_assignment,
+			      false_type)
+
+      /**
+       * @brief   How the allocator is propagated on move assignment
+       *
+       * @c Alloc::propagate_on_container_move_assignment if that type exists,
+       * otherwise @c false_type
+      */
+      typedef __propagate_on_container_move_assignment
+	propagate_on_container_move_assignment;
+
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_swap,
+			      false_type)
+
+      /**
+       * @brief   How the allocator is propagated on swap
+       *
+       * @c Alloc::propagate_on_container_swap if that type exists,
+       * otherwise @c false_type
+      */
+      typedef __propagate_on_container_swap propagate_on_container_swap;
+
+#undef _GLIBCXX_ALLOC_TR_NESTED_TYPE
+
+      template<typename _Tp>
+	using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type;
+      template<typename _Tp>
+	using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
+
+    private:
+      template<typename _Alloc2>
+	struct __allocate_helper
+	{
+	  template<typename _Alloc3,
+	    typename = decltype(std::declval<_Alloc3*>()->allocate(
+		  std::declval<size_type>(),
+		  std::declval<const_void_pointer>()))>
+	    static true_type __test(int);
+
+	  template<typename>
+	    static false_type __test(...);
+
+	  using type = decltype(__test<_Alloc>(0));
+	};
+
+      template<typename _Alloc2>
+	using __has_allocate = typename __allocate_helper<_Alloc2>::type;
+
+      template<typename _Alloc2,
+	       typename = _Require<__has_allocate<_Alloc2>>>
+	static pointer
+	_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint)
+	{ return __a.allocate(__n, __hint); }
+
+      template<typename _Alloc2, typename _UnusedHint,
+	       typename = _Require<__not_<__has_allocate<_Alloc2>>>>
+	static pointer
+	_S_allocate(_Alloc2& __a, size_type __n, _UnusedHint)
+	{ return __a.allocate(__n); }
+
+      template<typename _Tp, typename... _Args>
+	struct __construct_helper
+	{
+	  template<typename _Alloc2,
+	    typename = decltype(std::declval<_Alloc2*>()->construct(
+		  std::declval<_Tp*>(), std::declval<_Args>()...))>
+	    static true_type __test(int);
+
+	  template<typename>
+	    static false_type __test(...);
+
+	  using type = decltype(__test<_Alloc>(0));
+	};
+
+      template<typename _Tp, typename... _Args>
+	using __has_construct
+	  = typename __construct_helper<_Tp, _Args...>::type;
+
+      template<typename _Tp, typename... _Args>
+	static _Require<__has_construct<_Tp, _Args...>>
+	_S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+	{ __a.construct(__p, std::forward<_Args>(__args)...); }
+
+      template<typename _Tp, typename... _Args>
+	static
+	_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
+			       is_constructible<_Tp, _Args...>>>
+	_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
+	{ ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
+
+      template<typename _Tp>
+	struct __destroy_helper
+	{
+	  template<typename _Alloc2,
+	    typename = decltype(std::declval<_Alloc2*>()->destroy(
+		  std::declval<_Tp*>()))>
+	    static true_type __test(int);
+
+	  template<typename>
+	    static false_type __test(...);
+
+	  using type = decltype(__test<_Alloc>(0));
+	};
+
+      template<typename _Tp>
+	using __has_destroy = typename __destroy_helper<_Tp>::type;
+
+      template<typename _Tp>
+	static _Require<__has_destroy<_Tp>>
+	_S_destroy(_Alloc& __a, _Tp* __p)
+	{ __a.destroy(__p); }
+
+      template<typename _Tp>
+	static _Require<__not_<__has_destroy<_Tp>>>
+	_S_destroy(_Alloc&, _Tp* __p)
+	{ __p->~_Tp(); }
+
+      template<typename _Alloc2>
+	struct __maxsize_helper
+	{
+	  template<typename _Alloc3,
+	    typename = decltype(std::declval<_Alloc3*>()->max_size())>
+	    static true_type __test(int);
+
+	  template<typename>
+	    static false_type __test(...);
+
+	  using type = decltype(__test<_Alloc2>(0));
+	};
+
+      template<typename _Alloc2>
+	using __has_max_size = typename __maxsize_helper<_Alloc2>::type;
+
+      template<typename _Alloc2,
+	       typename = _Require<__has_max_size<_Alloc2>>>
+	static size_type
+	_S_max_size(_Alloc2& __a, int)
+	{ return __a.max_size(); }
+
+      template<typename _Alloc2,
+	       typename = _Require<__not_<__has_max_size<_Alloc2>>>>
+	static size_type
+	_S_max_size(_Alloc2&, ...)
+	{ return __gnu_cxx::__numeric_traits<size_type>::__max; }
+
+      template<typename _Alloc2>
+	struct __select_helper
+	{
+	  template<typename _Alloc3, typename
+	    = decltype(std::declval<_Alloc3*>()
+		->select_on_container_copy_construction())>
+	    static true_type __test(int);
+
+	  template<typename>
+	    static false_type __test(...);
+
+	  using type = decltype(__test<_Alloc2>(0));
+	};
+
+      template<typename _Alloc2>
+	using __has_soccc = typename __select_helper<_Alloc2>::type;
+
+      template<typename _Alloc2,
+	       typename = _Require<__has_soccc<_Alloc2>>>
+	static _Alloc2
+	_S_select(_Alloc2& __a, int)
+	{ return __a.select_on_container_copy_construction(); }
+
+      template<typename _Alloc2,
+	       typename = _Require<__not_<__has_soccc<_Alloc2>>>>
+	static _Alloc2
+	_S_select(_Alloc2& __a, ...)
+	{ return __a; }
+
+    public:
+
+      /**
+       *  @brief  Allocate memory.
+       *  @param  __a  An allocator.
+       *  @param  __n  The number of objects to allocate space for.
+       *
+       *  Calls @c a.allocate(n)
+      */
+      static pointer
+      allocate(_Alloc& __a, size_type __n)
+      { return __a.allocate(__n); }
+
+      /**
+       *  @brief  Allocate memory.
+       *  @param  __a  An allocator.
+       *  @param  __n  The number of objects to allocate space for.
+       *  @param  __hint Aid to locality.
+       *  @return Memory of suitable size and alignment for @a n objects
+       *          of type @c value_type
+       *
+       *  Returns <tt> a.allocate(n, hint) </tt> if that expression is
+       *  well-formed, otherwise returns @c a.allocate(n)
+      */
+      static pointer
+      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
+      { return _S_allocate(__a, __n, __hint); }
+
+      /**
+       *  @brief  Deallocate memory.
+       *  @param  __a  An allocator.
+       *  @param  __p  Pointer to the memory to deallocate.
+       *  @param  __n  The number of objects space was allocated for.
+       *
+       *  Calls <tt> a.deallocate(p, n) </tt>
+      */
+      static void deallocate(_Alloc& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+
+      /**
+       *  @brief  Construct an object of type @a _Tp
+       *  @param  __a  An allocator.
+       *  @param  __p  Pointer to memory of suitable size and alignment for Tp
+       *  @param  __args Constructor arguments.
+       *
+       *  Calls <tt> __a.construct(__p, std::forward<Args>(__args)...) </tt>
+       *  if that expression is well-formed, otherwise uses placement-new
+       *  to construct an object of type @a _Tp at location @a __p from the
+       *  arguments @a __args...
+      */
+      template<typename _Tp, typename... _Args>
+	static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+	-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
+	{ _S_construct(__a, __p, std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief  Destroy an object of type @a _Tp
+       *  @param  __a  An allocator.
+       *  @param  __p  Pointer to the object to destroy
+       *
+       *  Calls @c __a.destroy(__p) if that expression is well-formed,
+       *  otherwise calls @c __p->~_Tp()
+      */
+      template <class _Tp>
+	static void destroy(_Alloc& __a, _Tp* __p)
+	{ _S_destroy(__a, __p); }
+
+      /**
+       *  @brief  The maximum supported allocation size
+       *  @param  __a  An allocator.
+       *  @return @c __a.max_size() or @c numeric_limits<size_type>::max()
+       *
+       *  Returns @c __a.max_size() if that expression is well-formed,
+       *  otherwise returns @c numeric_limits<size_type>::max()
+      */
+      static size_type max_size(const _Alloc& __a) noexcept
+      { return _S_max_size(__a, 0); }
+
+      /**
+       *  @brief  Obtain an allocator to use when copying a container.
+       *  @param  __rhs  An allocator.
+       *  @return @c __rhs.select_on_container_copy_construction() or @a __rhs
+       *
+       *  Returns @c __rhs.select_on_container_copy_construction() if that
+       *  expression is well-formed, otherwise returns @a __rhs
+      */
+      static _Alloc
+      select_on_container_copy_construction(const _Alloc& __rhs)
+      { return _S_select(__rhs, 0); }
+    };
+
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
+    { __one = __two; }
+
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
+    { }
+
+  template<typename _Alloc>
+    inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_copy_assignment __pocca;
+      __do_alloc_on_copy(__one, __two, __pocca());
+    }
+
+  template<typename _Alloc>
+    inline _Alloc __alloc_on_copy(const _Alloc& __a)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      return __traits::select_on_container_copy_construction(__a);
+    }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
+    { __one = std::move(__two); }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
+    { }
+
+  template<typename _Alloc>
+    inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_move_assignment __pocma;
+      __do_alloc_on_move(__one, __two, __pocma());
+    }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
+    {
+      using std::swap;
+      swap(__one, __two);
+    }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
+    { }
+
+  template<typename _Alloc>
+    inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_swap __pocs;
+      __do_alloc_on_swap(__one, __two, __pocs());
+    }
+
+  template<typename _Alloc>
+    class __is_copy_insertable_impl
+    {
+      typedef allocator_traits<_Alloc> _Traits;
+
+      template<typename _Up, typename
+	       = decltype(_Traits::construct(std::declval<_Alloc&>(),
+					     std::declval<_Up*>(),
+					     std::declval<const _Up&>()))>
+	static true_type
+	_M_select(int);
+
+      template<typename _Up>
+	static false_type
+	_M_select(...);
+
+    public:
+      typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
+    };
+
+  // true if _Alloc::value_type is CopyInsertable into containers using _Alloc
+  template<typename _Alloc>
+    struct __is_copy_insertable
+    : __is_copy_insertable_impl<_Alloc>::type
+    { };
+
+  // std::allocator<_Tp> just requires CopyConstructible
+  template<typename _Tp>
+    struct __is_copy_insertable<allocator<_Tp>>
+    : is_copy_constructible<_Tp>
+    { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/allocator.h b/gcc-4.9/libstdc++-v3/include/bits/allocator.h
new file mode 100644
index 0000000..e293c54
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/allocator.h
@@ -0,0 +1,221 @@
+// Allocators -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/allocator.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _ALLOCATOR_H
+#define _ALLOCATOR_H 1
+
+#include <bits/c++allocator.h> // Define the base class to std::allocator.
+#include <bits/memoryfwd.h>
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @addtogroup allocators
+   *  @{
+   */
+
+  /// allocator<void> specialization.
+  template<>
+    class allocator<void>
+    {
+    public:
+      typedef size_t      size_type;
+      typedef ptrdiff_t   difference_type;
+      typedef void*       pointer;
+      typedef const void* const_pointer;
+      typedef void        value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. std::allocator propagate_on_container_move_assignment
+      typedef true_type propagate_on_container_move_assignment;
+#endif
+    };
+
+  /**
+   * @brief  The @a standard allocator, as per [20.4].
+   *
+   *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
+   *  for further details.
+   *
+   *  @tparam  _Tp  Type of allocated object.
+   */
+  template<typename _Tp>
+    class allocator: public __allocator_base<_Tp>
+    {
+   public:
+      typedef size_t     size_type;
+      typedef ptrdiff_t  difference_type;
+      typedef _Tp*       pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp&       reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp        value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. std::allocator propagate_on_container_move_assignment
+      typedef true_type propagate_on_container_move_assignment;
+#endif
+
+      allocator() throw() { }
+
+      allocator(const allocator& __a) throw()
+      : __allocator_base<_Tp>(__a) { }
+
+      template<typename _Tp1>
+        allocator(const allocator<_Tp1>&) throw() { }
+
+      ~allocator() throw() { }
+
+      // Inherit everything else.
+    };
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator==(const allocator<_T1>&, const allocator<_T2>&)
+    { return true; }
+
+  template<typename _Tp>
+    inline bool
+    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
+    { return true; }
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    { return false; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
+    { return false; }
+
+  /// @} group allocator
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class allocator<char>;
+  extern template class allocator<wchar_t>;
+#endif
+
+  // Undefine.
+#undef __allocator_base
+
+  // To implement Option 3 of DR 431.
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_swap
+    { static void _S_do_it(_Alloc&, _Alloc&) _GLIBCXX_NOEXCEPT { } };
+
+  template<typename _Alloc>
+    struct __alloc_swap<_Alloc, false>
+    {
+      static void
+      _S_do_it(_Alloc& __one, _Alloc& __two) _GLIBCXX_NOEXCEPT
+      {
+	// Precondition: swappable allocators.
+	if (__one != __two)
+	  swap(__one, __two);
+      }
+    };
+
+  // Optimize for stateless allocators.
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_neq
+    {
+      static bool
+      _S_do_it(const _Alloc&, const _Alloc&)
+      { return false; }
+    };
+
+  template<typename _Alloc>
+    struct __alloc_neq<_Alloc, false>
+    {
+      static bool
+      _S_do_it(const _Alloc& __one, const _Alloc& __two)
+      { return __one != __two; }
+    };
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, bool
+    = __or_<is_copy_constructible<typename _Tp::value_type>,
+            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
+    struct __shrink_to_fit_aux
+    { static bool _S_do_it(_Tp&) noexcept { return false; } };
+
+  template<typename _Tp>
+    struct __shrink_to_fit_aux<_Tp, true>
+    {
+      static bool
+      _S_do_it(_Tp& __c) noexcept
+      {
+	__try
+	  {
+	    _Tp(__make_move_if_noexcept_iterator(__c.begin()),
+		__make_move_if_noexcept_iterator(__c.end()),
+		__c.get_allocator()).swap(__c);
+	    return true;
+	  }
+	__catch(...)
+	  { return false; }
+      }
+    };
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/atomic_base.h b/gcc-4.9/libstdc++-v3/include/bits/atomic_base.h
new file mode 100644
index 0000000..7d2ba75
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/atomic_base.h
@@ -0,0 +1,892 @@
+// -*- C++ -*- header.
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/atomic_base.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{atomic}
+ */
+
+#ifndef _GLIBCXX_ATOMIC_BASE_H
+#define _GLIBCXX_ATOMIC_BASE_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <bits/atomic_lockfree_defines.h>
+
+#ifndef _GLIBCXX_ALWAYS_INLINE
+#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup atomics Atomics
+   *
+   * Components for performing atomic operations.
+   * @{
+   */
+
+  /// Enumeration for memory_order
+  typedef enum memory_order
+    {
+      memory_order_relaxed,
+      memory_order_consume,
+      memory_order_acquire,
+      memory_order_release,
+      memory_order_acq_rel,
+      memory_order_seq_cst
+    } memory_order;
+
+  enum __memory_order_modifier
+    {
+      __memory_order_mask          = 0x0ffff,
+      __memory_order_modifier_mask = 0xffff0000,
+      __memory_order_hle_acquire   = 0x10000,
+      __memory_order_hle_release   = 0x20000
+    };
+
+  constexpr memory_order
+  operator|(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(__m | int(__mod));
+  }
+
+  constexpr memory_order
+  operator&(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(__m & int(__mod));
+  }
+
+  // Drop release ordering as per [atomics.types.operations.req]/21
+  constexpr memory_order
+  __cmpexch_failure_order2(memory_order __m) noexcept
+  {
+    return __m == memory_order_acq_rel ? memory_order_acquire
+      : __m == memory_order_release ? memory_order_relaxed : __m;
+  }
+
+  constexpr memory_order
+  __cmpexch_failure_order(memory_order __m) noexcept
+  {
+    return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
+      | (__m & __memory_order_modifier_mask));
+  }
+
+  _GLIBCXX_ALWAYS_INLINE void
+  atomic_thread_fence(memory_order __m) noexcept
+  { __atomic_thread_fence(__m); }
+
+  _GLIBCXX_ALWAYS_INLINE void
+  atomic_signal_fence(memory_order __m) noexcept
+  { __atomic_signal_fence(__m); }
+
+  /// kill_dependency
+  template<typename _Tp>
+    inline _Tp
+    kill_dependency(_Tp __y) noexcept
+    {
+      _Tp __ret(__y);
+      return __ret;
+    }
+
+
+  // Base types for atomics.
+  template<typename _IntTp>
+    struct __atomic_base;
+
+  /// atomic_char
+  typedef __atomic_base<char>  	       		atomic_char;
+
+  /// atomic_schar
+  typedef __atomic_base<signed char>	     	atomic_schar;
+
+  /// atomic_uchar
+  typedef __atomic_base<unsigned char>		atomic_uchar;
+
+  /// atomic_short
+  typedef __atomic_base<short>			atomic_short;
+
+  /// atomic_ushort
+  typedef __atomic_base<unsigned short>	 	atomic_ushort;
+
+  /// atomic_int
+  typedef __atomic_base<int>  	       		atomic_int;
+
+  /// atomic_uint
+  typedef __atomic_base<unsigned int>	     	atomic_uint;
+
+  /// atomic_long
+  typedef __atomic_base<long>  	       		atomic_long;
+
+  /// atomic_ulong
+  typedef __atomic_base<unsigned long>		atomic_ulong;
+
+  /// atomic_llong
+  typedef __atomic_base<long long>  		atomic_llong;
+
+  /// atomic_ullong
+  typedef __atomic_base<unsigned long long> 	atomic_ullong;
+
+  /// atomic_wchar_t
+  typedef __atomic_base<wchar_t>  		atomic_wchar_t;
+
+  /// atomic_char16_t
+  typedef __atomic_base<char16_t>  		atomic_char16_t;
+
+  /// atomic_char32_t
+  typedef __atomic_base<char32_t>  		atomic_char32_t;
+
+  /// atomic_char32_t
+  typedef __atomic_base<char32_t>  		atomic_char32_t;
+
+
+  /// atomic_int_least8_t
+  typedef __atomic_base<int_least8_t>  		atomic_int_least8_t;
+
+  /// atomic_uint_least8_t
+  typedef __atomic_base<uint_least8_t>	       	atomic_uint_least8_t;
+
+  /// atomic_int_least16_t
+  typedef __atomic_base<int_least16_t>	       	atomic_int_least16_t;
+
+  /// atomic_uint_least16_t
+  typedef __atomic_base<uint_least16_t>	       	atomic_uint_least16_t;
+
+  /// atomic_int_least32_t
+  typedef __atomic_base<int_least32_t>	       	atomic_int_least32_t;
+
+  /// atomic_uint_least32_t
+  typedef __atomic_base<uint_least32_t>	       	atomic_uint_least32_t;
+
+  /// atomic_int_least64_t
+  typedef __atomic_base<int_least64_t>	       	atomic_int_least64_t;
+
+  /// atomic_uint_least64_t
+  typedef __atomic_base<uint_least64_t>	       	atomic_uint_least64_t;
+
+
+  /// atomic_int_fast8_t
+  typedef __atomic_base<int_fast8_t>  		atomic_int_fast8_t;
+
+  /// atomic_uint_fast8_t
+  typedef __atomic_base<uint_fast8_t>	      	atomic_uint_fast8_t;
+
+  /// atomic_int_fast16_t
+  typedef __atomic_base<int_fast16_t>	      	atomic_int_fast16_t;
+
+  /// atomic_uint_fast16_t
+  typedef __atomic_base<uint_fast16_t>	      	atomic_uint_fast16_t;
+
+  /// atomic_int_fast32_t
+  typedef __atomic_base<int_fast32_t>	      	atomic_int_fast32_t;
+
+  /// atomic_uint_fast32_t
+  typedef __atomic_base<uint_fast32_t>	      	atomic_uint_fast32_t;
+
+  /// atomic_int_fast64_t
+  typedef __atomic_base<int_fast64_t>	      	atomic_int_fast64_t;
+
+  /// atomic_uint_fast64_t
+  typedef __atomic_base<uint_fast64_t>	      	atomic_uint_fast64_t;
+
+
+  /// atomic_intptr_t
+  typedef __atomic_base<intptr_t>  	       	atomic_intptr_t;
+
+  /// atomic_uintptr_t
+  typedef __atomic_base<uintptr_t>  	       	atomic_uintptr_t;
+
+  /// atomic_size_t
+  typedef __atomic_base<size_t>	 	       	atomic_size_t;
+
+  /// atomic_intmax_t
+  typedef __atomic_base<intmax_t>  	       	atomic_intmax_t;
+
+  /// atomic_uintmax_t
+  typedef __atomic_base<uintmax_t>  	       	atomic_uintmax_t;
+
+  /// atomic_ptrdiff_t
+  typedef __atomic_base<ptrdiff_t>  	       	atomic_ptrdiff_t;
+
+
+#define ATOMIC_VAR_INIT(_VI) { _VI }
+
+  template<typename _Tp>
+    struct atomic;
+
+  template<typename _Tp>
+    struct atomic<_Tp*>;
+
+    /* The target's "set" value for test-and-set may not be exactly 1.  */
+#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
+    typedef bool __atomic_flag_data_type;
+#else
+    typedef unsigned char __atomic_flag_data_type;
+#endif
+
+  /**
+   *  @brief Base type for atomic_flag.
+   *
+   *  Base type is POD with data, allowing atomic_flag to derive from
+   *  it and meet the standard layout type requirement. In addition to
+   *  compatibility with a C interface, this allows different
+   *  implementations of atomic_flag to use the same atomic operation
+   *  functions, via a standard conversion to the __atomic_flag_base
+   *  argument.
+  */
+  _GLIBCXX_BEGIN_EXTERN_C
+
+  struct __atomic_flag_base
+  {
+    __atomic_flag_data_type _M_i;
+  };
+
+  _GLIBCXX_END_EXTERN_C
+
+#define ATOMIC_FLAG_INIT { 0 }
+
+  /// atomic_flag
+  struct atomic_flag : public __atomic_flag_base
+  {
+    atomic_flag() noexcept = default;
+    ~atomic_flag() noexcept = default;
+    atomic_flag(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) volatile = delete;
+
+    // Conversion to ATOMIC_FLAG_INIT.
+    constexpr atomic_flag(bool __i) noexcept
+      : __atomic_flag_base{ _S_init(__i) }
+    { }
+
+    _GLIBCXX_ALWAYS_INLINE bool
+    test_and_set(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      return __atomic_test_and_set (&_M_i, __m);
+    }
+
+    _GLIBCXX_ALWAYS_INLINE bool
+    test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      return __atomic_test_and_set (&_M_i, __m);
+    }
+
+    _GLIBCXX_ALWAYS_INLINE void
+    clear(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+      __glibcxx_assert(__b != memory_order_consume);
+      __glibcxx_assert(__b != memory_order_acquire);
+      __glibcxx_assert(__b != memory_order_acq_rel);
+
+      __atomic_clear (&_M_i, __m);
+    }
+
+    _GLIBCXX_ALWAYS_INLINE void
+    clear(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+      __glibcxx_assert(__b != memory_order_consume);
+      __glibcxx_assert(__b != memory_order_acquire);
+      __glibcxx_assert(__b != memory_order_acq_rel);
+
+      __atomic_clear (&_M_i, __m);
+    }
+
+  private:
+    static constexpr __atomic_flag_data_type
+    _S_init(bool __i)
+    { return __i ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0; }
+  };
+
+
+  /// Base class for atomic integrals.
+  //
+  // For each of the integral types, define atomic_[integral type] struct
+  //
+  // atomic_bool     bool
+  // atomic_char     char
+  // atomic_schar    signed char
+  // atomic_uchar    unsigned char
+  // atomic_short    short
+  // atomic_ushort   unsigned short
+  // atomic_int      int
+  // atomic_uint     unsigned int
+  // atomic_long     long
+  // atomic_ulong    unsigned long
+  // atomic_llong    long long
+  // atomic_ullong   unsigned long long
+  // atomic_char16_t char16_t
+  // atomic_char32_t char32_t
+  // atomic_wchar_t  wchar_t
+  //
+  // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or
+  // 8 bytes, since that is what GCC built-in functions for atomic
+  // memory access expect.
+  template<typename _ITp>
+    struct __atomic_base
+    {
+    private:
+      typedef _ITp 	__int_type;
+
+      __int_type 	_M_i;
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+      // Requires __int_type convertible to _M_i.
+      constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
+
+      operator __int_type() const noexcept
+      { return load(); }
+
+      operator __int_type() const volatile noexcept
+      { return load(); }
+
+      __int_type
+      operator=(__int_type __i) noexcept
+      {
+	store(__i);
+	return __i;
+      }
+
+      __int_type
+      operator=(__int_type __i) volatile noexcept
+      {
+	store(__i);
+	return __i;
+      }
+
+      __int_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator+=(__int_type __i) noexcept
+      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator+=(__int_type __i) volatile noexcept
+      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator-=(__int_type __i) noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator-=(__int_type __i) volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator&=(__int_type __i) noexcept
+      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator&=(__int_type __i) volatile noexcept
+      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator|=(__int_type __i) noexcept
+      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator|=(__int_type __i) volatile noexcept
+      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator^=(__int_type __i) noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator^=(__int_type __i) volatile noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      bool
+      is_lock_free() const noexcept
+      { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
+
+      bool
+      is_lock_free() const volatile noexcept
+      { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
+
+      _GLIBCXX_ALWAYS_INLINE void
+      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+	__glibcxx_assert(__b != memory_order_acquire);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+	__glibcxx_assert(__b != memory_order_consume);
+
+	__atomic_store_n(&_M_i, __i, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE void
+      store(__int_type __i,
+	    memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+	__glibcxx_assert(__b != memory_order_acquire);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+	__glibcxx_assert(__b != memory_order_consume);
+
+	__atomic_store_n(&_M_i, __i, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+       memory_order __b = __m & __memory_order_mask;
+	__glibcxx_assert(__b != memory_order_release);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+
+	return __atomic_load_n(&_M_i, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+	__glibcxx_assert(__b != memory_order_release);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+
+	return __atomic_load_n(&_M_i, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      exchange(__int_type __i,
+	       memory_order __m = memory_order_seq_cst) noexcept
+      {
+	return __atomic_exchange_n(&_M_i, __i, __m);
+      }
+
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      exchange(__int_type __i,
+	       memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+	return __atomic_exchange_n(&_M_i, __i, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+			    memory_order __m1, memory_order __m2) noexcept
+      {
+       memory_order __b2 = __m2 & __memory_order_mask;
+       memory_order __b1 = __m1 & __memory_order_mask;
+	__glibcxx_assert(__b2 != memory_order_release);
+	__glibcxx_assert(__b2 != memory_order_acq_rel);
+	__glibcxx_assert(__b2 <= __b1);
+
+	return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+			    memory_order __m1,
+			    memory_order __m2) volatile noexcept
+      {
+       memory_order __b2 = __m2 & __memory_order_mask;
+       memory_order __b1 = __m1 & __memory_order_mask;
+	__glibcxx_assert(__b2 != memory_order_release);
+	__glibcxx_assert(__b2 != memory_order_acq_rel);
+	__glibcxx_assert(__b2 <= __b1);
+
+	return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+			    memory_order __m = memory_order_seq_cst) noexcept
+      {
+	return compare_exchange_weak(__i1, __i2, __m,
+				     __cmpexch_failure_order(__m));
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+		   memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+	return compare_exchange_weak(__i1, __i2, __m,
+				     __cmpexch_failure_order(__m));
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+			      memory_order __m1, memory_order __m2) noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+	__glibcxx_assert(__b2 != memory_order_release);
+	__glibcxx_assert(__b2 != memory_order_acq_rel);
+	__glibcxx_assert(__b2 <= __b1);
+
+	return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+			      memory_order __m1,
+			      memory_order __m2) volatile noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+
+	__glibcxx_assert(__b2 != memory_order_release);
+	__glibcxx_assert(__b2 != memory_order_acq_rel);
+	__glibcxx_assert(__b2 <= __b1);
+
+	return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+			      memory_order __m = memory_order_seq_cst) noexcept
+      {
+	return compare_exchange_strong(__i1, __i2, __m,
+				       __cmpexch_failure_order(__m));
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+		 memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+	return compare_exchange_strong(__i1, __i2, __m,
+				       __cmpexch_failure_order(__m));
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_add(__int_type __i,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_add(__int_type __i,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_sub(__int_type __i,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_sub(__int_type __i,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_and(__int_type __i,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_and(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_and(__int_type __i,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_and(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_or(__int_type __i,
+	       memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_or(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_or(__int_type __i,
+	       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_or(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_xor(__int_type __i,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __int_type
+      fetch_xor(__int_type __i,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, __m); }
+    };
+
+
+  /// Partial specialization for pointer types.
+  template<typename _PTp>
+    struct __atomic_base<_PTp*>
+    {
+    private:
+      typedef _PTp* 	__pointer_type;
+
+      __pointer_type 	_M_p;
+
+      // Factored out to facilitate explicit specialization.
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) { return __d * sizeof(_PTp); }
+
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) volatile { return __d * sizeof(_PTp); }
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+      // Requires __pointer_type convertible to _M_p.
+      constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
+
+      operator __pointer_type() const noexcept
+      { return load(); }
+
+      operator __pointer_type() const volatile noexcept
+      { return load(); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      {
+	store(__p);
+	return __p;
+      }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      {
+	store(__p);
+	return __p;
+      }
+
+      __pointer_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+				  memory_order_seq_cst); }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+				  memory_order_seq_cst); }
+
+      __pointer_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+				  memory_order_seq_cst); }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+				  memory_order_seq_cst); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+				  memory_order_seq_cst); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+				  memory_order_seq_cst); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+				  memory_order_seq_cst); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+				  memory_order_seq_cst); }
+
+      bool
+      is_lock_free() const noexcept
+      { return __atomic_is_lock_free(_M_type_size(1), nullptr); }
+
+      bool
+      is_lock_free() const volatile noexcept
+      { return __atomic_is_lock_free(_M_type_size(1), nullptr); }
+
+      _GLIBCXX_ALWAYS_INLINE void
+      store(__pointer_type __p,
+	    memory_order __m = memory_order_seq_cst) noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+
+	__glibcxx_assert(__b != memory_order_acquire);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+	__glibcxx_assert(__b != memory_order_consume);
+
+	__atomic_store_n(&_M_p, __p, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE void
+      store(__pointer_type __p,
+	    memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+	__glibcxx_assert(__b != memory_order_acquire);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+	__glibcxx_assert(__b != memory_order_consume);
+
+	__atomic_store_n(&_M_p, __p, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+	__glibcxx_assert(__b != memory_order_release);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+
+	return __atomic_load_n(&_M_p, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+	__glibcxx_assert(__b != memory_order_release);
+	__glibcxx_assert(__b != memory_order_acq_rel);
+
+	return __atomic_load_n(&_M_p, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      exchange(__pointer_type __p,
+	       memory_order __m = memory_order_seq_cst) noexcept
+      {
+	return __atomic_exchange_n(&_M_p, __p, __m);
+      }
+
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      exchange(__pointer_type __p,
+	       memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+	return __atomic_exchange_n(&_M_p, __p, __m);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+			      memory_order __m1,
+			      memory_order __m2) noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+	__glibcxx_assert(__b2 != memory_order_release);
+	__glibcxx_assert(__b2 != memory_order_acq_rel);
+	__glibcxx_assert(__b2 <= __b1);
+
+	return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+			      memory_order __m1,
+			      memory_order __m2) volatile noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+
+	__glibcxx_assert(__b2 != memory_order_release);
+	__glibcxx_assert(__b2 != memory_order_acq_rel);
+	__glibcxx_assert(__b2 <= __b1);
+
+	return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
+      }
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      fetch_add(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      fetch_add(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      fetch_sub(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
+
+      _GLIBCXX_ALWAYS_INLINE __pointer_type
+      fetch_sub(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
+    };
+
+  // @} group atomics
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/basic_ios.h b/gcc-4.9/libstdc++-v3/include/bits/basic_ios.h
new file mode 100644
index 0000000..58bede4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/basic_ios.h
@@ -0,0 +1,477 @@
+// Iostreams base classes -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/basic_ios.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ios}
+ */
+
+#ifndef _BASIC_IOS_H
+#define _BASIC_IOS_H 1
+
+#pragma GCC system_header
+
+#include <bits/localefwd.h>
+#include <bits/locale_classes.h>
+#include <bits/locale_facets.h>
+#include <bits/streambuf_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Facet>
+    inline const _Facet&
+    __check_facet(const _Facet* __f)
+    {
+      if (!__f)
+	__throw_bad_cast();
+      return *__f;
+    }
+
+  /**
+   *  @brief Template class basic_ios, virtual base class for all
+   *  stream classes. 
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  Most of the member functions called dispatched on stream objects
+   *  (e.g., @c std::cout.foo(bar);) are consolidated in this class.
+  */
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+      //@{
+      /**
+       *  These are standard types.  They permit a standardized way of
+       *  referring to names of (or names dependent on) the template
+       *  parameters, which are specific to the implementation.
+      */
+      typedef _CharT                                 char_type;
+      typedef typename _Traits::int_type             int_type;
+      typedef typename _Traits::pos_type             pos_type;
+      typedef typename _Traits::off_type             off_type;
+      typedef _Traits                                traits_type;
+      //@}
+
+      //@{
+      /**
+       *  These are non-standard types.
+      */
+      typedef ctype<_CharT>                          __ctype_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+						     __num_put_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+						     __num_get_type;
+      //@}
+
+      // Data members:
+    protected:
+      basic_ostream<_CharT, _Traits>*                _M_tie;
+      mutable char_type                              _M_fill;
+      mutable bool                                   _M_fill_init;
+      basic_streambuf<_CharT, _Traits>*              _M_streambuf;
+
+      // Cached use_facet<ctype>, which is based on the current locale info.
+      const __ctype_type*                            _M_ctype;
+      // For ostream.
+      const __num_put_type*                          _M_num_put;
+      // For istream.
+      const __num_get_type*                          _M_num_get;
+
+    public:
+      //@{
+      /**
+       *  @brief  The quick-and-easy status check.
+       *
+       *  This allows you to write constructs such as
+       *  <code>if (!a_stream) ...</code> and <code>while (a_stream) ...</code>
+      */
+      operator void*() const
+      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
+
+      bool
+      operator!() const
+      { return this->fail(); }
+      //@}
+
+      /**
+       *  @brief  Returns the error state of the stream buffer.
+       *  @return  A bit pattern (well, isn't everything?)
+       *
+       *  See std::ios_base::iostate for the possible bit values.  Most
+       *  users will call one of the interpreting wrappers, e.g., good().
+      */
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+
+      /**
+       *  @brief  [Re]sets the error state.
+       *  @param  __state  The new state flag(s) to set.
+       *
+       *  See std::ios_base::iostate for the possible bit values.  Most
+       *  users will not need to pass an argument.
+      */
+      void
+      clear(iostate __state = goodbit);
+
+      /**
+       *  @brief  Sets additional flags in the error state.
+       *  @param  __state  The additional state flag(s) to set.
+       *
+       *  See std::ios_base::iostate for the possible bit values.
+      */
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+
+      // Flip the internal state on for the proper state bits, then re
+      // throws the propagated exception if bit also set in
+      // exceptions().
+      void
+      _M_setstate(iostate __state)
+      {
+	// 27.6.1.2.1 Common requirements.
+	// Turn this on without causing an ios::failure to be thrown.
+	_M_streambuf_state |= __state;
+	if (this->exceptions() & __state)
+	  __throw_exception_again;
+      }
+
+      /**
+       *  @brief  Fast error checking.
+       *  @return  True if no error flags are set.
+       *
+       *  A wrapper around rdstate.
+      */
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+
+      /**
+       *  @brief  Fast error checking.
+       *  @return  True if the eofbit is set.
+       *
+       *  Note that other iostate flags may also be set.
+      */
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+
+      /**
+       *  @brief  Fast error checking.
+       *  @return  True if either the badbit or the failbit is set.
+       *
+       *  Checking the badbit in fail() is historical practice.
+       *  Note that other iostate flags may also be set.
+      */
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+
+      /**
+       *  @brief  Fast error checking.
+       *  @return  True if the badbit is set.
+       *
+       *  Note that other iostate flags may also be set.
+      */
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+
+      /**
+       *  @brief  Throwing exceptions on errors.
+       *  @return  The current exceptions mask.
+       *
+       *  This changes nothing in the stream.  See the one-argument version
+       *  of exceptions(iostate) for the meaning of the return value.
+      */
+      iostate
+      exceptions() const
+      { return _M_exception; }
+
+      /**
+       *  @brief  Throwing exceptions on errors.
+       *  @param  __except  The new exceptions mask.
+       *
+       *  By default, error flags are set silently.  You can set an
+       *  exceptions mask for each stream; if a bit in the mask becomes set
+       *  in the error flags, then an exception of type
+       *  std::ios_base::failure is thrown.
+       *
+       *  If the error flag is already set when the exceptions mask is
+       *  added, the exception is immediately thrown.  Try running the
+       *  following under GCC 3.1 or later:
+       *  @code
+       *  #include <iostream>
+       *  #include <fstream>
+       *  #include <exception>
+       *
+       *  int main()
+       *  {
+       *      std::set_terminate (__gnu_cxx::__verbose_terminate_handler);
+       *
+       *      std::ifstream f ("/etc/motd");
+       *
+       *      std::cerr << "Setting badbit\n";
+       *      f.setstate (std::ios_base::badbit);
+       *
+       *      std::cerr << "Setting exception mask\n";
+       *      f.exceptions (std::ios_base::badbit);
+       *  }
+       *  @endcode
+      */
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+
+      // Constructor/destructor:
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  The parameter is passed by derived streams.
+      */
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+	_M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+
+      /**
+       *  @brief  Empty.
+       *
+       *  The destructor does nothing.  More specifically, it does not
+       *  destroy the streambuf held by rdbuf().
+      */
+      virtual
+      ~basic_ios() { }
+
+      // Members:
+      /**
+       *  @brief  Fetches the current @e tied stream.
+       *  @return  A pointer to the tied stream, or NULL if the stream is
+       *           not tied.
+       *
+       *  A stream may be @e tied (or synchronized) to a second output
+       *  stream.  When this stream performs any I/O, the tied stream is
+       *  first flushed.  For example, @c std::cin is tied to @c std::cout.
+      */
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+
+      /**
+       *  @brief  Ties this stream to an output stream.
+       *  @param  __tiestr  The output stream.
+       *  @return  The previously tied output stream, or NULL if the stream
+       *           was not tied.
+       *
+       *  This sets up a new tie; see tie() for more.
+      */
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+
+      /**
+       *  @brief  Accessing the underlying buffer.
+       *  @return  The current stream buffer.
+       *
+       *  This does not change the state of the stream.
+      */
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+
+      /**
+       *  @brief  Changing the underlying buffer.
+       *  @param  __sb  The new stream buffer.
+       *  @return  The previous stream buffer.
+       *
+       *  Associates a new buffer with the current stream, and clears the
+       *  error state.
+       *
+       *  Due to historical accidents which the LWG refuses to correct, the
+       *  I/O library suffers from a design error:  this function is hidden
+       *  in derived classes by overrides of the zero-argument @c rdbuf(),
+       *  which is non-virtual for hysterical raisins.  As a result, you
+       *  must use explicit qualifications to access this function via any
+       *  derived class.  For example:
+       *
+       *  @code
+       *  std::fstream     foo;         // or some other derived type
+       *  std::streambuf*  p = .....;
+       *
+       *  foo.ios::rdbuf(p);            // ios == basic_ios<char>
+       *  @endcode
+      */
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+
+      /**
+       *  @brief  Copies fields of __rhs into this.
+       *  @param  __rhs  The source values for the copies.
+       *  @return  Reference to this object.
+       *
+       *  All fields of __rhs are copied into this object except that rdbuf()
+       *  and rdstate() remain unchanged.  All values in the pword and iword
+       *  arrays are copied.  Before copying, each callback is invoked with
+       *  erase_event.  After copying, each (new) callback is invoked with
+       *  copyfmt_event.  The final step is to copy exceptions().
+      */
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+
+      /**
+       *  @brief  Retrieves the @a empty character.
+       *  @return  The current fill character.
+       *
+       *  It defaults to a space (' ') in the current locale.
+      */
+      char_type
+      fill() const
+      {
+	if (!_M_fill_init)
+	  {
+	    _M_fill = this->widen(' ');
+	    _M_fill_init = true;
+	  }
+	return _M_fill;
+      }
+
+      /**
+       *  @brief  Sets a new @a empty character.
+       *  @param  __ch  The new character.
+       *  @return  The previous fill character.
+       *
+       *  The fill character is used to fill out space when P+ characters
+       *  have been requested (e.g., via setw), Q characters are actually
+       *  used, and Q<P.  It defaults to a space (' ') in the current locale.
+      */
+      char_type
+      fill(char_type __ch)
+      {
+	char_type __old = this->fill();
+	_M_fill = __ch;
+	return __old;
+      }
+
+      // Locales:
+      /**
+       *  @brief  Moves to a new locale.
+       *  @param  __loc  The new locale.
+       *  @return  The previous locale.
+       *
+       *  Calls @c ios_base::imbue(loc), and if a stream buffer is associated
+       *  with this stream, calls that buffer's @c pubimbue(loc).
+       *
+       *  Additional l10n notes are at
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
+      */
+      locale
+      imbue(const locale& __loc);
+
+      /**
+       *  @brief  Squeezes characters.
+       *  @param  __c  The character to narrow.
+       *  @param  __dfault  The character to narrow.
+       *  @return  The narrowed character.
+       *
+       *  Maps a character of @c char_type to a character of @c char,
+       *  if possible.
+       *
+       *  Returns the result of
+       *  @code
+       *    std::use_facet<ctype<char_type> >(getloc()).narrow(c,dfault)
+       *  @endcode
+       *
+       *  Additional l10n notes are at
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
+      */
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+
+      /**
+       *  @brief  Widens characters.
+       *  @param  __c  The character to widen.
+       *  @return  The widened character.
+       *
+       *  Maps a character of @c char to a character of @c char_type.
+       *
+       *  Returns the result of
+       *  @code
+       *    std::use_facet<ctype<char_type> >(getloc()).widen(c)
+       *  @endcode
+       *
+       *  Additional l10n notes are at
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
+      */
+      char_type
+      widen(char __c) const
+      { return __check_facet(_M_ctype).widen(__c); }
+
+    protected:
+      // 27.4.5.1  basic_ios constructors
+      /**
+       *  @brief  Empty.
+       *
+       *  The default constructor does nothing and is not normally
+       *  accessible to users.
+      */
+      basic_ios()
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), 
+	_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { }
+
+      /**
+       *  @brief  All setup is performed here.
+       *
+       *  This is called from the public constructor.  It is not virtual and
+       *  cannot be redefined.
+      */
+      void
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+
+      void
+      _M_cache_locale(const locale& __loc);
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/basic_ios.tcc>
+
+#endif /* _BASIC_IOS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/basic_ios.tcc b/gcc-4.9/libstdc++-v3/include/bits/basic_ios.tcc
new file mode 100644
index 0000000..3cf4289
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/basic_ios.tcc
@@ -0,0 +1,188 @@
+// basic_ios member functions -*- C++ -*-
+
+// Copyright (C) 1999-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/basic_ios.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ios}
+ */
+
+#ifndef _BASIC_IOS_TCC
+#define _BASIC_IOS_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+	_M_streambuf_state = __state;
+      else
+	  _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+	__throw_ios_failure(__N("basic_ios::clear"));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 292. effects of a.copyfmt (a)
+      if (this != &__rhs)
+	{
+	  // Per 27.1.1, do not call imbue, yet must trash all caches
+	  // associated with imbue()
+
+	  // Alloc any new word array first, so if it fails we have "rollback".
+	  _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+	                     _M_local_word : new _Words[__rhs._M_word_size];
+
+	  // Bump refs before doing callbacks, for safety.
+	  _Callback_list* __cb = __rhs._M_callbacks;
+	  if (__cb)
+	    __cb->_M_add_reference();
+	  _M_call_callbacks(erase_event);
+	  if (_M_word != _M_local_word)
+	    {
+	      delete [] _M_word;
+	      _M_word = 0;
+	    }
+	  _M_dispose_callbacks();
+
+	  // NB: Don't want any added during above.
+	  _M_callbacks = __cb;
+	  for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+	    __words[__i] = __rhs._M_word[__i];
+	  _M_word = __words;
+	  _M_word_size = __rhs._M_word_size;
+
+	  this->flags(__rhs.flags());
+	  this->width(__rhs.width());
+	  this->precision(__rhs.precision());
+	  this->tie(__rhs.tie());
+	  this->fill(__rhs.fill());
+	  _M_ios_locale = __rhs.getloc();
+	  _M_cache_locale(_M_ios_locale);
+
+	  _M_call_callbacks(copyfmt_event);
+
+	  // The next is required to be the last assignment.
+	  this->exceptions(__rhs.exceptions());
+	}
+      return *this;
+    }
+
+  // Locales:
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+	this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      // NB: This may be called more than once on the same object.
+      ios_base::_M_init();
+
+      // Cache locale data and specific facets used by iostreams.
+      _M_cache_locale(_M_ios_locale);
+
+      // NB: The 27.4.4.1 Postconditions Table specifies requirements
+      // after basic_ios::init() has been called. As part of this,
+      // fill() must return widen(' ') any time after init() has been
+      // called, which needs an imbued ctype facet of char_type to
+      // return without throwing an exception. Unfortunately,
+      // ctype<char_type> is not necessarily a required facet, so
+      // streams with char_type != [char, wchar_t] will not have it by
+      // default. Because of this, the correct value for _M_fill is
+      // constructed on the first call of fill(). That way,
+      // unformatted input and output with non-required basic_ios
+      // instantiations is possible even without imbuing the expected
+      // ctype<char_type> facet.
+      _M_fill = _CharT();
+      _M_fill_init = false;
+
+      _M_tie = 0;
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      _M_streambuf_state = __sb ? goodbit : badbit;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
+    {
+      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
+	_M_ctype = &use_facet<__ctype_type>(__loc);
+      else
+	_M_ctype = 0;
+
+      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
+	_M_num_put = &use_facet<__num_put_type>(__loc);
+      else
+	_M_num_put = 0;
+
+      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
+	_M_num_get = &use_facet<__num_get_type>(__loc);
+      else
+	_M_num_get = 0;
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class basic_ios<char>;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_ios<wchar_t>;
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/basic_string.h b/gcc-4.9/libstdc++-v3/include/bits/basic_string.h
new file mode 100644
index 0000000..cd60376
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/basic_string.h
@@ -0,0 +1,3162 @@
+// Components for manipulating sequences of characters -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/basic_string.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{string}
+ */
+
+//
+// ISO C++ 14882: 21 Strings library
+//
+
+#ifndef _BASIC_STRING_H
+#define _BASIC_STRING_H 1
+
+#pragma GCC system_header
+
+#include <ext/atomicity.h>
+#include <debug/debug.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @class basic_string basic_string.h <string>
+   *  @brief  Managing sequences of characters and character-like objects.
+   *
+   *  @ingroup strings
+   *  @ingroup sequences
+   *
+   *  @tparam _CharT  Type of character
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and a
+   *  <a href="tables.html#67">sequence</a>.  Of the
+   *  <a href="tables.html#68">optional sequence requirements</a>, only
+   *  @c push_back, @c at, and @c %array access are supported.
+   *
+   *  @doctodo
+   *
+   *
+   *  Documentation?  What's that?
+   *  Nathan Myers <ncm@cantrip.org>.
+   *
+   *  A string looks like this:
+   *
+   *  @code
+   *                                        [_Rep]
+   *                                        _M_length
+   *   [basic_string<char_type>]            _M_capacity
+   *   _M_dataplus                          _M_refcount
+   *   _M_p ---------------->               unnamed array of char_type
+   *  @endcode
+   *
+   *  Where the _M_p points to the first character in the string, and
+   *  you cast it to a pointer-to-_Rep and subtract 1 to get a
+   *  pointer to the header.
+   *
+   *  This approach has the enormous advantage that a string object
+   *  requires only one allocation.  All the ugliness is confined
+   *  within a single %pair of inline functions, which each compile to
+   *  a single @a add instruction: _Rep::_M_data(), and
+   *  string::_M_rep(); and the allocation function which gets a
+   *  block of raw bytes and with room enough and constructs a _Rep
+   *  object at the front.
+   *
+   *  The reason you want _M_data pointing to the character %array and
+   *  not the _Rep is so that the debugger can see the string
+   *  contents. (Probably we should add a non-inline member to get
+   *  the _Rep for the debugger to use, so users can check the actual
+   *  string length.)
+   *
+   *  Note that the _Rep object is a POD so that you can have a
+   *  static <em>empty string</em> _Rep object already @a constructed before
+   *  static constructors have run.  The reference-count encoding is
+   *  chosen so that a 0 indicates one reference, so you never try to
+   *  destroy the empty-string _Rep object.
+   *
+   *  All but the last paragraph is considered pretty conventional
+   *  for a C++ string implementation.
+  */
+  // 21.3  Template class basic_string
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_string
+    {
+      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
+
+      // Types:
+    public:
+      typedef _Traits					    traits_type;
+      typedef typename _Traits::char_type		    value_type;
+      typedef _Alloc					    allocator_type;
+      typedef typename _CharT_alloc_type::size_type	    size_type;
+      typedef typename _CharT_alloc_type::difference_type   difference_type;
+      typedef typename _CharT_alloc_type::reference	    reference;
+      typedef typename _CharT_alloc_type::const_reference   const_reference;
+      typedef typename _CharT_alloc_type::pointer	    pointer;
+      typedef typename _CharT_alloc_type::const_pointer	    const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, basic_string>  iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
+                                                            const_iterator;
+      typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
+      typedef std::reverse_iterator<iterator>		    reverse_iterator;
+
+    private:
+      // _Rep: string representation
+      //   Invariants:
+      //   1. String really contains _M_length + 1 characters: due to 21.3.4
+      //      must be kept null-terminated.
+      //   2. _M_capacity >= _M_length
+      //      Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
+      //   3. _M_refcount has three states:
+      //      -1: leaked, one reference, no ref-copies allowed, non-const.
+      //       0: one reference, non-const.
+      //     n>0: n + 1 references, operations require a lock, const.
+      //   4. All fields==0 is an empty string, given the extra storage
+      //      beyond-the-end for a null terminator; thus, the shared
+      //      empty string representation needs no constructor.
+
+      struct _Rep_base
+      {
+	size_type		_M_length;
+	size_type		_M_capacity;
+	_Atomic_word		_M_refcount;
+      };
+
+      struct _Rep : _Rep_base
+      {
+	// Types:
+	typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
+
+	// (Public) Data members:
+
+	// The maximum number of individual char_type elements of an
+	// individual string is determined by _S_max_size. This is the
+	// value that will be returned by max_size().  (Whereas npos
+	// is the maximum number of bytes the allocator can allocate.)
+	// If one was to divvy up the theoretical largest size string,
+	// with a terminating character and m _CharT elements, it'd
+	// look like this:
+	// npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
+	// Solving for m:
+	// m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
+	// In addition, this implementation quarters this amount.
+	static const size_type	_S_max_size;
+	static const _CharT	_S_terminal;
+
+	// The following storage is init'd to 0 by the linker, resulting
+        // (carefully) in an empty string with one reference.
+        static size_type _S_empty_rep_storage[];
+
+        static _Rep&
+        _S_empty_rep() _GLIBCXX_NOEXCEPT
+        { 
+	  // NB: Mild hack to avoid strict-aliasing warnings.  Note that
+	  // _S_empty_rep_storage is never modified and the punning should
+	  // be reasonably safe in this case.
+	  void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
+	  return *reinterpret_cast<_Rep*>(__p);
+	}
+
+        bool
+	_M_is_leaked() const _GLIBCXX_NOEXCEPT
+        { return this->_M_refcount < 0; }
+
+        bool
+	_M_is_shared() const _GLIBCXX_NOEXCEPT
+        { return this->_M_refcount > 0; }
+
+        void
+	_M_set_leaked() _GLIBCXX_NOEXCEPT
+        { this->_M_refcount = -1; }
+
+        void
+	_M_set_sharable() _GLIBCXX_NOEXCEPT
+        { this->_M_refcount = 0; }
+
+	void
+	_M_set_length_and_sharable(size_type __n) _GLIBCXX_NOEXCEPT
+	{
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+	  if (__builtin_expect(this != &_S_empty_rep(), false))
+#endif
+	    {
+	      this->_M_set_sharable();  // One reference.
+	      this->_M_length = __n;
+	      traits_type::assign(this->_M_refdata()[__n], _S_terminal);
+	      // grrr. (per 21.3.4)
+	      // You cannot leave those LWG people alone for a second.
+	    }
+	}
+
+	_CharT*
+	_M_refdata() throw()
+	{ return reinterpret_cast<_CharT*>(this + 1); }
+
+	_CharT*
+	_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
+	{
+	  return (!_M_is_leaked() && __alloc1 == __alloc2)
+	          ? _M_refcopy() : _M_clone(__alloc1);
+	}
+
+	// Create & Destroy
+	static _Rep*
+	_S_create(size_type, size_type, const _Alloc&);
+
+	void
+	_M_dispose(const _Alloc& __a) _GLIBCXX_NOEXCEPT
+	{
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+	  if (__builtin_expect(this != &_S_empty_rep(), false))
+#endif
+	    {
+	      // Be race-detector-friendly.  For more info see bits/c++config.
+	      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
+	      if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
+							 -1) <= 0)
+		{
+		  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
+		  _M_destroy(__a);
+		}
+	    }
+	}  // XXX MT
+
+	void
+	_M_destroy(const _Alloc&) throw();
+
+	_CharT*
+	_M_refcopy() throw()
+	{
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+	  if (__builtin_expect(this != &_S_empty_rep(), false))
+#endif
+            __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
+	  return _M_refdata();
+	}  // XXX MT
+
+	_CharT*
+	_M_clone(const _Alloc&, size_type __res = 0);
+      };
+
+      // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
+      struct _Alloc_hider : _Alloc
+      {
+	_Alloc_hider(_CharT* __dat, const _Alloc& __a) _GLIBCXX_NOEXCEPT
+	: _Alloc(__a), _M_p(__dat) { }
+
+	_CharT* _M_p; // The actual data.
+      };
+
+    public:
+      // Data Members (public):
+      // NB: This is an unsigned type, and thus represents the maximum
+      // size that the allocator can hold.
+      ///  Value returned by various member functions when they fail.
+      static const size_type	npos = static_cast<size_type>(-1);
+
+    private:
+      // Data Members (private):
+      mutable _Alloc_hider	_M_dataplus;
+
+      _CharT*
+      _M_data() const _GLIBCXX_NOEXCEPT
+      { return  _M_dataplus._M_p; }
+
+      _CharT*
+      _M_data(_CharT* __p) _GLIBCXX_NOEXCEPT
+      { return (_M_dataplus._M_p = __p); }
+
+      _Rep*
+      _M_rep() const _GLIBCXX_NOEXCEPT
+      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
+
+      // For the internal use we have functions similar to `begin'/`end'
+      // but they do not call _M_leak.
+      iterator
+      _M_ibegin() const _GLIBCXX_NOEXCEPT
+      { return iterator(_M_data()); }
+
+      iterator
+      _M_iend() const _GLIBCXX_NOEXCEPT
+      { return iterator(_M_data() + this->size()); }
+
+      void
+      _M_leak()    // for use in begin() & non-const op[]
+      {
+	if (!_M_rep()->_M_is_leaked())
+	  _M_leak_hard();
+      }
+
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+	if (__pos > this->size())
+	  __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
+				       "this->size() (which is %zu)"),
+				   __s, __pos, this->size());
+	return __pos;
+      }
+
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+	if (this->max_size() - (this->size() - __n1) < __n2)
+	  __throw_length_error(__N(__s));
+      }
+
+      // NB: _M_limit doesn't check for a bad __pos value.
+      size_type
+      _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
+      {
+	const bool __testoff =  __off < this->size() - __pos;
+	return __testoff ? __off : this->size() - __pos;
+      }
+
+      // True if _Rep and source do not overlap.
+      bool
+      _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
+      {
+	return (less<const _CharT*>()(__s, _M_data())
+		|| less<const _CharT*>()(_M_data() + this->size(), __s));
+      }
+
+      // When __n = 1 way faster than the general multichar
+      // traits_type::copy/move/assign.
+      static void
+      _M_copy(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
+      {
+	if (__n == 1)
+	  traits_type::assign(*__d, *__s);
+	else
+	  traits_type::copy(__d, __s, __n);
+      }
+
+      static void
+      _M_move(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
+      {
+	if (__n == 1)
+	  traits_type::assign(*__d, *__s);
+	else
+	  traits_type::move(__d, __s, __n);	  
+      }
+
+      static void
+      _M_assign(_CharT* __d, size_type __n, _CharT __c) _GLIBCXX_NOEXCEPT
+      {
+	if (__n == 1)
+	  traits_type::assign(*__d, __c);
+	else
+	  traits_type::assign(__d, __n, __c);	  
+      }
+
+      // _S_copy_chars is a separate template to permit specialization
+      // to optimize for the common case of pointers as iterators.
+      template<class _Iterator>
+        static void
+        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+	_GLIBCXX_NOEXCEPT
+        {
+	  for (; __k1 != __k2; ++__k1, ++__p)
+	    traits_type::assign(*__p, *__k1); // These types are off.
+	}
+
+      static void
+      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+      _GLIBCXX_NOEXCEPT
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
+      { _M_copy(__p, __k1, __k2 - __k1); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      _GLIBCXX_NOEXCEPT
+      { _M_copy(__p, __k1, __k2 - __k1); }
+
+      static int
+      _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
+      {
+	const difference_type __d = difference_type(__n1 - __n2);
+
+	if (__d > __gnu_cxx::__numeric_traits<int>::__max)
+	  return __gnu_cxx::__numeric_traits<int>::__max;
+	else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
+	  return __gnu_cxx::__numeric_traits<int>::__min;
+	else
+	  return int(__d);
+      }
+
+      void
+      _M_mutate(size_type __pos, size_type __len1, size_type __len2);
+
+      void
+      _M_leak_hard();
+
+      static _Rep&
+      _S_empty_rep() _GLIBCXX_NOEXCEPT
+      { return _Rep::_S_empty_rep(); }
+
+    public:
+      // Construct/copy/destroy:
+      // NB: We overload ctors in some cases instead of using default
+      // arguments, per 17.4.4.4 para. 2 item 2.
+
+      /**
+       *  @brief  Default constructor creates an empty string.
+       */
+      basic_string()
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+      : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
+#else
+      : _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc()){ }
+#endif
+
+      /**
+       *  @brief  Construct an empty string using allocator @a a.
+       */
+      explicit
+      basic_string(const _Alloc& __a);
+
+      // NB: per LWG issue 42, semantics different from IS:
+      /**
+       *  @brief  Construct string with copy of value of @a str.
+       *  @param  __str  Source string.
+       */
+      basic_string(const basic_string& __str);
+      /**
+       *  @brief  Construct string as copy of a substring.
+       *  @param  __str  Source string.
+       *  @param  __pos  Index of first character to copy from.
+       *  @param  __n  Number of characters to copy (default remainder).
+       */
+      basic_string(const basic_string& __str, size_type __pos,
+		   size_type __n = npos);
+      /**
+       *  @brief  Construct string as copy of a substring.
+       *  @param  __str  Source string.
+       *  @param  __pos  Index of first character to copy from.
+       *  @param  __n  Number of characters to copy.
+       *  @param  __a  Allocator to use.
+       */
+      basic_string(const basic_string& __str, size_type __pos,
+		   size_type __n, const _Alloc& __a);
+
+      /**
+       *  @brief  Construct string initialized by a character %array.
+       *  @param  __s  Source character %array.
+       *  @param  __n  Number of characters to copy.
+       *  @param  __a  Allocator to use (default is default allocator).
+       *
+       *  NB: @a __s must have at least @a __n characters, &apos;\\0&apos;
+       *  has no special meaning.
+       */
+      basic_string(const _CharT* __s, size_type __n,
+		   const _Alloc& __a = _Alloc());
+      /**
+       *  @brief  Construct string as copy of a C string.
+       *  @param  __s  Source C string.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
+      /**
+       *  @brief  Construct string as multiple characters.
+       *  @param  __n  Number of characters.
+       *  @param  __c  Character to use.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Move construct string.
+       *  @param  __str  Source string.
+       *
+       *  The newly-created string contains the exact contents of @a __str.
+       *  @a __str is a valid, but unspecified string.
+       **/
+      basic_string(basic_string&& __str)
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+      noexcept // FIXME C++11: should always be noexcept.
+#endif
+      : _M_dataplus(__str._M_dataplus)
+      {
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+	__str._M_data(_S_empty_rep()._M_refdata());
+#else
+	__str._M_data(_S_construct(size_type(), _CharT(), get_allocator()));
+#endif
+      }
+
+      /**
+       *  @brief  Construct string from an initializer %list.
+       *  @param  __l  std::initializer_list of characters.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
+#endif // C++11
+
+      /**
+       *  @brief  Construct string as copy of a range.
+       *  @param  __beg  Start of range.
+       *  @param  __end  End of range.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+      template<class _InputIterator>
+        basic_string(_InputIterator __beg, _InputIterator __end,
+		     const _Alloc& __a = _Alloc());
+
+      /**
+       *  @brief  Destroy the string instance.
+       */
+      ~basic_string() _GLIBCXX_NOEXCEPT
+      { _M_rep()->_M_dispose(this->get_allocator()); }
+
+      /**
+       *  @brief  Assign the value of @a str to this string.
+       *  @param  __str  Source string.
+       */
+      basic_string&
+      operator=(const basic_string& __str) 
+      { return this->assign(__str); }
+
+      /**
+       *  @brief  Copy contents of @a s into this string.
+       *  @param  __s  Source null-terminated string.
+       */
+      basic_string&
+      operator=(const _CharT* __s) 
+      { return this->assign(__s); }
+
+      /**
+       *  @brief  Set value to string of length 1.
+       *  @param  __c  Source character.
+       *
+       *  Assigning to a character makes this string length 1 and
+       *  (*this)[0] == @a c.
+       */
+      basic_string&
+      operator=(_CharT __c) 
+      { 
+	this->assign(1, __c); 
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Move assign the value of @a str to this string.
+       *  @param  __str  Source string.
+       *
+       *  The contents of @a str are moved into this string (without copying).
+       *  @a str is a valid, but unspecified string.
+       **/
+      // PR 58265, this should be noexcept.
+      basic_string&
+      operator=(basic_string&& __str)
+      {
+	// NB: DR 1204.
+	this->swap(__str);
+	return *this;
+      }
+
+      /**
+       *  @brief  Set value to string constructed from initializer %list.
+       *  @param  __l  std::initializer_list.
+       */
+      basic_string&
+      operator=(initializer_list<_CharT> __l)
+      {
+	this->assign(__l.begin(), __l.size());
+	return *this;
+      }
+#endif // C++11
+
+      // Iterators:
+      /**
+       *  Returns a read/write iterator that points to the first character in
+       *  the %string.  Unshares the string.
+       */
+      iterator
+      begin() // FIXME C++11: should be noexcept.
+      {
+	_M_leak();
+	return iterator(_M_data());
+      }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  character in the %string.
+       */
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_M_data()); }
+
+      /**
+       *  Returns a read/write iterator that points one past the last
+       *  character in the %string.  Unshares the string.
+       */
+      iterator
+      end() // FIXME C++11: should be noexcept.
+      {
+	_M_leak();
+	return iterator(_M_data() + this->size());
+      }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the
+       *  last character in the %string.
+       */
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_M_data() + this->size()); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to the last
+       *  character in the %string.  Iteration is done in reverse element
+       *  order.  Unshares the string.
+       */
+      reverse_iterator
+      rbegin() // FIXME C++11: should be noexcept.
+      { return reverse_iterator(this->end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last character in the %string.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(this->end()); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to one before the
+       *  first character in the %string.  Iteration is done in reverse
+       *  element order.  Unshares the string.
+       */
+      reverse_iterator
+      rend() // FIXME C++11: should be noexcept.
+      { return reverse_iterator(this->begin()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first character in the %string.  Iteration
+       *  is done in reverse element order.
+       */
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(this->begin()); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  character in the %string.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_data()); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the
+       *  last character in the %string.
+       */
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_data() + this->size()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last character in the %string.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first character in the %string.  Iteration
+       *  is done in reverse element order.
+       */
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+#endif
+
+    public:
+      // Capacity:
+      ///  Returns the number of characters in the string, not including any
+      ///  null-termination.
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return _M_rep()->_M_length; }
+
+      ///  Returns the number of characters in the string, not including any
+      ///  null-termination.
+      size_type
+      length() const _GLIBCXX_NOEXCEPT
+      { return _M_rep()->_M_length; }
+
+      ///  Returns the size() of the largest possible %string.
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _Rep::_S_max_size; }
+
+      /**
+       *  @brief  Resizes the %string to the specified number of characters.
+       *  @param  __n  Number of characters the %string should contain.
+       *  @param  __c  Character to fill any new elements.
+       *
+       *  This function will %resize the %string to the specified
+       *  number of characters.  If the number is smaller than the
+       *  %string's current size the %string is truncated, otherwise
+       *  the %string is extended and new elements are %set to @a __c.
+       */
+      void
+      resize(size_type __n, _CharT __c);
+
+      /**
+       *  @brief  Resizes the %string to the specified number of characters.
+       *  @param  __n  Number of characters the %string should contain.
+       *
+       *  This function will resize the %string to the specified length.  If
+       *  the new size is smaller than the %string's current size the %string
+       *  is truncated, otherwise the %string is extended and new characters
+       *  are default-constructed.  For basic types such as char, this means
+       *  setting them to 0.
+       */
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+
+#if __cplusplus >= 201103L
+      ///  A non-binding request to reduce capacity() to size().
+      void
+      shrink_to_fit() _GLIBCXX_NOEXCEPT
+      {
+	if (capacity() > size())
+	  {
+	    __try
+	      { reserve(0); }
+	    __catch(...)
+	      { }
+	  }
+      }
+#endif
+
+      /**
+       *  Returns the total number of characters that the %string can hold
+       *  before needing to allocate more memory.
+       */
+      size_type
+      capacity() const _GLIBCXX_NOEXCEPT
+      { return _M_rep()->_M_capacity; }
+
+      /**
+       *  @brief  Attempt to preallocate enough memory for specified number of
+       *          characters.
+       *  @param  __res_arg  Number of characters required.
+       *  @throw  std::length_error  If @a __res_arg exceeds @c max_size().
+       *
+       *  This function attempts to reserve enough memory for the
+       *  %string to hold the specified number of characters.  If the
+       *  number requested is more than max_size(), length_error is
+       *  thrown.
+       *
+       *  The advantage of this function is that if optimal code is a
+       *  necessity and the user can determine the string length that will be
+       *  required, the user can reserve the memory in %advance, and thus
+       *  prevent a possible reallocation of memory and copying of %string
+       *  data.
+       */
+      void
+      reserve(size_type __res_arg = 0);
+
+      /**
+       *  Erases the string, making it empty.
+       */
+      // PR 56166: this should not throw.
+      void
+      clear()
+      { _M_mutate(0, this->size(), 0); }
+
+      /**
+       *  Returns true if the %string is empty.  Equivalent to 
+       *  <code>*this == ""</code>.
+       */
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return this->size() == 0; }
+
+      // Element access:
+      /**
+       *  @brief  Subscript access to the data contained in the %string.
+       *  @param  __pos  The index of the character to access.
+       *  @return  Read-only (constant) reference to the character.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)
+       */
+      const_reference
+      operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_ASSERT(__pos <= size());
+	return _M_data()[__pos];
+      }
+
+      /**
+       *  @brief  Subscript access to the data contained in the %string.
+       *  @param  __pos  The index of the character to access.
+       *  @return  Read/write reference to the character.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)  Unshares the string.
+       */
+      reference
+      operator[](size_type __pos)
+      {
+        // Allow pos == size() both in C++98 mode, as v3 extension,
+	// and in C++11 mode.
+	_GLIBCXX_DEBUG_ASSERT(__pos <= size());
+        // In pedantic mode be strict in C++98 mode.
+	_GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
+	_M_leak();
+	return _M_data()[__pos];
+      }
+
+      /**
+       *  @brief  Provides access to the data contained in the %string.
+       *  @param __n The index of the character to access.
+       *  @return  Read-only (const) reference to the character.
+       *  @throw  std::out_of_range  If @a n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter is
+       *  first checked that it is in the range of the string.  The function
+       *  throws out_of_range if the check fails.
+       */
+      const_reference
+      at(size_type __n) const
+      {
+	if (__n >= this->size())
+	  __throw_out_of_range_fmt(__N("basic_string::at: __n "
+				       "(which is %zu) >= this->size() "
+				       "(which is %zu)"),
+				   __n, this->size());
+	return _M_data()[__n];
+      }
+
+      /**
+       *  @brief  Provides access to the data contained in the %string.
+       *  @param __n The index of the character to access.
+       *  @return  Read/write reference to the character.
+       *  @throw  std::out_of_range  If @a n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter is
+       *  first checked that it is in the range of the string.  The function
+       *  throws out_of_range if the check fails.  Success results in
+       *  unsharing the string.
+       */
+      reference
+      at(size_type __n)
+      {
+	if (__n >= size())
+	  __throw_out_of_range_fmt(__N("basic_string::at: __n "
+				       "(which is %zu) >= this->size() "
+				       "(which is %zu)"),
+				   __n, this->size());
+	_M_leak();
+	return _M_data()[__n];
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %string.
+       */
+      reference
+      front()
+      { return operator[](0); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %string.
+       */
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      { return operator[](0); }
+
+      /**
+       *  Returns a read/write reference to the data at the last
+       *  element of the %string.
+       */
+      reference
+      back()
+      { return operator[](this->size() - 1); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the
+       *  last element of the %string.
+       */
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      { return operator[](this->size() - 1); }
+#endif
+
+      // Modifiers:
+      /**
+       *  @brief  Append a string to this string.
+       *  @param __str  The string to append.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      operator+=(const basic_string& __str)
+      { return this->append(__str); }
+
+      /**
+       *  @brief  Append a C string.
+       *  @param __s  The C string to append.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+
+      /**
+       *  @brief  Append a character.
+       *  @param __c  The character to append.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      operator+=(_CharT __c)
+      { 
+	this->push_back(__c);
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Append an initializer_list of characters.
+       *  @param __l  The initializer_list of characters to be appended.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      operator+=(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+#endif // C++11
+
+      /**
+       *  @brief  Append a string to this string.
+       *  @param __str  The string to append.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      append(const basic_string& __str);
+
+      /**
+       *  @brief  Append a substring.
+       *  @param __str  The string to append.
+       *  @param __pos  Index of the first character of str to append.
+       *  @param __n  The number of characters to append.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range if @a __pos is not a valid index.
+       *
+       *  This function appends @a __n characters from @a __str
+       *  starting at @a __pos to this string.  If @a __n is is larger
+       *  than the number of available characters in @a __str, the
+       *  remainder of @a __str is appended.
+       */
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n);
+
+      /**
+       *  @brief  Append a C substring.
+       *  @param __s  The C string to append.
+       *  @param __n  The number of characters to append.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      append(const _CharT* __s, size_type __n);
+
+      /**
+       *  @brief  Append a C string.
+       *  @param __s  The C string to append.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      append(const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return this->append(__s, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Append multiple characters.
+       *  @param __n  The number of characters to append.
+       *  @param __c  The character to use.
+       *  @return  Reference to this string.
+       *
+       *  Appends __n copies of __c to this string.
+       */
+      basic_string&
+      append(size_type __n, _CharT __c);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Append an initializer_list of characters.
+       *  @param __l  The initializer_list of characters to append.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      append(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+#endif // C++11
+
+      /**
+       *  @brief  Append a range of characters.
+       *  @param __first  Iterator referencing the first character to append.
+       *  @param __last  Iterator marking the end of the range.
+       *  @return  Reference to this string.
+       *
+       *  Appends characters in the range [__first,__last) to this string.
+       */
+      template<class _InputIterator>
+        basic_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_iend(), _M_iend(), __first, __last); }
+
+      /**
+       *  @brief  Append a single character.
+       *  @param __c  Character to append.
+       */
+      void
+      push_back(_CharT __c)
+      { 
+	const size_type __len = 1 + this->size();
+	if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	  this->reserve(__len);
+	traits_type::assign(_M_data()[this->size()], __c);
+	_M_rep()->_M_set_length_and_sharable(__len);
+      }
+
+      /**
+       *  @brief  Set value to contents of another string.
+       *  @param  __str  Source string to use.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      assign(const basic_string& __str);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Set value to contents of another string.
+       *  @param  __str  Source string to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets this string to the exact contents of @a __str.
+       *  @a __str is a valid, but unspecified string.
+       */
+      // PR 58265, this should be noexcept.
+      basic_string&
+      assign(basic_string&& __str)
+      {
+	this->swap(__str);
+	return *this;
+      }
+#endif // C++11
+
+      /**
+       *  @brief  Set value to a substring of a string.
+       *  @param __str  The string to use.
+       *  @param __pos  Index of the first character of str.
+       *  @param __n  Number of characters to use.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range if @a pos is not a valid index.
+       *
+       *  This function sets this string to the substring of @a __str
+       *  consisting of @a __n characters at @a __pos.  If @a __n is
+       *  is larger than the number of available characters in @a
+       *  __str, the remainder of @a __str is used.
+       */
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n)
+      { return this->assign(__str._M_data()
+			    + __str._M_check(__pos, "basic_string::assign"),
+			    __str._M_limit(__pos, __n)); }
+
+      /**
+       *  @brief  Set value to a C substring.
+       *  @param __s  The C string to use.
+       *  @param __n  Number of characters to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets the value of this string to the first @a __n
+       *  characters of @a __s.  If @a __n is is larger than the number of
+       *  available characters in @a __s, the remainder of @a __s is used.
+       */
+      basic_string&
+      assign(const _CharT* __s, size_type __n);
+
+      /**
+       *  @brief  Set value to contents of a C string.
+       *  @param __s  The C string to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets the value of this string to the value of @a __s.
+       *  The data is copied, so there is no dependence on @a __s once the
+       *  function returns.
+       */
+      basic_string&
+      assign(const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return this->assign(__s, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Set value to multiple characters.
+       *  @param __n  Length of the resulting string.
+       *  @param __c  The character to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets the value of this string to @a __n copies of
+       *  character @a __c.
+       */
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+
+      /**
+       *  @brief  Set value to a range of characters.
+       *  @param __first  Iterator referencing the first character to append.
+       *  @param __last  Iterator marking the end of the range.
+       *  @return  Reference to this string.
+       *
+       *  Sets value of string to characters in the range [__first,__last).
+      */
+      template<class _InputIterator>
+        basic_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Set value to an initializer_list of characters.
+       *  @param __l  The initializer_list of characters to assign.
+       *  @return  Reference to this string.
+       */
+      basic_string&
+      assign(initializer_list<_CharT> __l)
+      { return this->assign(__l.begin(), __l.size()); }
+#endif // C++11
+
+      /**
+       *  @brief  Insert multiple characters.
+       *  @param __p  Iterator referencing location in string to insert at.
+       *  @param __n  Number of characters to insert
+       *  @param __c  The character to insert.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts @a __n copies of character @a __c starting at the
+       *  position referenced by iterator @a __p.  If adding
+       *  characters causes the length to exceed max_size(),
+       *  length_error is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      void
+      insert(iterator __p, size_type __n, _CharT __c)
+      {	this->replace(__p, __p, __n, __c);  }
+
+      /**
+       *  @brief  Insert a range of characters.
+       *  @param __p  Iterator referencing location in string to insert at.
+       *  @param __beg  Start of range.
+       *  @param __end  End of range.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts characters in range [__beg,__end).  If adding
+       *  characters causes the length to exceed max_size(),
+       *  length_error is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      template<class _InputIterator>
+        void
+        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
+        { this->replace(__p, __p, __beg, __end); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert an initializer_list of characters.
+       *  @param __p  Iterator referencing location in string to insert at.
+       *  @param __l  The initializer_list of characters to insert.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       */
+      void
+      insert(iterator __p, initializer_list<_CharT> __l)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
+	this->insert(__p - _M_ibegin(), __l.begin(), __l.size());
+      }
+#endif // C++11
+
+      /**
+       *  @brief  Insert value of a string.
+       *  @param __pos1  Iterator referencing location in string to insert at.
+       *  @param __str  The string to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts value of @a __str starting at @a __pos1.  If adding
+       *  characters causes the length to exceed max_size(),
+       *  length_error is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str)
+      { return this->insert(__pos1, __str, size_type(0), __str.size()); }
+
+      /**
+       *  @brief  Insert a substring.
+       *  @param __pos1  Iterator referencing location in string to insert at.
+       *  @param __str  The string to insert.
+       *  @param __pos2  Start of characters in str to insert.
+       *  @param __n  Number of characters to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a pos1 > size() or
+       *  @a __pos2 > @a str.size().
+       *
+       *  Starting at @a pos1, insert @a __n character of @a __str
+       *  beginning with @a __pos2.  If adding characters causes the
+       *  length to exceed max_size(), length_error is thrown.  If @a
+       *  __pos1 is beyond the end of this string or @a __pos2 is
+       *  beyond the end of @a __str, out_of_range is thrown.  The
+       *  value of the string doesn't change if an error is thrown.
+      */
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+	     size_type __pos2, size_type __n)
+      { return this->insert(__pos1, __str._M_data()
+			    + __str._M_check(__pos2, "basic_string::insert"),
+			    __str._M_limit(__pos2, __n)); }
+
+      /**
+       *  @brief  Insert a C substring.
+       *  @param __pos  Iterator referencing location in string to insert at.
+       *  @param __s  The C string to insert.
+       *  @param __n  The number of characters to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a __pos is beyond the end of this
+       *  string.
+       *
+       *  Inserts the first @a __n characters of @a __s starting at @a
+       *  __pos.  If adding characters causes the length to exceed
+       *  max_size(), length_error is thrown.  If @a __pos is beyond
+       *  end(), out_of_range is thrown.  The value of the string
+       *  doesn't change if an error is thrown.
+      */
+      basic_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n);
+
+      /**
+       *  @brief  Insert a C string.
+       *  @param __pos  Iterator referencing location in string to insert at.
+       *  @param __s  The C string to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a pos is beyond the end of this
+       *  string.
+       *
+       *  Inserts the first @a n characters of @a __s starting at @a __pos.  If
+       *  adding characters causes the length to exceed max_size(),
+       *  length_error is thrown.  If @a __pos is beyond end(), out_of_range is
+       *  thrown.  The value of the string doesn't change if an error is
+       *  thrown.
+      */
+      basic_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return this->insert(__pos, __s, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Insert multiple characters.
+       *  @param __pos  Index in string to insert at.
+       *  @param __n  Number of characters to insert
+       *  @param __c  The character to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a __pos is beyond the end of this
+       *  string.
+       *
+       *  Inserts @a __n copies of character @a __c starting at index
+       *  @a __pos.  If adding characters causes the length to exceed
+       *  max_size(), length_error is thrown.  If @a __pos > length(),
+       *  out_of_range is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+			      size_type(0), __n, __c); }
+
+      /**
+       *  @brief  Insert one character.
+       *  @param __p  Iterator referencing position in string to insert at.
+       *  @param __c  The character to insert.
+       *  @return  Iterator referencing newly inserted char.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts character @a __c at position referenced by @a __p.
+       *  If adding character causes the length to exceed max_size(),
+       *  length_error is thrown.  If @a __p is beyond end of string,
+       *  out_of_range is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      iterator
+      insert(iterator __p, _CharT __c)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
+	const size_type __pos = __p - _M_ibegin();
+	_M_replace_aux(__pos, size_type(0), size_type(1), __c);
+	_M_rep()->_M_set_leaked();
+	return iterator(_M_data() + __pos);
+      }
+
+      /**
+       *  @brief  Remove characters.
+       *  @param __pos  Index of first character to remove (default 0).
+       *  @param __n  Number of characters to remove (default remainder).
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a pos is beyond the end of this
+       *  string.
+       *
+       *  Removes @a __n characters from this string starting at @a
+       *  __pos.  The length of the string is reduced by @a __n.  If
+       *  there are < @a __n characters to remove, the remainder of
+       *  the string is truncated.  If @a __p is beyond end of string,
+       *  out_of_range is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      { 
+	_M_mutate(_M_check(__pos, "basic_string::erase"),
+		  _M_limit(__pos, __n), size_type(0));
+	return *this;
+      }
+
+      /**
+       *  @brief  Remove one character.
+       *  @param __position  Iterator referencing the character to remove.
+       *  @return  iterator referencing same location after removal.
+       *
+       *  Removes the character at @a __position from this string. The value
+       *  of the string doesn't change if an error is thrown.
+      */
+      iterator
+      erase(iterator __position)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
+				 && __position < _M_iend());
+	const size_type __pos = __position - _M_ibegin();
+	_M_mutate(__pos, size_type(1), size_type(0));
+	_M_rep()->_M_set_leaked();
+	return iterator(_M_data() + __pos);
+      }
+
+      /**
+       *  @brief  Remove a range of characters.
+       *  @param __first  Iterator referencing the first character to remove.
+       *  @param __last  Iterator referencing the end of the range.
+       *  @return  Iterator referencing location of first after removal.
+       *
+       *  Removes the characters in the range [first,last) from this string.
+       *  The value of the string doesn't change if an error is thrown.
+      */
+      iterator
+      erase(iterator __first, iterator __last);
+ 
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Remove the last character.
+       *
+       *  The string must be non-empty.
+       */
+      void
+      pop_back() // FIXME C++11: should be noexcept.
+      { erase(size()-1, 1); }
+#endif // C++11
+
+      /**
+       *  @brief  Replace characters with value from another string.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n  Number of characters to be replaced.
+       *  @param __str  String to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a pos is beyond the end of this
+       *  string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__pos,__pos+__n) from
+       *  this string.  In place, the value of @a __str is inserted.
+       *  If @a __pos is beyond end of string, out_of_range is thrown.
+       *  If the length of the result exceeds max_size(), length_error
+       *  is thrown.  The value of the string doesn't change if an
+       *  error is thrown.
+      */
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+
+      /**
+       *  @brief  Replace characters with value from another string.
+       *  @param __pos1  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __str  String to insert.
+       *  @param __pos2  Index of first character of str to use.
+       *  @param __n2  Number of characters from str to use.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos1 > size() or @a __pos2 >
+       *  __str.size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__pos1,__pos1 + n) from this
+       *  string.  In place, the value of @a __str is inserted.  If @a __pos is
+       *  beyond end of string, out_of_range is thrown.  If the length of the
+       *  result exceeds max_size(), length_error is thrown.  The value of the
+       *  string doesn't change if an error is thrown.
+      */
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+	      size_type __pos2, size_type __n2)
+      { return this->replace(__pos1, __n1, __str._M_data()
+			     + __str._M_check(__pos2, "basic_string::replace"),
+			     __str._M_limit(__pos2, __n2)); }
+
+      /**
+       *  @brief  Replace characters with value of a C substring.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __s  C string to insert.
+       *  @param __n2  Number of characters from @a s to use.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a pos1 > size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__pos,__pos + __n1)
+       *  from this string.  In place, the first @a __n2 characters of
+       *  @a __s are inserted, or all of @a __s if @a __n2 is too large.  If
+       *  @a __pos is beyond end of string, out_of_range is thrown.  If
+       *  the length of result exceeds max_size(), length_error is
+       *  thrown.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+	      size_type __n2);
+
+      /**
+       *  @brief  Replace characters with value of a C string.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __s  C string to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a pos > size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__pos,__pos + __n1)
+       *  from this string.  In place, the characters of @a __s are
+       *  inserted.  If @a __pos is beyond end of string, out_of_range
+       *  is thrown.  If the length of result exceeds max_size(),
+       *  length_error is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Replace characters with multiple characters.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __n2  Number of characters to insert.
+       *  @param __c  Character to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos > size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [pos,pos + n1) from this
+       *  string.  In place, @a __n2 copies of @a __c are inserted.
+       *  If @a __pos is beyond end of string, out_of_range is thrown.
+       *  If the length of result exceeds max_size(), length_error is
+       *  thrown.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+			      _M_limit(__pos, __n1), __n2, __c); }
+
+      /**
+       *  @brief  Replace range of characters with string.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __str  String value to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__i1,__i2).  In place,
+       *  the value of @a __str is inserted.  If the length of result
+       *  exceeds max_size(), length_error is thrown.  The value of
+       *  the string doesn't change if an error is thrown.
+      */
+      basic_string&
+      replace(iterator __i1, iterator __i2, const basic_string& __str)
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+
+      /**
+       *  @brief  Replace range of characters with C substring.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __s  C string value to insert.
+       *  @param __n  Number of characters from s to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__i1,__i2).  In place,
+       *  the first @a __n characters of @a __s are inserted.  If the
+       *  length of result exceeds max_size(), length_error is thrown.
+       *  The value of the string doesn't change if an error is
+       *  thrown.
+      */
+      basic_string&
+      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
+      }
+
+      /**
+       *  @brief  Replace range of characters with C string.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __s  C string value to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__i1,__i2).  In place,
+       *  the characters of @a __s are inserted.  If the length of
+       *  result exceeds max_size(), length_error is thrown.  The
+       *  value of the string doesn't change if an error is thrown.
+      */
+      basic_string&
+      replace(iterator __i1, iterator __i2, const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Replace range of characters with multiple characters
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __n  Number of characters to insert.
+       *  @param __c  Character to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__i1,__i2).  In place,
+       *  @a __n copies of @a __c are inserted.  If the length of
+       *  result exceeds max_size(), length_error is thrown.  The
+       *  value of the string doesn't change if an error is thrown.
+      */
+      basic_string&
+      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
+      }
+
+      /**
+       *  @brief  Replace range of characters with range.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __k1  Iterator referencing start of range to insert.
+       *  @param __k2  Iterator referencing end of range to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__i1,__i2).  In place,
+       *  characters in the range [__k1,__k2) are inserted.  If the
+       *  length of result exceeds max_size(), length_error is thrown.
+       *  The value of the string doesn't change if an error is
+       *  thrown.
+      */
+      template<class _InputIterator>
+        basic_string&
+        replace(iterator __i1, iterator __i2,
+		_InputIterator __k1, _InputIterator __k2)
+        {
+	  _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				   && __i2 <= _M_iend());
+	  __glibcxx_requires_valid_range(__k1, __k2);
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
+	}
+
+      // Specializations for the common case of pointer and iterator:
+      // useful to avoid the overhead of temporary buffering in _M_replace.
+      basic_string&
+      replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(iterator __i1, iterator __i2,
+	      const _CharT* __k1, const _CharT* __k2)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1.base(), __k2 - __k1);
+      }
+
+      basic_string&
+      replace(iterator __i1, iterator __i2,
+	      const_iterator __k1, const_iterator __k2)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1.base(), __k2 - __k1);
+      }
+      
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Replace range of characters with initializer_list.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __l  The initializer_list of characters to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [__i1,__i2).  In place,
+       *  characters in the range [__k1,__k2) are inserted.  If the
+       *  length of result exceeds max_size(), length_error is thrown.
+       *  The value of the string doesn't change if an error is
+       *  thrown.
+      */
+      basic_string& replace(iterator __i1, iterator __i2,
+			    initializer_list<_CharT> __l)
+      { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
+#endif // C++11
+
+    private:
+      template<class _Integer>
+	basic_string&
+	_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
+			    _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
+
+      template<class _InputIterator>
+	basic_string&
+	_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
+			    _InputIterator __k2, __false_type);
+
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+		     _CharT __c);
+
+      basic_string&
+      _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
+		      size_type __n2);
+
+      // _S_construct_aux is used to implement the 21.3.1 para 15 which
+      // requires special behaviour if _InIter is an integral type
+      template<class _InIterator>
+        static _CharT*
+        _S_construct_aux(_InIterator __beg, _InIterator __end,
+			 const _Alloc& __a, __false_type)
+	{
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          return _S_construct(__beg, __end, __a, _Tag());
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<class _Integer>
+        static _CharT*
+        _S_construct_aux(_Integer __beg, _Integer __end,
+			 const _Alloc& __a, __true_type)
+        { return _S_construct_aux_2(static_cast<size_type>(__beg),
+				    __end, __a); }
+
+      static _CharT*
+      _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
+      { return _S_construct(__req, __c, __a); }
+
+      template<class _InIterator>
+        static _CharT*
+        _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
+	{
+	  typedef typename std::__is_integer<_InIterator>::__type _Integral;
+	  return _S_construct_aux(__beg, __end, __a, _Integral());
+        }
+
+      // For Input Iterators, used in istreambuf_iterators, etc.
+      template<class _InIterator>
+        static _CharT*
+         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+		      input_iterator_tag);
+
+      // For forward_iterators up to random_access_iterators, used for
+      // string::iterator, _CharT*, etc.
+      template<class _FwdIterator>
+        static _CharT*
+        _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
+		     forward_iterator_tag);
+
+      static _CharT*
+      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
+
+    public:
+
+      /**
+       *  @brief  Copy substring into C string.
+       *  @param __s  C string to copy value into.
+       *  @param __n  Number of characters to copy.
+       *  @param __pos  Index of first character to copy.
+       *  @return  Number of characters actually copied
+       *  @throw  std::out_of_range  If __pos > size().
+       *
+       *  Copies up to @a __n characters starting at @a __pos into the
+       *  C string @a __s.  If @a __pos is %greater than size(),
+       *  out_of_range is thrown.
+      */
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+
+      /**
+       *  @brief  Swap contents with another string.
+       *  @param __s  String to swap with.
+       *
+       *  Exchanges the contents of this string with that of @a __s in constant
+       *  time.
+      */
+      // PR 58265, this should be noexcept.
+      void
+      swap(basic_string& __s);
+
+      // String operations:
+      /**
+       *  @brief  Return const pointer to null-terminated contents.
+       *
+       *  This is a handle to internal data.  Do not modify or dire things may
+       *  happen.
+      */
+      const _CharT*
+      c_str() const _GLIBCXX_NOEXCEPT
+      { return _M_data(); }
+
+      /**
+       *  @brief  Return const pointer to contents.
+       *
+       *  This is a handle to internal data.  Do not modify or dire things may
+       *  happen.
+      */
+      const _CharT*
+      data() const _GLIBCXX_NOEXCEPT
+      { return _M_data(); }
+
+      /**
+       *  @brief  Return copy of allocator used to construct this string.
+      */
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return _M_dataplus; }
+
+      /**
+       *  @brief  Find position of a C substring.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to search from.
+       *  @param __n  Number of characters from @a s to search for.
+       *  @return  Index of start of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for the first @a
+       *  __n characters in @a __s within this string.  If found,
+       *  returns the index where it begins.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find position of a string.
+       *  @param __str  String to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of start of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for value of @a __str within
+       *  this string.  If found, returns the index where it begins.  If not
+       *  found, returns npos.
+      */
+      size_type
+      find(const basic_string& __str, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find position of a C string.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of start of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for the value of @a
+       *  __s within this string.  If found, returns the index where
+       *  it begins.  If not found, returns npos.
+      */
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for @a __c within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Find last position of a string.
+       *  @param __str  String to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of start of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for value of @a
+       *  __str within this string.  If found, returns the index where
+       *  it begins.  If not found, returns npos.
+      */
+      size_type
+      rfind(const basic_string& __str, size_type __pos = npos) const
+	_GLIBCXX_NOEXCEPT
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find last position of a C substring.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to search back from.
+       *  @param __n  Number of characters from s to search for.
+       *  @return  Index of start of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for the first @a
+       *  __n characters in @a __s within this string.  If found,
+       *  returns the index where it begins.  If not found, returns
+       *  npos.
+      */
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find last position of a C string.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to start search at (default end).
+       *  @return  Index of start of  last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for the value of
+       *  @a __s within this string.  If found, returns the index
+       *  where it begins.  If not found, returns npos.
+      */
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find last position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for @a __c within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Find position of a character of string.
+       *  @param __str  String containing characters to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for one of the
+       *  characters of @a __str within this string.  If found,
+       *  returns the index where it was found.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find_first_of(const basic_string& __str, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find position of a character of C substring.
+       *  @param __s  String containing characters to locate.
+       *  @param __pos  Index of character to search from.
+       *  @param __n  Number of characters from s to search for.
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for one of the
+       *  first @a __n characters of @a __s within this string.  If
+       *  found, returns the index where it was found.  If not found,
+       *  returns npos.
+      */
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find position of a character of C string.
+       *  @param __s  String containing characters to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for one of the
+       *  characters of @a __s within this string.  If found, returns
+       *  the index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for the character
+       *  @a __c within this string.  If found, returns the index
+       *  where it was found.  If not found, returns npos.
+       *
+       *  Note: equivalent to find(__c, __pos).
+      */
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
+      { return this->find(__c, __pos); }
+
+      /**
+       *  @brief  Find last position of a character of string.
+       *  @param __str  String containing characters to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for one of the
+       *  characters of @a __str within this string.  If found,
+       *  returns the index where it was found.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find_last_of(const basic_string& __str, size_type __pos = npos) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find last position of a character of C substring.
+       *  @param __s  C string containing characters to locate.
+       *  @param __pos  Index of character to search back from.
+       *  @param __n  Number of characters from s to search for.
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for one of the
+       *  first @a __n characters of @a __s within this string.  If
+       *  found, returns the index where it was found.  If not found,
+       *  returns npos.
+      */
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find last position of a character of C string.
+       *  @param __s  C string containing characters to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for one of the
+       *  characters of @a __s within this string.  If found, returns
+       *  the index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find last position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for @a __c within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+       *
+       *  Note: equivalent to rfind(__c, __pos).
+      */
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
+      { return this->rfind(__c, __pos); }
+
+      /**
+       *  @brief  Find position of a character not in string.
+       *  @param __str  String containing characters to avoid.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character not contained
+       *  in @a __str within this string.  If found, returns the index where it
+       *  was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find position of a character not in C substring.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search from.
+       *  @param __n  Number of characters from __s to consider.
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character not
+       *  contained in the first @a __n characters of @a __s within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+			size_type __n) const;
+
+      /**
+       *  @brief  Find position of a character not in C string.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character not
+       *  contained in @a __s within this string.  If found, returns
+       *  the index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find position of a different character.
+       *  @param __c  Character to avoid.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character
+       *  other than @a __c within this string.  If found, returns the
+       *  index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Find last position of a character not in string.
+       *  @param __str  String containing characters to avoid.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character
+       *  not contained in @a __str within this string.  If found,
+       *  returns the index where it was found.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find last position of a character not in C substring.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search back from.
+       *  @param __n  Number of characters from s to consider.
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character not
+       *  contained in the first @a __n characters of @a __s within this string.
+       *  If found, returns the index where it was found.  If not found,
+       *  returns npos.
+      */
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+		       size_type __n) const;
+      /**
+       *  @brief  Find last position of a character not in C string.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character
+       *  not contained in @a __s within this string.  If found,
+       *  returns the index where it was found.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find last position of a different character.
+       *  @param __c  Character to avoid.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character other than
+       *  @a __c within this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const
+	_GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Get a substring.
+       *  @param __pos  Index of first character (default 0).
+       *  @param __n  Number of characters in substring (default remainder).
+       *  @return  The new string.
+       *  @throw  std::out_of_range  If __pos > size().
+       *
+       *  Construct and return a new string using the @a __n
+       *  characters starting at @a __pos.  If the string is too
+       *  short, use the remainder of the characters.  If @a __pos is
+       *  beyond the end of the string, out_of_range is thrown.
+      */
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+			    _M_check(__pos, "basic_string::substr"), __n); }
+
+      /**
+       *  @brief  Compare to a string.
+       *  @param __str  String to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Returns an integer < 0 if this string is ordered before @a
+       *  __str, 0 if their values are equivalent, or > 0 if this
+       *  string is ordered after @a __str.  Determines the effective
+       *  length rlen of the strings to compare as the smallest of
+       *  size() and str.size().  The function then compares the two
+       *  strings by calling traits::compare(data(), str.data(),rlen).
+       *  If the result of the comparison is nonzero returns it,
+       *  otherwise the shorter one is ordered first.
+      */
+      int
+      compare(const basic_string& __str) const
+      {
+	const size_type __size = this->size();
+	const size_type __osize = __str.size();
+	const size_type __len = std::min(__size, __osize);
+
+	int __r = traits_type::compare(_M_data(), __str.data(), __len);
+	if (!__r)
+	  __r = _S_compare(__size, __osize);
+	return __r;
+      }
+
+      /**
+       *  @brief  Compare substring to a string.
+       *  @param __pos  Index of first character of substring.
+       *  @param __n  Number of characters in substring.
+       *  @param __str  String to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n characters
+       *  starting at @a __pos.  Returns an integer < 0 if the
+       *  substring is ordered before @a __str, 0 if their values are
+       *  equivalent, or > 0 if the substring is ordered after @a
+       *  __str.  Determines the effective length rlen of the strings
+       *  to compare as the smallest of the length of the substring
+       *  and @a __str.size().  The function then compares the two
+       *  strings by calling
+       *  traits::compare(substring.data(),str.data(),rlen).  If the
+       *  result of the comparison is nonzero returns it, otherwise
+       *  the shorter one is ordered first.
+      */
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+
+      /**
+       *  @brief  Compare substring to a substring.
+       *  @param __pos1  Index of first character of substring.
+       *  @param __n1  Number of characters in substring.
+       *  @param __str  String to compare against.
+       *  @param __pos2  Index of first character of substring of str.
+       *  @param __n2  Number of characters in substring of str.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n1
+       *  characters starting at @a __pos1.  Form the substring of @a
+       *  __str from the @a __n2 characters starting at @a __pos2.
+       *  Returns an integer < 0 if this substring is ordered before
+       *  the substring of @a __str, 0 if their values are equivalent,
+       *  or > 0 if this substring is ordered after the substring of
+       *  @a __str.  Determines the effective length rlen of the
+       *  strings to compare as the smallest of the lengths of the
+       *  substrings.  The function then compares the two strings by
+       *  calling
+       *  traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
+       *  If the result of the comparison is nonzero returns it,
+       *  otherwise the shorter one is ordered first.
+      */
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+	      size_type __pos2, size_type __n2) const;
+
+      /**
+       *  @brief  Compare to a C string.
+       *  @param __s  C string to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Returns an integer < 0 if this string is ordered before @a __s, 0 if
+       *  their values are equivalent, or > 0 if this string is ordered after
+       *  @a __s.  Determines the effective length rlen of the strings to
+       *  compare as the smallest of size() and the length of a string
+       *  constructed from @a __s.  The function then compares the two strings
+       *  by calling traits::compare(data(),s,rlen).  If the result of the
+       *  comparison is nonzero returns it, otherwise the shorter one is
+       *  ordered first.
+      */
+      int
+      compare(const _CharT* __s) const;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 5 String::compare specification questionable
+      /**
+       *  @brief  Compare substring to a C string.
+       *  @param __pos  Index of first character of substring.
+       *  @param __n1  Number of characters in substring.
+       *  @param __s  C string to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n1
+       *  characters starting at @a pos.  Returns an integer < 0 if
+       *  the substring is ordered before @a __s, 0 if their values
+       *  are equivalent, or > 0 if the substring is ordered after @a
+       *  __s.  Determines the effective length rlen of the strings to
+       *  compare as the smallest of the length of the substring and
+       *  the length of a string constructed from @a __s.  The
+       *  function then compares the two string by calling
+       *  traits::compare(substring.data(),__s,rlen).  If the result of
+       *  the comparison is nonzero returns it, otherwise the shorter
+       *  one is ordered first.
+      */
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+
+      /**
+       *  @brief  Compare substring against a character %array.
+       *  @param __pos  Index of first character of substring.
+       *  @param __n1  Number of characters in substring.
+       *  @param __s  character %array to compare against.
+       *  @param __n2  Number of characters of s.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n1
+       *  characters starting at @a __pos.  Form a string from the
+       *  first @a __n2 characters of @a __s.  Returns an integer < 0
+       *  if this substring is ordered before the string from @a __s,
+       *  0 if their values are equivalent, or > 0 if this substring
+       *  is ordered after the string from @a __s.  Determines the
+       *  effective length rlen of the strings to compare as the
+       *  smallest of the length of the substring and @a __n2.  The
+       *  function then compares the two strings by calling
+       *  traits::compare(substring.data(),s,rlen).  If the result of
+       *  the comparison is nonzero returns it, otherwise the shorter
+       *  one is ordered first.
+       *
+       *  NB: s must have at least n2 characters, &apos;\\0&apos; has
+       *  no special meaning.
+      */
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+	      size_type __n2) const;
+  };
+
+  // operator+
+  /**
+   *  @brief  Concatenate two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with value of @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  /**
+   *  @brief  Concatenate C string and string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with value of @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(const _CharT* __lhs,
+	      const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+  /**
+   *  @brief  Concatenate character and string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+  /**
+   *  @brief  Concatenate string and C string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	     const _CharT* __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  /**
+   *  @brief  Concatenate string and character.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc>	__string_type;
+      typedef typename __string_type::size_type		__size_type;
+      __string_type __str(__lhs);
+      __str.append(__size_type(1), __rhs);
+      return __str;
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+	      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	      basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+	      basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    {
+      const auto __size = __lhs.size() + __rhs.size();
+      const bool __cond = (__size > __lhs.capacity()
+			   && __size <= __rhs.capacity());
+      return __cond ? std::move(__rhs.insert(0, __lhs))
+	            : std::move(__lhs.append(__rhs));
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+	      basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs,
+	      basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, 1, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+	      const _CharT* __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+	      _CharT __rhs)
+    { return std::move(__lhs.append(1, __rhs)); }
+#endif
+
+  // operator ==
+  /**
+   *  @brief  Test equivalence of two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  template<typename _CharT>
+    inline
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
+    operator==(const basic_string<_CharT>& __lhs,
+	       const basic_string<_CharT>& __rhs)
+    { return (__lhs.size() == __rhs.size()
+	      && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+						    __lhs.size())); }
+
+  /**
+   *  @brief  Test equivalence of C string and string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __rhs.compare(@a __lhs) == 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const _CharT* __lhs,
+	       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+
+  /**
+   *  @brief  Test equivalence of string and C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  // operator !=
+  /**
+   *  @brief  Test difference of two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs.compare(@a __rhs) != 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   *  @brief  Test difference of C string and string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __rhs.compare(@a __lhs) != 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const _CharT* __lhs,
+	       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   *  @brief  Test difference of string and C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs.compare(@a __rhs) != 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+
+  // operator <
+  /**
+   *  @brief  Test if string precedes string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   *  @brief  Test if string precedes C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	      const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   *  @brief  Test if C string precedes string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const _CharT* __lhs,
+	      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+
+  // operator >
+  /**
+   *  @brief  Test if string follows string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+  /**
+   *  @brief  Test if string follows C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	      const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+  /**
+   *  @brief  Test if C string follows string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const _CharT* __lhs,
+	      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+
+  // operator <=
+  /**
+   *  @brief  Test if string doesn't follow string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+  /**
+   *  @brief  Test if string doesn't follow C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+  /**
+   *  @brief  Test if C string doesn't follow string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const _CharT* __lhs,
+	       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+
+  // operator >=
+  /**
+   *  @brief  Test if string doesn't precede string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+  /**
+   *  @brief  Test if string doesn't precede C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+  /**
+   *  @brief  Test if C string doesn't precede string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const _CharT* __lhs,
+	     const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+
+  /**
+   *  @brief  Swap contents of two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *
+   *  Exchanges the contents of @a __lhs and @a __rhs in constant time.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+	 basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+  /**
+   *  @brief  Read stream into a string.
+   *  @param __is  Input stream.
+   *  @param __str  Buffer to store into.
+   *  @return  Reference to the input stream.
+   *
+   *  Stores characters from @a __is into @a __str until whitespace is
+   *  found, the end of the stream is encountered, or str.max_size()
+   *  is reached.  If is.width() is non-zero, that is the limit on the
+   *  number of characters stored into @a __str.  Any previous
+   *  contents of @a __str are erased.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+	       basic_string<_CharT, _Traits, _Alloc>& __str);
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
+
+  /**
+   *  @brief  Write string to a stream.
+   *  @param __os  Output stream.
+   *  @param __str  String to write out.
+   *  @return  Reference to the output stream.
+   *
+   *  Output characters of @a __str into os following the same rules as for
+   *  writing a C string.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+	       const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 586. string inserter not a formatted function
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+
+  /**
+   *  @brief  Read a line from stream into a string.
+   *  @param __is  Input stream.
+   *  @param __str  Buffer to store into.
+   *  @param __delim  Character marking end of line.
+   *  @return  Reference to the input stream.
+   *
+   *  Stores characters from @a __is into @a __str until @a __delim is
+   *  found, the end of the stream is encountered, or str.max_size()
+   *  is reached.  Any previous contents of @a __str are erased.  If
+   *  @a __delim is encountered, it is extracted but not stored into
+   *  @a __str.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+	    basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+
+  /**
+   *  @brief  Read a line from stream into a string.
+   *  @param __is  Input stream.
+   *  @param __str  Buffer to store into.
+   *  @return  Reference to the input stream.
+   *
+   *  Stores characters from is into @a __str until &apos;\n&apos; is
+   *  found, the end of the stream is encountered, or str.max_size()
+   *  is reached.  Any previous contents of @a __str are erased.  If
+   *  end of line is encountered, it is extracted but not stored into
+   *  @a __str.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+	    basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return getline(__is, __str, __is.widen('\n')); }
+
+  template<>
+    basic_istream<char>&
+    getline(basic_istream<char>& __in, basic_string<char>& __str,
+	    char __delim);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+	    wchar_t __delim);
+#endif  
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if ((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+     && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#include <ext/string_conversions.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 21.4 Numeric Conversions [string.conversions].
+  inline int
+  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
+					__idx, __base); }
+
+  inline long
+  stol(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long
+  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
+			     __idx, __base); }
+
+  inline long long
+  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long long
+  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
+			     __idx, __base); }
+
+  // NB: strtof vs strtod.
+  inline float
+  stof(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
+
+  // NB: (v)snprintf vs sprintf.
+
+  // DR 1261.
+  inline string
+  to_string(int __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
+					   "%d", __val); }
+
+  inline string
+  to_string(unsigned __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+					   4 * sizeof(unsigned),
+					   "%u", __val); }
+
+  inline string
+  to_string(long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
+					   "%ld", __val); }
+
+  inline string
+  to_string(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+					   4 * sizeof(unsigned long),
+					   "%lu", __val); }
+
+  inline string
+  to_string(long long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+					   4 * sizeof(long long),
+					   "%lld", __val); }
+
+  inline string
+  to_string(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+					   4 * sizeof(unsigned long long),
+					   "%llu", __val); }
+
+  inline string
+  to_string(float __val)
+  {
+    const int __n = 
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+					   "%f", __val);
+  }
+
+  inline string
+  to_string(double __val)
+  {
+    const int __n = 
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+					   "%f", __val);
+  }
+
+  inline string
+  to_string(long double __val)
+  {
+    const int __n = 
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+					   "%Lf", __val);
+  }
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  inline int 
+  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
+					__idx, __base); }
+
+  inline long 
+  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long
+  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
+			     __idx, __base); }
+
+  inline long long
+  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long long
+  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
+			     __idx, __base); }
+
+  // NB: wcstof vs wcstod.
+  inline float
+  stof(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
+
+  // DR 1261.
+  inline wstring
+  to_wstring(int __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
+					    L"%d", __val); }
+
+  inline wstring
+  to_wstring(unsigned __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+					    4 * sizeof(unsigned),
+					    L"%u", __val); }
+
+  inline wstring
+  to_wstring(long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
+					    L"%ld", __val); }
+
+  inline wstring
+  to_wstring(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+					    4 * sizeof(unsigned long),
+					    L"%lu", __val); }
+
+  inline wstring
+  to_wstring(long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+					    4 * sizeof(long long),
+					    L"%lld", __val); }
+
+  inline wstring
+  to_wstring(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+					    4 * sizeof(unsigned long long),
+					    L"%llu", __val); }
+
+  inline wstring
+  to_wstring(float __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+					    L"%f", __val);
+  }
+
+  inline wstring
+  to_wstring(double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+					    L"%f", __val);
+  }
+
+  inline wstring
+  to_wstring(long double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+					    L"%Lf", __val);
+  }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* C++11 && _GLIBCXX_USE_C99 ... */
+
+#if __cplusplus >= 201103L
+
+#include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // DR 1182.
+
+#ifndef _GLIBCXX_COMPATIBILITY_CXX0X
+  /// std::hash specialization for string.
+  template<>
+    struct hash<string>
+    : public __hash_base<size_t, string>
+    {
+      size_t
+      operator()(const string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<string>> : std::false_type
+    { };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /// std::hash specialization for wstring.
+  template<>
+    struct hash<wstring>
+    : public __hash_base<size_t, wstring>
+    {
+      size_t
+      operator()(const wstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<wstring>> : std::false_type
+    { };
+#endif
+#endif /* _GLIBCXX_COMPATIBILITY_CXX0X */
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+  /// std::hash specialization for u16string.
+  template<>
+    struct hash<u16string>
+    : public __hash_base<size_t, u16string>
+    {
+      size_t
+      operator()(const u16string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u16string>> : std::false_type
+    { };
+
+  /// std::hash specialization for u32string.
+  template<>
+    struct hash<u32string>
+    : public __hash_base<size_t, u32string>
+    {
+      size_t
+      operator()(const u32string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u32string>> : std::false_type
+    { };
+#endif
+
+#if __cplusplus > 201103L
+
+  inline namespace literals
+  {
+  inline namespace string_literals
+  {
+
+    inline basic_string<char>
+    operator""s(const char* __str, size_t __len)
+    { return basic_string<char>{__str, __len}; }
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+    inline basic_string<wchar_t>
+    operator""s(const wchar_t* __str, size_t __len)
+    { return basic_string<wchar_t>{__str, __len}; }
+#endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+    inline basic_string<char16_t>
+    operator""s(const char16_t* __str, size_t __len)
+    { return basic_string<char16_t>{__str, __len}; }
+
+    inline basic_string<char32_t>
+    operator""s(const char32_t* __str, size_t __len)
+    { return basic_string<char32_t>{__str, __len}; }
+#endif
+
+  } // inline namespace string_literals
+  } // inline namespace literals
+
+#endif // __cplusplus > 201103L
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++11
+
+#endif /* _BASIC_STRING_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/basic_string.tcc b/gcc-4.9/libstdc++-v3/include/bits/basic_string.tcc
new file mode 100644
index 0000000..f8907c0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/basic_string.tcc
@@ -0,0 +1,1166 @@
+// Components for manipulating sequences of characters -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/basic_string.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{string}
+ */
+
+//
+// ISO C++ 14882: 21  Strings library
+//
+
+// Written by Jason Merrill based upon the specification by Takanori Adachi
+// in ANSI X3J16/94-0013R2.  Rewritten by Nathan Myers to ISO-14882.
+
+#ifndef _BASIC_STRING_TCC
+#define _BASIC_STRING_TCC 1
+
+#pragma GCC system_header
+
+#include <bits/cxxabi_forced.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const _CharT
+    basic_string<_CharT, _Traits, _Alloc>::
+    _Rep::_S_terminal = _CharT();
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+
+  // Linker sets _S_empty_rep_storage to all 0s (one reference, empty string)
+  // at static init time (before static ctors are run).
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
+    (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
+      sizeof(size_type)];
+
+  // NB: This is the special case for Input Iterators, used in
+  // istreambuf_iterators, etc.
+  // Input Iterators have a cost structure very different from
+  // pointers, calling for a different coding style.
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      _CharT*
+      basic_string<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+		   input_iterator_tag)
+      {
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+	if (__beg == __end && __a == _Alloc())
+	  return _S_empty_rep()._M_refdata();
+#endif
+	// Avoid reallocation for common case.
+	_CharT __buf[128];
+	size_type __len = 0;
+	while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
+	  {
+	    __buf[__len++] = *__beg;
+	    ++__beg;
+	  }
+	_Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
+	_M_copy(__r->_M_refdata(), __buf, __len);
+	__try
+	  {
+	    while (__beg != __end)
+	      {
+		if (__len == __r->_M_capacity)
+		  {
+		    // Allocate more space.
+		    _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
+		    _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
+		    __r->_M_destroy(__a);
+		    __r = __another;
+		  }
+		__r->_M_refdata()[__len++] = *__beg;
+		++__beg;
+	      }
+	  }
+	__catch(...)
+	  {
+	    __r->_M_destroy(__a);
+	    __throw_exception_again;
+	  }
+	__r->_M_set_length_and_sharable(__len);
+	return __r->_M_refdata();
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template <typename _InIterator>
+      _CharT*
+      basic_string<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+		   forward_iterator_tag)
+      {
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+	if (__beg == __end && __a == _Alloc())
+	  return _S_empty_rep()._M_refdata();
+#endif
+	// NB: Not required, but considered best practice.
+	if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
+	  __throw_logic_error(__N("basic_string::_S_construct null not valid"));
+
+	const size_type __dnew = static_cast<size_type>(std::distance(__beg,
+								      __end));
+	// Check for out_of_range and length_error exceptions.
+	_Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
+	__try
+	  { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
+	__catch(...)
+	  {
+	    __r->_M_destroy(__a);
+	    __throw_exception_again;
+	  }
+	__r->_M_set_length_and_sharable(__dnew);
+	return __r->_M_refdata();
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    basic_string<_CharT, _Traits, _Alloc>::
+    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
+    {
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+      if (__n == 0 && __a == _Alloc())
+	return _S_empty_rep()._M_refdata();
+#endif
+      // Check for out_of_range and length_error exceptions.
+      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
+      if (__n)
+	_M_assign(__r->_M_refdata(), __n, __c);
+
+      __r->_M_set_length_and_sharable(__n);
+      return __r->_M_refdata();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str)
+    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
+					  __str.get_allocator()),
+		  __str.get_allocator())
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _Alloc& __a)
+    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str, size_type __pos, size_type __n)
+    : _M_dataplus(_S_construct(__str._M_data()
+			       + __str._M_check(__pos,
+						"basic_string::basic_string"),
+			       __str._M_data() + __str._M_limit(__pos, __n)
+			       + __pos, _Alloc()), _Alloc())
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str, size_type __pos,
+		 size_type __n, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__str._M_data()
+			       + __str._M_check(__pos,
+						"basic_string::basic_string"),
+			       __str._M_data() + __str._M_limit(__pos, __n)
+			       + __pos, __a), __a)
+    { }
+
+  // TBD: DPG annotate
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
+    { }
+
+  // TBD: DPG annotate
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _CharT* __s, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
+			       __s + npos, __a), __a)
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__n, __c, __a), __a)
+    { }
+
+  // TBD: DPG annotate
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
+    { }
+
+#if __cplusplus >= 201103L
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(initializer_list<_CharT> __l, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a)
+    { }
+#endif
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    assign(const basic_string& __str)
+    {
+      if (_M_rep() != __str._M_rep())
+	{
+	  // XXX MT
+	  const allocator_type __a = this->get_allocator();
+	  _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
+	  _M_rep()->_M_dispose(__a);
+	  _M_data(__tmp);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    assign(const _CharT* __s, size_type __n)
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      _M_check_length(this->size(), __n, "basic_string::assign");
+      if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+	return _M_replace_safe(size_type(0), this->size(), __s, __n);
+      else
+	{
+	  // Work in-place.
+	  const size_type __pos = __s - _M_data();
+	  if (__pos >= __n)
+	    _M_copy(_M_data(), __s, __n);
+	  else if (__pos)
+	    _M_move(_M_data(), __s, __n);
+	  _M_rep()->_M_set_length_and_sharable(__n);
+	  return *this;
+	}
+     }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(size_type __n, _CharT __c)
+    {
+      if (__n)
+	{
+	  _M_check_length(size_type(0), __n, "basic_string::append");	  
+	  const size_type __len = __n + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    this->reserve(__len);
+	  _M_assign(_M_data() + this->size(), __n, __c);
+	  _M_rep()->_M_set_length_and_sharable(__len);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const _CharT* __s, size_type __n)
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      if (__n)
+	{
+	  _M_check_length(size_type(0), __n, "basic_string::append");
+	  const size_type __len = __n + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    {
+	      if (_M_disjunct(__s))
+		this->reserve(__len);
+	      else
+		{
+		  const size_type __off = __s - _M_data();
+		  this->reserve(__len);
+		  __s = _M_data() + __off;
+		}
+	    }
+	  _M_copy(_M_data() + this->size(), __s, __n);
+	  _M_rep()->_M_set_length_and_sharable(__len);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str)
+    {
+      const size_type __size = __str.size();
+      if (__size)
+	{
+	  const size_type __len = __size + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    this->reserve(__len);
+	  _M_copy(_M_data() + this->size(), __str._M_data(), __size);
+	  _M_rep()->_M_set_length_and_sharable(__len);
+	}
+      return *this;
+    }    
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str, size_type __pos, size_type __n)
+    {
+      __str._M_check(__pos, "basic_string::append");
+      __n = __str._M_limit(__pos, __n);
+      if (__n)
+	{
+	  const size_type __len = __n + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    this->reserve(__len);
+	  _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
+	  _M_rep()->_M_set_length_and_sharable(__len);	  
+	}
+      return *this;
+    }
+
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     basic_string<_CharT, _Traits, _Alloc>&
+     basic_string<_CharT, _Traits, _Alloc>::
+     insert(size_type __pos, const _CharT* __s, size_type __n)
+     {
+       __glibcxx_requires_string_len(__s, __n);
+       _M_check(__pos, "basic_string::insert");
+       _M_check_length(size_type(0), __n, "basic_string::insert");
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+         return _M_replace_safe(__pos, size_type(0), __s, __n);
+       else
+         {
+           // Work in-place.
+           const size_type __off = __s - _M_data();
+           _M_mutate(__pos, 0, __n);
+           __s = _M_data() + __off;
+           _CharT* __p = _M_data() + __pos;
+           if (__s  + __n <= __p)
+             _M_copy(__p, __s, __n);
+           else if (__s >= __p)
+             _M_copy(__p, __s + __n, __n);
+           else
+             {
+	       const size_type __nleft = __p - __s;
+               _M_copy(__p, __s, __nleft);
+               _M_copy(__p + __nleft, __p + __n, __n - __nleft);
+             }
+           return *this;
+         }
+     }
+
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     typename basic_string<_CharT, _Traits, _Alloc>::iterator
+     basic_string<_CharT, _Traits, _Alloc>::
+     erase(iterator __first, iterator __last)
+     {
+       _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
+				&& __last <= _M_iend());
+
+       // NB: This isn't just an optimization (bail out early when
+       // there is nothing to do, really), it's also a correctness
+       // issue vs MT, see libstdc++/40518.
+       const size_type __size = __last - __first;
+       if (__size)
+	 {
+	   const size_type __pos = __first - _M_ibegin();
+	   _M_mutate(__pos, __size, size_type(0));
+	   _M_rep()->_M_set_leaked();
+	   return iterator(_M_data() + __pos);
+	 }
+       else
+	 return __first;
+     }
+
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     basic_string<_CharT, _Traits, _Alloc>&
+     basic_string<_CharT, _Traits, _Alloc>::
+     replace(size_type __pos, size_type __n1, const _CharT* __s,
+	     size_type __n2)
+     {
+       __glibcxx_requires_string_len(__s, __n2);
+       _M_check(__pos, "basic_string::replace");
+       __n1 = _M_limit(__pos, __n1);
+       _M_check_length(__n1, __n2, "basic_string::replace");
+       bool __left;
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+         return _M_replace_safe(__pos, __n1, __s, __n2);
+       else if ((__left = __s + __n2 <= _M_data() + __pos)
+		|| _M_data() + __pos + __n1 <= __s)
+	 {
+	   // Work in-place: non-overlapping case.
+	   size_type __off = __s - _M_data();
+	   __left ? __off : (__off += __n2 - __n1);
+	   _M_mutate(__pos, __n1, __n2);
+	   _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
+	   return *this;
+	 }
+       else
+	 {
+	   // Todo: overlapping case.
+	   const basic_string __tmp(__s, __n2);
+	   return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
+	 }
+     }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _M_destroy(const _Alloc& __a) throw ()
+    {
+      const size_type __size = sizeof(_Rep_base) +
+	                       (this->_M_capacity + 1) * sizeof(_CharT);
+      _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_leak_hard()
+    {
+#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
+      if (_M_rep() == &_S_empty_rep())
+	return;
+#endif
+      if (_M_rep()->_M_is_shared())
+	_M_mutate(0, 0, 0);
+      _M_rep()->_M_set_leaked();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, size_type __len2)
+    {
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+      const size_type __how_much = __old_size - __pos - __len1;
+
+      if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
+	{
+	  // Must reallocate.
+	  const allocator_type __a = get_allocator();
+	  _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
+
+	  if (__pos)
+	    _M_copy(__r->_M_refdata(), _M_data(), __pos);
+	  if (__how_much)
+	    _M_copy(__r->_M_refdata() + __pos + __len2,
+		    _M_data() + __pos + __len1, __how_much);
+
+	  _M_rep()->_M_dispose(__a);
+	  _M_data(__r->_M_refdata());
+	}
+      else if (__how_much && __len1 != __len2)
+	{
+	  // Work in-place.
+	  _M_move(_M_data() + __pos + __len2,
+		  _M_data() + __pos + __len1, __how_much);
+	}
+      _M_rep()->_M_set_length_and_sharable(__new_size);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
+    {
+      if (__res != this->capacity() || _M_rep()->_M_is_shared())
+        {
+	  // Make sure we don't shrink below the current size
+	  if (__res < this->size())
+	    __res = this->size();
+	  const allocator_type __a = get_allocator();
+	  _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
+	  _M_rep()->_M_dispose(__a);
+	  _M_data(__tmp);
+        }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s)
+    {
+      if (_M_rep()->_M_is_leaked())
+	_M_rep()->_M_set_sharable();
+      if (__s._M_rep()->_M_is_leaked())
+	__s._M_rep()->_M_set_sharable();
+      if (this->get_allocator() == __s.get_allocator())
+	{
+	  _CharT* __tmp = _M_data();
+	  _M_data(__s._M_data());
+	  __s._M_data(__tmp);
+	}
+      // The code below can usually be optimized away.
+      else
+	{
+	  const basic_string __tmp1(_M_ibegin(), _M_iend(),
+				    __s.get_allocator());
+	  const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
+				    this->get_allocator());
+	  *this = __tmp2;
+	  __s = __tmp1;
+	}
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _S_create(size_type __capacity, size_type __old_capacity,
+	      const _Alloc& __alloc)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 83.  String::npos vs. string::max_size()
+      if (__capacity > _S_max_size)
+	__throw_length_error(__N("basic_string::_S_create"));
+
+      // The standard places no restriction on allocating more memory
+      // than is strictly needed within this layer at the moment or as
+      // requested by an explicit application call to reserve().
+
+      // Many malloc implementations perform quite poorly when an
+      // application attempts to allocate memory in a stepwise fashion
+      // growing each allocation size by only 1 char.  Additionally,
+      // it makes little sense to allocate less linear memory than the
+      // natural blocking size of the malloc implementation.
+      // Unfortunately, we would need a somewhat low-level calculation
+      // with tuned parameters to get this perfect for any particular
+      // malloc implementation.  Fortunately, generalizations about
+      // common features seen among implementations seems to suffice.
+
+      // __pagesize need not match the actual VM page size for good
+      // results in practice, thus we pick a common value on the low
+      // side.  __malloc_header_size is an estimate of the amount of
+      // overhead per memory allocation (in practice seen N * sizeof
+      // (void*) where N is 0, 2 or 4).  According to folklore,
+      // picking this value on the high side is better than
+      // low-balling it (especially when this algorithm is used with
+      // malloc implementations that allocate memory blocks rounded up
+      // to a size which is a power of 2).
+      const size_type __pagesize = 4096;
+      const size_type __malloc_header_size = 4 * sizeof(void*);
+
+      // The below implements an exponential growth policy, necessary to
+      // meet amortized linear time requirements of the library: see
+      // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
+      // It's active for allocations requiring an amount of memory above
+      // system pagesize. This is consistent with the requirements of the
+      // standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+	__capacity = 2 * __old_capacity;
+
+      // NB: Need an array of char_type[__capacity], plus a terminating
+      // null char_type() element, plus enough for the _Rep data structure.
+      // Whew. Seemingly so needy, yet so elemental.
+      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
+
+      const size_type __adj_size = __size + __malloc_header_size;
+      if (__adj_size > __pagesize && __capacity > __old_capacity)
+	{
+	  const size_type __extra = __pagesize - __adj_size % __pagesize;
+	  __capacity += __extra / sizeof(_CharT);
+	  // Never allocate a string bigger than _S_max_size.
+	  if (__capacity > _S_max_size)
+	    __capacity = _S_max_size;
+	  __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
+	}
+
+      // NB: Might throw, but no worries about a leak, mate: _Rep()
+      // does not throw.
+      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
+      _Rep *__p = new (__place) _Rep;
+      __p->_M_capacity = __capacity;
+      // ABI compatibility - 3.4.x set in _S_create both
+      // _M_refcount and _M_length.  All callers of _S_create
+      // in basic_string.tcc then set just _M_length.
+      // In 4.0.x and later both _M_refcount and _M_length
+      // are initialized in the callers, unfortunately we can
+      // have 3.4.x compiled code with _S_create callers inlined
+      // calling 4.0.x+ _S_create.
+      __p->_M_set_sharable();
+      return __p;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _M_clone(const _Alloc& __alloc, size_type __res)
+    {
+      // Requested capacity of the clone.
+      const size_type __requested_cap = this->_M_length + __res;
+      _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
+				  __alloc);
+      if (this->_M_length)
+	_M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
+
+      __r->_M_set_length_and_sharable(this->_M_length);
+      return __r->_M_refdata();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      _M_check_length(__size, __n, "basic_string::resize");
+      if (__size < __n)
+	this->append(__n - __size, __c);
+      else if (__n < __size)
+	this->erase(__n);
+      // else nothing (in particular, avoid calling _M_mutate() unnecessarily.)
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+      basic_string<_CharT, _Traits, _Alloc>&
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
+			  _InputIterator __k2, __false_type)
+      {
+	const basic_string __s(__k1, __k2);
+	const size_type __n1 = __i2 - __i1;
+	_M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
+	return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
+			       __s.size());
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+		   _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+	_M_assign(_M_data() + __pos1, __n2, __c);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
+		    size_type __n2)
+    {
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+	_M_copy(_M_data() + __pos1, __s, __n2);
+      return *this;
+    }
+   
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+	      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      __glibcxx_requires_string(__lhs);
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type	  __size_type;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str;
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type	  __size_type;
+      __string_type __str;
+      const __size_type __len = __rhs.size();
+      __str.reserve(__len + 1);
+      __str.append(__size_type(1), __lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "basic_string::copy");
+      __n = _M_limit(__pos, __n);
+      __glibcxx_requires_string_len(__s, __n);
+      if (__n)
+	_M_copy(__s, _M_data() + __pos, __n);
+      // 21.3.5.7 par 3: do not append null.  (good.)
+      return __n;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      const size_type __size = this->size();
+      const _CharT* __data = _M_data();
+
+      if (__n == 0)
+	return __pos <= __size ? __pos : npos;
+
+      if (__n <= __size)
+	{
+	  for (; __pos <= __size - __n; ++__pos)
+	    if (traits_type::eq(__data[__pos], __s[0])
+		&& traits_type::compare(__data + __pos + 1,
+					__s + 1, __n - 1) == 0)
+	      return __pos;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      size_type __ret = npos;
+      const size_type __size = this->size();
+      if (__pos < __size)
+	{
+	  const _CharT* __data = _M_data();
+	  const size_type __n = __size - __pos;
+	  const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
+	  if (__p)
+	    __ret = __p - __data;
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      const size_type __size = this->size();
+      if (__n <= __size)
+	{
+	  __pos = std::min(size_type(__size - __n), __pos);
+	  const _CharT* __data = _M_data();
+	  do
+	    {
+	      if (traits_type::compare(__data + __pos, __s, __n) == 0)
+		return __pos;
+	    }
+	  while (__pos-- > 0);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      size_type __size = this->size();
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  for (++__size; __size-- > 0; )
+	    if (traits_type::eq(_M_data()[__size], __c))
+	      return __size;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      for (; __n && __pos < this->size(); ++__pos)
+	{
+	  const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
+	  if (__p)
+	    return __pos;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      size_type __size = this->size();
+      if (__size && __n)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (traits_type::find(__s, __n, _M_data()[__size]))
+		return __size;
+	    }
+	  while (__size-- != 0);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      for (; __pos < this->size(); ++__pos)
+	if (!traits_type::find(__s, __n, _M_data()[__pos]))
+	  return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      for (; __pos < this->size(); ++__pos)
+	if (!traits_type::eq(_M_data()[__pos], __c))
+	  return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      size_type __size = this->size();
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (!traits_type::find(__s, __n, _M_data()[__size]))
+		return __size;
+	    }
+	  while (__size--);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      size_type __size = this->size();
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (!traits_type::eq(_M_data()[__size], __c))
+		return __size;
+	    }
+	  while (__size--);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n, const basic_string& __str) const
+    {
+      _M_check(__pos, "basic_string::compare");
+      __n = _M_limit(__pos, __n);
+      const size_type __osize = __str.size();
+      const size_type __len = std::min(__n, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
+      if (!__r)
+	__r = _S_compare(__n, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+	    size_type __pos2, size_type __n2) const
+    {
+      _M_check(__pos1, "basic_string::compare");
+      __str._M_check(__pos2, "basic_string::compare");
+      __n1 = _M_limit(__pos1, __n1);
+      __n2 = __str._M_limit(__pos2, __n2);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos1,
+				     __str.data() + __pos2, __len);
+      if (!__r)
+	__r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(const _CharT* __s) const
+    {
+      __glibcxx_requires_string(__s);
+      const size_type __size = this->size();
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__size, __osize);
+      int __r = traits_type::compare(_M_data(), __s, __len);
+      if (!__r)
+	__r = _S_compare(__size, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s) const
+    {
+      __glibcxx_requires_string(__s);
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__n1, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+	__r = _S_compare(__n1, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
+	    size_type __n2) const
+    {
+      __glibcxx_requires_string_len(__s, __n2);
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+	__r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+  // 21.3.7.9 basic_string::getline and operators
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in,
+	       basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      typedef basic_istream<_CharT, _Traits>		__istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc>	__string_type;
+      typedef typename __istream_type::ios_base         __ios_base;
+      typedef typename __istream_type::int_type		__int_type;
+      typedef typename __string_type::size_type		__size_type;
+      typedef ctype<_CharT>				__ctype_type;
+      typedef typename __ctype_type::ctype_base         __ctype_base;
+
+      __size_type __extracted = 0;
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      // Avoid reallocation for common case.
+	      __str.erase();
+	      _CharT __buf[128];
+	      __size_type __len = 0;	      
+	      const streamsize __w = __in.width();
+	      const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
+		                              : __str.max_size();
+	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+	      const __int_type __eof = _Traits::eof();
+	      __int_type __c = __in.rdbuf()->sgetc();
+
+	      while (__extracted < __n
+		     && !_Traits::eq_int_type(__c, __eof)
+		     && !__ct.is(__ctype_base::space,
+				 _Traits::to_char_type(__c)))
+		{
+		  if (__len == sizeof(__buf) / sizeof(_CharT))
+		    {
+		      __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+		      __len = 0;
+		    }
+		  __buf[__len++] = _Traits::to_char_type(__c);
+		  ++__extracted;
+		  __c = __in.rdbuf()->snextc();
+		}
+	      __str.append(__buf, __len);
+
+	      if (_Traits::eq_int_type(__c, __eof))
+		__err |= __ios_base::eofbit;
+	      __in.width(0);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __in._M_setstate(__ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 91. Description of operator>> and getline() for string<>
+	      // might cause endless loop
+	      __in._M_setstate(__ios_base::badbit);
+	    }
+	}
+      // 211.  operator>>(istream&, string&) doesn't set failbit
+      if (!__extracted)
+	__err |= __ios_base::failbit;
+      if (__err)
+	__in.setstate(__err);
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __in,
+	    basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    {
+      typedef basic_istream<_CharT, _Traits>		__istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc>	__string_type;
+      typedef typename __istream_type::ios_base         __ios_base;
+      typedef typename __istream_type::int_type		__int_type;
+      typedef typename __string_type::size_type		__size_type;
+
+      __size_type __extracted = 0;
+      const __size_type __n = __str.max_size();
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, true);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      __str.erase();
+	      const __int_type __idelim = _Traits::to_int_type(__delim);
+	      const __int_type __eof = _Traits::eof();
+	      __int_type __c = __in.rdbuf()->sgetc();
+
+	      while (__extracted < __n
+		     && !_Traits::eq_int_type(__c, __eof)
+		     && !_Traits::eq_int_type(__c, __idelim))
+		{
+		  __str += _Traits::to_char_type(__c);
+		  ++__extracted;
+		  __c = __in.rdbuf()->snextc();
+		}
+
+	      if (_Traits::eq_int_type(__c, __eof))
+		__err |= __ios_base::eofbit;
+	      else if (_Traits::eq_int_type(__c, __idelim))
+		{
+		  ++__extracted;		  
+		  __in.rdbuf()->sbumpc();
+		}
+	      else
+		__err |= __ios_base::failbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __in._M_setstate(__ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 91. Description of operator>> and getline() for string<>
+	      // might cause endless loop
+	      __in._M_setstate(__ios_base::badbit);
+	    }
+	}
+      if (!__extracted)
+	__err |= __ios_base::failbit;
+      if (__err)
+	__in.setstate(__err);
+      return __in;
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE > 0
+  extern template class basic_string<char>;
+  extern template
+    basic_istream<char>&
+    operator>>(basic_istream<char>&, string&);
+  extern template
+    basic_ostream<char>&
+    operator<<(basic_ostream<char>&, const string&);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&, char);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_string<wchar_t>;
+  extern template
+    basic_istream<wchar_t>&
+    operator>>(basic_istream<wchar_t>&, wstring&);
+  extern template
+    basic_ostream<wchar_t>&
+    operator<<(basic_ostream<wchar_t>&, const wstring&);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/boost_concept_check.h b/gcc-4.9/libstdc++-v3/include/bits/boost_concept_check.h
new file mode 100644
index 0000000..79e2d5a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/boost_concept_check.h
@@ -0,0 +1,790 @@
+// -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+//
+
+/** @file bits/boost_concept_check.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ */
+
+// GCC Note:  based on version 1.12.0 of the Boost library.
+
+#ifndef _BOOST_CONCEPT_CHECK_H
+#define _BOOST_CONCEPT_CHECK_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stl_iterator_base_types.h>    // for traits and tags
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#define _IsUnused __attribute__ ((__unused__))
+
+// When the C-C code is in use, we would like this function to do as little
+// as possible at runtime, use as few resources as possible, and hopefully
+// be elided out of existence... hmmm.
+template <class _Concept>
+inline void __function_requires()
+{
+  void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
+}
+
+// No definition: if this is referenced, there's a problem with
+// the instantiating type not being one of the required integer types.
+// Unfortunately, this results in a link-time error, not a compile-time error.
+void __error_type_must_be_an_integer_type();
+void __error_type_must_be_an_unsigned_integer_type();
+void __error_type_must_be_a_signed_integer_type();
+
+// ??? Should the "concept_checking*" structs begin with more than _ ?
+#define _GLIBCXX_CLASS_REQUIRES(_type_var, _ns, _concept) \
+  typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); \
+  template <_func##_type_var##_concept _Tp1> \
+  struct _concept_checking##_type_var##_concept { }; \
+  typedef _concept_checking##_type_var##_concept< \
+    &_ns::_concept <_type_var>::__constraints> \
+    _concept_checking_typedef##_type_var##_concept
+
+#define _GLIBCXX_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \
+  typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); \
+  template <_func##_type_var1##_type_var2##_concept _Tp1> \
+  struct _concept_checking##_type_var1##_type_var2##_concept { }; \
+  typedef _concept_checking##_type_var1##_type_var2##_concept< \
+    &_ns::_concept <_type_var1,_type_var2>::__constraints> \
+    _concept_checking_typedef##_type_var1##_type_var2##_concept
+
+#define _GLIBCXX_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \
+  typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); \
+  template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> \
+  struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; \
+  typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< \
+    &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints>  \
+  _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept
+
+#define _GLIBCXX_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \
+  typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); \
+  template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> \
+  struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; \
+  typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< \
+  &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \
+    _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept
+
+
+template <class _Tp1, class _Tp2>
+struct _Aux_require_same { };
+
+template <class _Tp>
+struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
+
+  template <class _Tp1, class _Tp2>
+  struct _SameTypeConcept
+  {
+    void __constraints() {
+      typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
+    }
+  };
+
+  template <class _Tp>
+  struct _IntegerConcept {
+    void __constraints() {
+      __error_type_must_be_an_integer_type();
+    }
+  };
+  template <> struct _IntegerConcept<short> { void __constraints() {} };
+  template <> struct _IntegerConcept<unsigned short> { void __constraints(){} };
+  template <> struct _IntegerConcept<int> { void __constraints() {} };
+  template <> struct _IntegerConcept<unsigned int> { void __constraints() {} };
+  template <> struct _IntegerConcept<long> { void __constraints() {} };
+  template <> struct _IntegerConcept<unsigned long> { void __constraints() {} };
+  template <> struct _IntegerConcept<long long> { void __constraints() {} };
+  template <> struct _IntegerConcept<unsigned long long>
+                                                { void __constraints() {} };
+
+  template <class _Tp>
+  struct _SignedIntegerConcept {
+    void __constraints() {
+      __error_type_must_be_a_signed_integer_type();
+    }
+  };
+  template <> struct _SignedIntegerConcept<short> { void __constraints() {} };
+  template <> struct _SignedIntegerConcept<int> { void __constraints() {} };
+  template <> struct _SignedIntegerConcept<long> { void __constraints() {} };
+  template <> struct _SignedIntegerConcept<long long> { void __constraints(){}};
+
+  template <class _Tp>
+  struct _UnsignedIntegerConcept {
+    void __constraints() {
+      __error_type_must_be_an_unsigned_integer_type();
+    }
+  };
+  template <> struct _UnsignedIntegerConcept<unsigned short>
+    { void __constraints() {} };
+  template <> struct _UnsignedIntegerConcept<unsigned int>
+    { void __constraints() {} };
+  template <> struct _UnsignedIntegerConcept<unsigned long>
+    { void __constraints() {} };
+  template <> struct _UnsignedIntegerConcept<unsigned long long>
+    { void __constraints() {} };
+
+  //===========================================================================
+  // Basic Concepts
+
+  template <class _Tp>
+  struct _DefaultConstructibleConcept
+  {
+    void __constraints() {
+      _Tp __a _IsUnused;                // require default constructor
+    }
+  };
+
+  template <class _Tp>
+  struct _AssignableConcept
+  {
+    void __constraints() {
+      __a = __a;                        // require assignment operator
+      __const_constraints(__a);
+    }
+    void __const_constraints(const _Tp& __b) {
+      __a = __b;                   // const required for argument to assignment
+    }
+    _Tp __a;
+    // possibly should be "Tp* a;" and then dereference "a" in constraint
+    // functions?  present way would require a default ctor, i think...
+  };
+
+  template <class _Tp>
+  struct _CopyConstructibleConcept
+  {
+    void __constraints() {
+      _Tp __a(__b);                     // require copy constructor
+      _Tp* __ptr _IsUnused = &__a;      // require address of operator
+      __const_constraints(__a);
+    }
+    void __const_constraints(const _Tp& __a) {
+      _Tp __c _IsUnused(__a);           // require const copy constructor
+      const _Tp* __ptr _IsUnused = &__a; // require const address of operator
+    }
+    _Tp __b;
+  };
+
+  // The SGI STL version of Assignable requires copy constructor and operator=
+  template <class _Tp>
+  struct _SGIAssignableConcept
+  {
+    void __constraints() {
+      _Tp __b _IsUnused(__a);
+      __a = __a;                        // require assignment operator
+      __const_constraints(__a);
+    }
+    void __const_constraints(const _Tp& __b) {
+      _Tp __c _IsUnused(__b);
+      __a = __b;              // const required for argument to assignment
+    }
+    _Tp __a;
+  };
+
+  template <class _From, class _To>
+  struct _ConvertibleConcept
+  {
+    void __constraints() {
+      _To __y _IsUnused = __x;
+    }
+    _From __x;
+  };
+
+  // The C++ standard requirements for many concepts talk about return
+  // types that must be "convertible to bool".  The problem with this
+  // requirement is that it leaves the door open for evil proxies that
+  // define things like operator|| with strange return types.  Two
+  // possible solutions are:
+  // 1) require the return type to be exactly bool
+  // 2) stay with convertible to bool, and also
+  //    specify stuff about all the logical operators.
+  // For now we just test for convertible to bool.
+  template <class _Tp>
+  void __aux_require_boolean_expr(const _Tp& __t) {
+    bool __x _IsUnused = __t;
+  }
+
+// FIXME
+  template <class _Tp>
+  struct _EqualityComparableConcept
+  {
+    void __constraints() {
+      __aux_require_boolean_expr(__a == __b);
+    }
+    _Tp __a, __b;
+  };
+
+  template <class _Tp>
+  struct _LessThanComparableConcept
+  {
+    void __constraints() {
+      __aux_require_boolean_expr(__a < __b);
+    }
+    _Tp __a, __b;
+  };
+
+  // This is equivalent to SGI STL's LessThanComparable.
+  template <class _Tp>
+  struct _ComparableConcept
+  {
+    void __constraints() {
+      __aux_require_boolean_expr(__a < __b);
+      __aux_require_boolean_expr(__a > __b);
+      __aux_require_boolean_expr(__a <= __b);
+      __aux_require_boolean_expr(__a >= __b);
+    }
+    _Tp __a, __b;
+  };
+
+#define _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
+  template <class _First, class _Second> \
+  struct _NAME { \
+    void __constraints() { (void)__constraints_(); } \
+    bool __constraints_() {  \
+      return  __a _OP __b; \
+    } \
+    _First __a; \
+    _Second __b; \
+  }
+
+#define _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
+  template <class _Ret, class _First, class _Second> \
+  struct _NAME { \
+    void __constraints() { (void)__constraints_(); } \
+    _Ret __constraints_() {  \
+      return __a _OP __b; \
+    } \
+    _First __a; \
+    _Second __b; \
+  }
+
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
+
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
+
+#undef _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
+#undef _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT
+
+  //===========================================================================
+  // Function Object Concepts
+
+  template <class _Func, class _Return>
+  struct _GeneratorConcept
+  {
+    void __constraints() {
+      const _Return& __r _IsUnused = __f();// require operator() member function
+    }
+    _Func __f;
+  };
+
+
+  template <class _Func>
+  struct _GeneratorConcept<_Func,void>
+  {
+    void __constraints() {
+      __f();                            // require operator() member function
+    }
+    _Func __f;
+  };
+
+  template <class _Func, class _Return, class _Arg>
+  struct _UnaryFunctionConcept
+  {
+    void __constraints() {
+      __r = __f(__arg);                  // require operator()
+    }
+    _Func __f;
+    _Arg __arg;
+    _Return __r;
+  };
+
+  template <class _Func, class _Arg>
+  struct _UnaryFunctionConcept<_Func, void, _Arg> {
+    void __constraints() {
+      __f(__arg);                       // require operator()
+    }
+    _Func __f;
+    _Arg __arg;
+  };
+
+  template <class _Func, class _Return, class _First, class _Second>
+  struct _BinaryFunctionConcept
+  {
+    void __constraints() {
+      __r = __f(__first, __second);     // require operator()
+    }
+    _Func __f;
+    _First __first;
+    _Second __second;
+    _Return __r;
+  };
+
+  template <class _Func, class _First, class _Second>
+  struct _BinaryFunctionConcept<_Func, void, _First, _Second>
+  {
+    void __constraints() {
+      __f(__first, __second);           // require operator()
+    }
+    _Func __f;
+    _First __first;
+    _Second __second;
+  };
+
+  template <class _Func, class _Arg>
+  struct _UnaryPredicateConcept
+  {
+    void __constraints() {
+      __aux_require_boolean_expr(__f(__arg)); // require op() returning bool
+    }
+    _Func __f;
+    _Arg __arg;
+  };
+
+  template <class _Func, class _First, class _Second>
+  struct _BinaryPredicateConcept
+  {
+    void __constraints() {
+      __aux_require_boolean_expr(__f(__a, __b)); // require op() returning bool
+    }
+    _Func __f;
+    _First __a;
+    _Second __b;
+  };
+
+  // use this when functor is used inside a container class like std::set
+  template <class _Func, class _First, class _Second>
+  struct _Const_BinaryPredicateConcept {
+    void __constraints() {
+      __const_constraints(__f);
+    }
+    void __const_constraints(const _Func& __fun) {
+      __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >();
+      // operator() must be a const member function
+      __aux_require_boolean_expr(__fun(__a, __b));
+    }
+    _Func __f;
+    _First __a;
+    _Second __b;
+  };
+
+  //===========================================================================
+  // Iterator Concepts
+
+  template <class _Tp>
+  struct _TrivialIteratorConcept
+  {
+    void __constraints() {
+//    __function_requires< _DefaultConstructibleConcept<_Tp> >();
+      __function_requires< _AssignableConcept<_Tp> >();
+      __function_requires< _EqualityComparableConcept<_Tp> >();
+//      typedef typename std::iterator_traits<_Tp>::value_type _V;
+      (void)*__i;                       // require dereference operator
+    }
+    _Tp __i;
+  };
+
+  template <class _Tp>
+  struct _Mutable_TrivialIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _TrivialIteratorConcept<_Tp> >();
+      *__i = *__j;                      // require dereference and assignment
+    }
+    _Tp __i, __j;
+  };
+
+  template <class _Tp>
+  struct _InputIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _TrivialIteratorConcept<_Tp> >();
+      // require iterator_traits typedef's
+      typedef typename std::iterator_traits<_Tp>::difference_type _Diff;
+//      __function_requires< _SignedIntegerConcept<_Diff> >();
+      typedef typename std::iterator_traits<_Tp>::reference _Ref;
+      typedef typename std::iterator_traits<_Tp>::pointer _Pt;
+      typedef typename std::iterator_traits<_Tp>::iterator_category _Cat;
+      __function_requires< _ConvertibleConcept<
+        typename std::iterator_traits<_Tp>::iterator_category,
+        std::input_iterator_tag> >();
+      ++__i;                            // require preincrement operator
+      __i++;                            // require postincrement operator
+    }
+    _Tp __i;
+  };
+
+  template <class _Tp, class _ValueT>
+  struct _OutputIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _AssignableConcept<_Tp> >();
+      ++__i;                            // require preincrement operator
+      __i++;                            // require postincrement operator
+      *__i++ = __t;                     // require postincrement and assignment
+    }
+    _Tp __i;
+    _ValueT __t;
+  };
+
+  template <class _Tp>
+  struct _ForwardIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _InputIteratorConcept<_Tp> >();
+      __function_requires< _DefaultConstructibleConcept<_Tp> >();
+      __function_requires< _ConvertibleConcept<
+        typename std::iterator_traits<_Tp>::iterator_category,
+        std::forward_iterator_tag> >();
+      typedef typename std::iterator_traits<_Tp>::reference _Ref;
+      _Ref __r _IsUnused = *__i;
+    }
+    _Tp __i;
+  };
+
+  template <class _Tp>
+  struct _Mutable_ForwardIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _ForwardIteratorConcept<_Tp> >();
+      *__i++ = *__i;                    // require postincrement and assignment
+    }
+    _Tp __i;
+  };
+
+  template <class _Tp>
+  struct _BidirectionalIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _ForwardIteratorConcept<_Tp> >();
+      __function_requires< _ConvertibleConcept<
+        typename std::iterator_traits<_Tp>::iterator_category,
+        std::bidirectional_iterator_tag> >();
+      --__i;                            // require predecrement operator
+      __i--;                            // require postdecrement operator
+    }
+    _Tp __i;
+  };
+
+  template <class _Tp>
+  struct _Mutable_BidirectionalIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _BidirectionalIteratorConcept<_Tp> >();
+      __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >();
+      *__i-- = *__i;                    // require postdecrement and assignment
+    }
+    _Tp __i;
+  };
+
+
+  template <class _Tp>
+  struct _RandomAccessIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _BidirectionalIteratorConcept<_Tp> >();
+      __function_requires< _ComparableConcept<_Tp> >();
+      __function_requires< _ConvertibleConcept<
+        typename std::iterator_traits<_Tp>::iterator_category,
+        std::random_access_iterator_tag> >();
+      // ??? We don't use _Ref, are we just checking for "referenceability"?
+      typedef typename std::iterator_traits<_Tp>::reference _Ref;
+
+      __i += __n;                       // require assignment addition operator
+      __i = __i + __n; __i = __n + __i; // require addition with difference type
+      __i -= __n;                       // require assignment subtraction op
+      __i = __i - __n;                  // require subtraction with
+                                        //            difference type
+      __n = __i - __j;                  // require difference operator
+      (void)__i[__n];                   // require element access operator
+    }
+    _Tp __a, __b;
+    _Tp __i, __j;
+    typename std::iterator_traits<_Tp>::difference_type __n;
+  };
+
+  template <class _Tp>
+  struct _Mutable_RandomAccessIteratorConcept
+  {
+    void __constraints() {
+      __function_requires< _RandomAccessIteratorConcept<_Tp> >();
+      __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >();
+      __i[__n] = *__i;                  // require element access and assignment
+    }
+    _Tp __i;
+    typename std::iterator_traits<_Tp>::difference_type __n;
+  };
+
+  //===========================================================================
+  // Container Concepts
+
+  template <class _Container>
+  struct _ContainerConcept
+  {
+    typedef typename _Container::value_type _Value_type;
+    typedef typename _Container::difference_type _Difference_type;
+    typedef typename _Container::size_type _Size_type;
+    typedef typename _Container::const_reference _Const_reference;
+    typedef typename _Container::const_pointer _Const_pointer;
+    typedef typename _Container::const_iterator _Const_iterator;
+
+    void __constraints() {
+      __function_requires< _InputIteratorConcept<_Const_iterator> >();
+      __function_requires< _AssignableConcept<_Container> >();
+      const _Container __c;
+      __i = __c.begin();
+      __i = __c.end();
+      __n = __c.size();
+      __n = __c.max_size();
+      __b = __c.empty();
+    }
+    bool __b;
+    _Const_iterator __i;
+    _Size_type __n;
+  };
+
+  template <class _Container>
+  struct _Mutable_ContainerConcept
+  {
+    typedef typename _Container::value_type _Value_type;
+    typedef typename _Container::reference _Reference;
+    typedef typename _Container::iterator _Iterator;
+    typedef typename _Container::pointer _Pointer;
+
+    void __constraints() {
+      __function_requires< _ContainerConcept<_Container> >();
+      __function_requires< _AssignableConcept<_Value_type> >();
+      __function_requires< _InputIteratorConcept<_Iterator> >();
+
+      __i = __c.begin();
+      __i = __c.end();
+      __c.swap(__c2);
+    }
+    _Iterator __i;
+    _Container __c, __c2;
+  };
+
+  template <class _ForwardContainer>
+  struct _ForwardContainerConcept
+  {
+    void __constraints() {
+      __function_requires< _ContainerConcept<_ForwardContainer> >();
+      typedef typename _ForwardContainer::const_iterator _Const_iterator;
+      __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
+    }
+  };
+
+  template <class _ForwardContainer>
+  struct _Mutable_ForwardContainerConcept
+  {
+    void __constraints() {
+      __function_requires< _ForwardContainerConcept<_ForwardContainer> >();
+      __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >();
+      typedef typename _ForwardContainer::iterator _Iterator;
+      __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
+    }
+  };
+
+  template <class _ReversibleContainer>
+  struct _ReversibleContainerConcept
+  {
+    typedef typename _ReversibleContainer::const_iterator _Const_iterator;
+    typedef typename _ReversibleContainer::const_reverse_iterator
+      _Const_reverse_iterator;
+
+    void __constraints() {
+      __function_requires< _ForwardContainerConcept<_ReversibleContainer> >();
+      __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >();
+      __function_requires<
+        _BidirectionalIteratorConcept<_Const_reverse_iterator> >();
+
+      const _ReversibleContainer __c;
+      _Const_reverse_iterator __i = __c.rbegin();
+      __i = __c.rend();
+    }
+  };
+
+  template <class _ReversibleContainer>
+  struct _Mutable_ReversibleContainerConcept
+  {
+    typedef typename _ReversibleContainer::iterator _Iterator;
+    typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator;
+
+    void __constraints() {
+      __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >();
+      __function_requires<
+        _Mutable_ForwardContainerConcept<_ReversibleContainer> >();
+      __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >();
+      __function_requires<
+        _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >();
+
+      _Reverse_iterator __i = __c.rbegin();
+      __i = __c.rend();
+    }
+    _ReversibleContainer __c;
+  };
+
+  template <class _RandomAccessContainer>
+  struct _RandomAccessContainerConcept
+  {
+    typedef typename _RandomAccessContainer::size_type _Size_type;
+    typedef typename _RandomAccessContainer::const_reference _Const_reference;
+    typedef typename _RandomAccessContainer::const_iterator _Const_iterator;
+    typedef typename _RandomAccessContainer::const_reverse_iterator
+      _Const_reverse_iterator;
+
+    void __constraints() {
+      __function_requires<
+        _ReversibleContainerConcept<_RandomAccessContainer> >();
+      __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >();
+      __function_requires<
+        _RandomAccessIteratorConcept<_Const_reverse_iterator> >();
+
+      const _RandomAccessContainer __c;
+      _Const_reference __r _IsUnused = __c[__n];
+    }
+    _Size_type __n;
+  };
+
+  template <class _RandomAccessContainer>
+  struct _Mutable_RandomAccessContainerConcept
+  {
+    typedef typename _RandomAccessContainer::size_type _Size_type;
+    typedef typename _RandomAccessContainer::reference _Reference;
+    typedef typename _RandomAccessContainer::iterator _Iterator;
+    typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator;
+
+    void __constraints() {
+      __function_requires<
+        _RandomAccessContainerConcept<_RandomAccessContainer> >();
+      __function_requires<
+        _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >();
+      __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >();
+      __function_requires<
+        _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >();
+
+      _Reference __r _IsUnused = __c[__i];
+    }
+    _Size_type __i;
+    _RandomAccessContainer __c;
+  };
+
+  // A Sequence is inherently mutable
+  template <class _Sequence>
+  struct _SequenceConcept
+  {
+    typedef typename _Sequence::reference _Reference;
+    typedef typename _Sequence::const_reference _Const_reference;
+
+    void __constraints() {
+      // Matt Austern's book puts DefaultConstructible here, the C++
+      // standard places it in Container
+      //    function_requires< DefaultConstructible<Sequence> >();
+      __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
+      __function_requires< _DefaultConstructibleConcept<_Sequence> >();
+
+      _Sequence
+	__c _IsUnused(__n, __t),
+        __c2 _IsUnused(__first, __last);
+
+      __c.insert(__p, __t);
+      __c.insert(__p, __n, __t);
+      __c.insert(__p, __first, __last);
+
+      __c.erase(__p);
+      __c.erase(__p, __q);
+
+      _Reference __r _IsUnused = __c.front();
+
+      __const_constraints(__c);
+    }
+    void __const_constraints(const _Sequence& __c) {
+      _Const_reference __r _IsUnused = __c.front();
+    }
+    typename _Sequence::value_type __t;
+    typename _Sequence::size_type __n;
+    typename _Sequence::value_type *__first, *__last;
+    typename _Sequence::iterator __p, __q;
+  };
+
+  template <class _FrontInsertionSequence>
+  struct _FrontInsertionSequenceConcept
+  {
+    void __constraints() {
+      __function_requires< _SequenceConcept<_FrontInsertionSequence> >();
+
+      __c.push_front(__t);
+      __c.pop_front();
+    }
+    _FrontInsertionSequence __c;
+    typename _FrontInsertionSequence::value_type __t;
+  };
+
+  template <class _BackInsertionSequence>
+  struct _BackInsertionSequenceConcept
+  {
+    typedef typename _BackInsertionSequence::reference _Reference;
+    typedef typename _BackInsertionSequence::const_reference _Const_reference;
+
+    void __constraints() {
+      __function_requires< _SequenceConcept<_BackInsertionSequence> >();
+
+      __c.push_back(__t);
+      __c.pop_back();
+      _Reference __r _IsUnused = __c.back();
+    }
+    void __const_constraints(const _BackInsertionSequence& __c) {
+      _Const_reference __r _IsUnused = __c.back();
+    };
+    _BackInsertionSequence __c;
+    typename _BackInsertionSequence::value_type __t;
+  };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#undef _IsUnused
+
+#endif // _GLIBCXX_BOOST_CONCEPT_CHECK
+
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/c++0x_warning.h b/gcc-4.9/libstdc++-v3/include/bits/c++0x_warning.h
new file mode 100644
index 0000000..3bfba48
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/c++0x_warning.h
@@ -0,0 +1,37 @@
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/c++0x_warning.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iosfwd}
+ */
+
+#ifndef _CXX0X_WARNING_H
+#define _CXX0X_WARNING_H 1
+
+#if __cplusplus < 201103L
+#error This file requires compiler and library support for the \
+ISO C++ 2011 standard. This support is currently experimental, and must be \
+enabled with the -std=c++11 or -std=gnu++11 compiler options.
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/c++14_warning.h b/gcc-4.9/libstdc++-v3/include/bits/c++14_warning.h
new file mode 100644
index 0000000..6bfe435
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/c++14_warning.h
@@ -0,0 +1,37 @@
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/c++14_warning.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iosfwd}
+ */
+
+#ifndef _CXX14_WARNING_H
+#define _CXX14_WARNING_H 1
+
+#if __cplusplus <= 201103L
+#error This file requires compiler and library support for the forthcoming \
+ISO C++ 2014 standard. This support is currently experimental, and must be \
+enabled with the -std=c++1y or -std=gnu++1y compiler options.
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/c++config b/gcc-4.9/libstdc++-v3/include/bits/c++config
new file mode 100644
index 0000000..ff6afc8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/c++config
@@ -0,0 +1,469 @@
+// Predefined symbols and macros -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/c++config.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iosfwd}
+ */
+
+#ifndef _GLIBCXX_CXX_CONFIG_H
+#define _GLIBCXX_CXX_CONFIG_H 1
+
+// The current version of the C++ library in compressed ISO date format.
+#define __GLIBCXX__
+
+// Macros for various attributes.
+//   _GLIBCXX_PURE
+//   _GLIBCXX_CONST
+//   _GLIBCXX_NORETURN
+//   _GLIBCXX_NOTHROW
+//   _GLIBCXX_VISIBILITY
+#ifndef _GLIBCXX_PURE
+# define _GLIBCXX_PURE __attribute__ ((__pure__))
+#endif
+
+#ifndef _GLIBCXX_CONST
+# define _GLIBCXX_CONST __attribute__ ((__const__))
+#endif
+
+#ifndef _GLIBCXX_NORETURN
+# define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))
+#endif
+
+// See below for C++
+#ifndef _GLIBCXX_NOTHROW
+# ifndef __cplusplus
+#  define _GLIBCXX_NOTHROW __attribute__((__nothrow__))
+# endif
+#endif
+
+// Macros for visibility attributes.
+//   _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
+//   _GLIBCXX_VISIBILITY
+#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
+
+#if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
+# define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
+#else
+// If this is not supplied by the OS-specific or CPU-specific
+// headers included below, it will be defined to an empty default.
+# define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V)
+#endif
+
+// Macros for deprecated attributes.
+//   _GLIBCXX_USE_DEPRECATED
+//   _GLIBCXX_DEPRECATED
+#ifndef _GLIBCXX_USE_DEPRECATED
+# define _GLIBCXX_USE_DEPRECATED 1
+#endif
+
+#if defined(__DEPRECATED) && (__cplusplus >= 201103L)
+# define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))
+#else
+# define _GLIBCXX_DEPRECATED
+#endif
+
+// Macros for ABI tag attributes.
+#ifndef _GLIBCXX_ABI_TAG_CXX11
+# define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
+#endif
+
+
+#if __cplusplus
+
+// Macro for constexpr, to support in mixed 03/0x mode.
+#ifndef _GLIBCXX_CONSTEXPR
+# if __cplusplus >= 201103L
+#  define _GLIBCXX_CONSTEXPR constexpr
+#  define _GLIBCXX_USE_CONSTEXPR constexpr
+# else
+#  define _GLIBCXX_CONSTEXPR
+#  define _GLIBCXX_USE_CONSTEXPR const
+# endif
+#endif
+
+// Macro for noexcept, to support in mixed 03/0x mode.
+#ifndef _GLIBCXX_NOEXCEPT
+# if __cplusplus >= 201103L
+#  define _GLIBCXX_NOEXCEPT noexcept
+#  define _GLIBCXX_USE_NOEXCEPT noexcept
+#  define _GLIBCXX_THROW(_EXC)
+# else
+#  define _GLIBCXX_NOEXCEPT
+#  define _GLIBCXX_USE_NOEXCEPT throw()
+#  define _GLIBCXX_THROW(_EXC) throw(_EXC)
+# endif
+#endif
+
+#ifndef _GLIBCXX_NOTHROW
+# define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
+#endif
+
+#ifndef _GLIBCXX_THROW_OR_ABORT
+# if __EXCEPTIONS
+#  define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
+# else
+#  define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort())
+# endif
+#endif
+
+// Macro for extern template, ie controling template linkage via use
+// of extern keyword on template declaration. As documented in the g++
+// manual, it inhibits all implicit instantiations and is used
+// throughout the library to avoid multiple weak definitions for
+// required types that are already explicitly instantiated in the
+// library binary. This substantially reduces the binary size of
+// resulting executables.
+// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
+// templates only in basic_string, thus activating its debug-mode
+// checks even at -O0.
+#define _GLIBCXX_EXTERN_TEMPLATE
+
+/*
+  Outline of libstdc++ namespaces.
+
+  namespace std
+  {
+    namespace __debug { }
+    namespace __parallel { }
+    namespace __profile { }
+    namespace __cxx1998 { }
+
+    namespace __detail { }
+
+    namespace rel_ops { }
+
+    namespace tr1
+    {
+      namespace placeholders { }
+      namespace regex_constants { }
+      namespace __detail { }
+    }
+
+    namespace tr2 { }
+    
+    namespace decimal { }
+
+    namespace chrono { }
+    namespace placeholders { }
+    namespace regex_constants { }
+    namespace this_thread { }
+
+    namespace experimental { }
+  }
+
+  namespace abi { }
+
+  namespace __gnu_cxx
+  {
+    namespace __detail { }
+  }
+
+  For full details see:
+  http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html
+*/
+namespace std
+{
+  typedef __SIZE_TYPE__ 	size_t;
+  typedef __PTRDIFF_TYPE__	ptrdiff_t;
+
+#if __cplusplus >= 201103L
+  typedef decltype(nullptr)	nullptr_t;
+#endif
+}
+
+
+// Defined if inline namespaces are used for versioning.
+#define _GLIBCXX_INLINE_VERSION 
+
+// Inline namespace for symbol versioning.
+#if _GLIBCXX_INLINE_VERSION
+
+namespace std
+{
+  inline namespace __7 { }
+
+  namespace rel_ops { inline namespace __7 { } }
+
+  namespace tr1
+  {
+    inline namespace __7 { }
+    namespace placeholders { inline namespace __7 { } }
+    namespace regex_constants { inline namespace __7 { } }
+    namespace __detail { inline namespace __7 { } }
+  }
+
+  namespace tr2
+  { inline namespace __7 { } }
+
+  namespace decimal { inline namespace __7 { } }
+
+  namespace chrono { inline namespace __7 { } }
+  namespace placeholders { inline namespace __7 { } }
+  namespace regex_constants { inline namespace __7 { } }
+  namespace this_thread { inline namespace __7 { } }
+
+  namespace experimental { inline namespace __7 { } }
+
+  namespace __detail { inline namespace __7 { } }
+}
+
+namespace __gnu_cxx
+{
+  inline namespace __7 { }
+  namespace __detail { inline namespace __7 { } }
+}
+# define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __7 {
+# define _GLIBCXX_END_NAMESPACE_VERSION }
+#else
+# define _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_END_NAMESPACE_VERSION
+#endif
+
+
+// Inline namespaces for special modes: debug, parallel, profile.
+#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) \
+    || defined(_GLIBCXX_PROFILE)
+namespace std
+{
+  // Non-inline namespace for components replaced by alternates in active mode.
+  namespace __cxx1998
+  {
+#if _GLIBCXX_INLINE_VERSION
+ inline namespace __7 { }
+#endif
+  }
+
+  // Inline namespace for debug mode.
+# ifdef _GLIBCXX_DEBUG
+  inline namespace __debug { }
+# endif
+
+  // Inline namespaces for parallel mode.
+# ifdef _GLIBCXX_PARALLEL
+  inline namespace __parallel { }
+# endif
+
+  // Inline namespaces for profile mode
+# ifdef _GLIBCXX_PROFILE
+  inline namespace __profile { }
+# endif
+}
+
+// Check for invalid usage and unsupported mixed-mode use.
+# if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL)
+#  error illegal use of multiple inlined namespaces
+# endif
+# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_DEBUG)
+#  error illegal use of multiple inlined namespaces
+# endif
+# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_PARALLEL)
+#  error illegal use of multiple inlined namespaces
+# endif
+
+// Check for invalid use due to lack for weak symbols.
+# if __NO_INLINE__ && !__GXX_WEAK__
+#  warning currently using inlined namespace mode which may fail \
+   without inlining due to lack of weak symbols
+# endif
+#endif
+
+// Macros for namespace scope. Either namespace std:: or the name
+// of some nested namespace within it corresponding to the active mode.
+// _GLIBCXX_STD_A
+// _GLIBCXX_STD_C
+//
+// Macros for opening/closing conditional namespaces.
+// _GLIBCXX_BEGIN_NAMESPACE_ALGO
+// _GLIBCXX_END_NAMESPACE_ALGO
+// _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+// _GLIBCXX_END_NAMESPACE_CONTAINER
+#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE)
+# define _GLIBCXX_STD_C __cxx1998
+# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \
+	 namespace _GLIBCXX_STD_C { _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_END_NAMESPACE_CONTAINER \
+	 _GLIBCXX_END_NAMESPACE_VERSION }
+# undef _GLIBCXX_EXTERN_TEMPLATE
+# define _GLIBCXX_EXTERN_TEMPLATE -1
+#endif
+
+#ifdef _GLIBCXX_PARALLEL
+# define _GLIBCXX_STD_A __cxx1998
+# define _GLIBCXX_BEGIN_NAMESPACE_ALGO \
+	 namespace _GLIBCXX_STD_A { _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_END_NAMESPACE_ALGO \
+	 _GLIBCXX_END_NAMESPACE_VERSION }
+#endif
+
+#ifndef _GLIBCXX_STD_A
+# define _GLIBCXX_STD_A std
+#endif
+
+#ifndef _GLIBCXX_STD_C
+# define _GLIBCXX_STD_C std
+#endif
+
+#ifndef _GLIBCXX_BEGIN_NAMESPACE_ALGO
+# define _GLIBCXX_BEGIN_NAMESPACE_ALGO
+#endif
+
+#ifndef _GLIBCXX_END_NAMESPACE_ALGO
+# define _GLIBCXX_END_NAMESPACE_ALGO
+#endif
+
+#ifndef _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+#endif
+
+#ifndef _GLIBCXX_END_NAMESPACE_CONTAINER
+# define _GLIBCXX_END_NAMESPACE_CONTAINER
+#endif
+
+// GLIBCXX_ABI Deprecated
+// Define if compatibility should be provided for -mlong-double-64.
+#undef _GLIBCXX_LONG_DOUBLE_COMPAT
+
+// Inline namespace for long double 128 mode.
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+namespace std
+{
+  inline namespace __gnu_cxx_ldbl128 { }
+}
+# define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128::
+# define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 {
+# define _GLIBCXX_END_NAMESPACE_LDBL }
+#else
+# define _GLIBCXX_NAMESPACE_LDBL
+# define _GLIBCXX_BEGIN_NAMESPACE_LDBL
+# define _GLIBCXX_END_NAMESPACE_LDBL
+#endif
+
+// Assert.
+#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PARALLEL)
+# define __glibcxx_assert(_Condition)
+#else
+namespace std
+{
+  // Avoid the use of assert, because we're trying to keep the <cassert>
+  // include out of the mix.
+  inline void
+  __replacement_assert(const char* __file, int __line,
+		       const char* __function, const char* __condition)
+  {
+    __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line,
+		     __function, __condition);
+    __builtin_abort();
+  }
+}
+#define __glibcxx_assert(_Condition)				   	 \
+  do 									 \
+  {							      		 \
+    if (! (_Condition))                                                  \
+      std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
+				#_Condition);				 \
+  } while (false)
+#endif
+
+// Macros for race detectors.
+// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and
+// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain
+// atomic (lock-free) synchronization to race detectors:
+// the race detector will infer a happens-before arc from the former to the
+// latter when they share the same argument pointer.
+//
+// The most frequent use case for these macros (and the only case in the
+// current implementation of the library) is atomic reference counting:
+//   void _M_remove_reference()
+//   {
+//     _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
+//     if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0)
+//       {
+//         _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
+//         _M_destroy(__a);
+//       }
+//   }
+// The annotations in this example tell the race detector that all memory
+// accesses occurred when the refcount was positive do not race with
+// memory accesses which occurred after the refcount became zero.
+#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE
+# define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A)
+#endif
+#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER
+# define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A)
+#endif
+
+// Macros for C linkage: define extern "C" linkage only when using C++.
+# define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
+# define _GLIBCXX_END_EXTERN_C }
+
+#else // !__cplusplus
+# define _GLIBCXX_BEGIN_EXTERN_C
+# define _GLIBCXX_END_EXTERN_C
+#endif
+
+
+// First includes.
+
+// Pick up any OS-specific definitions.
+#include <bits/os_defines.h>
+
+// Pick up any CPU-specific definitions.
+#include <bits/cpu_defines.h>
+
+// If platform uses neither visibility nor psuedo-visibility,
+// specify empty default for namespace annotation macros.
+#ifndef _GLIBCXX_PSEUDO_VISIBILITY
+# define _GLIBCXX_PSEUDO_VISIBILITY(V)
+#endif
+
+// Certain function definitions that are meant to be overridable from
+// user code are decorated with this macro.  For some targets, this
+// macro causes these definitions to be weak.
+#ifndef _GLIBCXX_WEAK_DEFINITION
+# define _GLIBCXX_WEAK_DEFINITION
+#endif
+
+
+// The remainder of the prewritten config is automatic; all the
+// user hooks are listed above.
+
+// Create a boolean flag to be used to determine if --fast-math is set.
+#ifdef __FAST_MATH__
+# define _GLIBCXX_FAST_MATH 1
+#else
+# define _GLIBCXX_FAST_MATH 0
+#endif
+
+// This marks string literals in header files to be extracted for eventual
+// translation.  It is primarily used for messages in thrown exceptions; see
+// src/functexcept.cc.  We use __N because the more traditional _N is used
+// for something else under certain OSes (see BADNAMES).
+#define __N(msgid)     (msgid)
+
+// For example, <windows.h> is known to #define min and max as macros...
+#undef min
+#undef max
+
+// End of prewritten config; the settings discovered at configure time follow.
diff --git a/gcc-4.9/libstdc++-v3/include/bits/char_traits.h b/gcc-4.9/libstdc++-v3/include/bits/char_traits.h
new file mode 100644
index 0000000..8c3bf96
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/char_traits.h
@@ -0,0 +1,577 @@
+// Character Traits for use by standard string and iostream -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/char_traits.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{string}
+ */
+
+//
+// ISO C++ 14882: 21  Strings library
+//
+
+#ifndef _CHAR_TRAITS_H
+#define _CHAR_TRAITS_H 1
+
+#pragma GCC system_header
+
+#include <bits/stl_algobase.h>  // std::copy, std::fill_n
+#include <bits/postypes.h>      // For streampos
+#include <cwchar>               // For WEOF, wmemmove, wmemset, etc.
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Mapping from character type to associated types.
+   *
+   *  @note This is an implementation class for the generic version
+   *  of char_traits.  It defines int_type, off_type, pos_type, and
+   *  state_type.  By default these are unsigned long, streamoff,
+   *  streampos, and mbstate_t.  Users who need a different set of
+   *  types, but who don't need to change the definitions of any function
+   *  defined in char_traits, can specialize __gnu_cxx::_Char_types
+   *  while leaving __gnu_cxx::char_traits alone. */
+  template<typename _CharT>
+    struct _Char_types
+    {
+      typedef unsigned long   int_type;
+      typedef std::streampos  pos_type;
+      typedef std::streamoff  off_type;
+      typedef std::mbstate_t  state_type;
+    };
+
+
+  /**
+   *  @brief  Base class used to implement std::char_traits.
+   *
+   *  @note For any given actual character type, this definition is
+   *  probably wrong.  (Most of the member functions are likely to be
+   *  right, but the int_type and state_type typedefs, and the eof()
+   *  member function, are likely to be wrong.)  The reason this class
+   *  exists is so users can specialize it.  Classes in namespace std
+   *  may not be specialized for fundamental types, but classes in
+   *  namespace __gnu_cxx may be.
+   *
+   *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
+   *  for advice on how to make use of this class for @a unusual character
+   *  types. Also, check out include/ext/pod_char_traits.h.  
+   */
+  template<typename _CharT>
+    struct char_traits
+    {
+      typedef _CharT                                    char_type;
+      typedef typename _Char_types<_CharT>::int_type    int_type;
+      typedef typename _Char_types<_CharT>::pos_type    pos_type;
+      typedef typename _Char_types<_CharT>::off_type    off_type;
+      typedef typename _Char_types<_CharT>::state_type  state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static _GLIBCXX_CONSTEXPR bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static _GLIBCXX_CONSTEXPR bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static std::size_t
+      length(const char_type* __s);
+
+      static const char_type*
+      find(const char_type* __s, std::size_t __n, const char_type& __a);
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      assign(char_type* __s, std::size_t __n, char_type __a);
+
+      static _GLIBCXX_CONSTEXPR char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(__c); }
+
+      static _GLIBCXX_CONSTEXPR bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      eof()
+      { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      not_eof(const int_type& __c)
+      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
+    };
+
+  template<typename _CharT>
+    int
+    char_traits<_CharT>::
+    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+	if (lt(__s1[__i], __s2[__i]))
+	  return -1;
+	else if (lt(__s2[__i], __s1[__i]))
+	  return 1;
+      return 0;
+    }
+
+  template<typename _CharT>
+    std::size_t
+    char_traits<_CharT>::
+    length(const char_type* __p)
+    {
+      std::size_t __i = 0;
+      while (!eq(__p[__i], char_type()))
+        ++__i;
+      return __i;
+    }
+
+  template<typename _CharT>
+    const typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    find(const char_type* __s, std::size_t __n, const char_type& __a)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+        if (eq(__s[__i], __a))
+          return __s + __i;
+      return 0;
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    move(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
+						    __n * sizeof(char_type)));
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      // NB: Inline std::copy so no recursive dependencies.
+      std::copy(__s2, __s2 + __n, __s1);
+      return __s1;
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    assign(char_type* __s, std::size_t __n, char_type __a)
+    {
+      // NB: Inline std::fill_n so no recursive dependencies.
+      std::fill_n(__s, __n, __a);
+      return __s;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 21.1
+  /**
+   *  @brief  Basis for explicit traits specializations.
+   *
+   *  @note  For any given actual character type, this definition is
+   *  probably wrong.  Since this is just a thin wrapper around
+   *  __gnu_cxx::char_traits, it is possible to achieve a more
+   *  appropriate definition by specializing __gnu_cxx::char_traits.
+   *
+   *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
+   *  for advice on how to make use of this class for @a unusual character
+   *  types. Also, check out include/ext/pod_char_traits.h.
+  */
+  template<class _CharT>
+    struct char_traits : public __gnu_cxx::char_traits<_CharT>
+    { };
+
+
+  /// 21.1.3.1  char_traits specializations
+  template<>
+    struct char_traits<char>
+    {
+      typedef char              char_type;
+      typedef int               int_type;
+      typedef streampos         pos_type;
+      typedef streamoff         off_type;
+      typedef mbstate_t         state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
+      { __c1 = __c2; }
+
+      static _GLIBCXX_CONSTEXPR bool
+      eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
+      { return __c1 == __c2; }
+
+      static _GLIBCXX_CONSTEXPR bool
+      lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
+      {
+	// LWG 467.
+	return (static_cast<unsigned char>(__c1)
+		< static_cast<unsigned char>(__c2));
+      }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      { return __builtin_memcmp(__s1, __s2, __n); }
+
+      static size_t
+      length(const char_type* __s)
+      { return __builtin_strlen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
+
+      static _GLIBCXX_CONSTEXPR char_type
+      to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
+      { return static_cast<char_type>(__c); }
+
+      // To keep both the byte 0xff and the eof symbol 0xffffffff
+      // from ending up as 0xffffffff.
+      static _GLIBCXX_CONSTEXPR int_type
+      to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
+      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
+
+      static _GLIBCXX_CONSTEXPR bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
+      { return __c1 == __c2; }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      eof() _GLIBCXX_NOEXCEPT
+      { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
+      { return (__c == eof()) ? 0 : __c; }
+  };
+
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /// 21.1.3.2  char_traits specializations
+  template<>
+    struct char_traits<wchar_t>
+    {
+      typedef wchar_t           char_type;
+      typedef wint_t            int_type;
+      typedef streamoff         off_type;
+      typedef wstreampos        pos_type;
+      typedef mbstate_t         state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
+      { __c1 = __c2; }
+
+      static _GLIBCXX_CONSTEXPR bool
+      eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
+      { return __c1 == __c2; }
+
+      static _GLIBCXX_CONSTEXPR bool
+      lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemcmp(__s1, __s2, __n); }
+
+      static size_t
+      length(const char_type* __s)
+      { return wcslen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      { return wmemchr(__s, __a, __n); }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemmove(__s1, __s2, __n); }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemcpy(__s1, __s2, __n); }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      { return wmemset(__s, __a, __n); }
+
+      static _GLIBCXX_CONSTEXPR char_type
+      to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
+      { return char_type(__c); }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
+      { return int_type(__c); }
+
+      static _GLIBCXX_CONSTEXPR bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
+      { return __c1 == __c2; }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      eof() _GLIBCXX_NOEXCEPT
+      { return static_cast<int_type>(WEOF); }
+
+      static _GLIBCXX_CONSTEXPR int_type
+      not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+  };
+#endif //_GLIBCXX_USE_WCHAR_T
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if ((__cplusplus >= 201103L) \
+     && defined(_GLIBCXX_USE_C99_STDINT_TR1))
+
+#include <cstdint>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<>
+    struct char_traits<char16_t>
+    {
+      typedef char16_t          char_type;
+      typedef uint_least16_t    int_type;
+      typedef streamoff         off_type;
+      typedef u16streampos      pos_type;
+      typedef mbstate_t         state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+	for (size_t __i = 0; __i < __n; ++__i)
+	  if (lt(__s1[__i], __s2[__i]))
+	    return -1;
+	  else if (lt(__s2[__i], __s1[__i]))
+	    return 1;
+	return 0;
+      }
+
+      static size_t
+      length(const char_type* __s)
+      {
+	size_t __i = 0;
+	while (!eq(__s[__i], char_type()))
+	  ++__i;
+	return __i;
+      }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+	for (size_t __i = 0; __i < __n; ++__i)
+	  if (eq(__s[__i], __a))
+	    return __s + __i;
+	return 0;
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+	return (static_cast<char_type*>
+		(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+	return (static_cast<char_type*>
+		(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+	for (size_t __i = 0; __i < __n; ++__i)
+	  assign(__s[__i], __a);
+	return __s;
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+
+  template<>
+    struct char_traits<char32_t>
+    {
+      typedef char32_t          char_type;
+      typedef uint_least32_t    int_type;
+      typedef streamoff         off_type;
+      typedef u32streampos      pos_type;
+      typedef mbstate_t         state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+	for (size_t __i = 0; __i < __n; ++__i)
+	  if (lt(__s1[__i], __s2[__i]))
+	    return -1;
+	  else if (lt(__s2[__i], __s1[__i]))
+	    return 1;
+	return 0;
+      }
+
+      static size_t
+      length(const char_type* __s)
+      {
+	size_t __i = 0;
+	while (!eq(__s[__i], char_type()))
+	  ++__i;
+	return __i;
+      }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+	for (size_t __i = 0; __i < __n; ++__i)
+	  if (eq(__s[__i], __a))
+	    return __s + __i;
+	return 0;
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+	return (static_cast<char_type*>
+		(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      { 
+	return (static_cast<char_type*>
+		(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+	for (size_t __i = 0; __i < __n; ++__i)
+	  assign(__s[__i], __a);
+	return __s;
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif 
+
+#endif // _CHAR_TRAITS_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/codecvt.h b/gcc-4.9/libstdc++-v3/include/bits/codecvt.h
new file mode 100644
index 0000000..5002a55
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/codecvt.h
@@ -0,0 +1,507 @@
+// Locale support (codecvt) -*- C++ -*-
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/codecvt.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+//
+// ISO C++ 14882: 22.2.1.5 Template class codecvt
+//
+
+// Written by Benjamin Kosnik <bkoz@redhat.com>
+
+#ifndef _CODECVT_H
+#define _CODECVT_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// Empty base class for codecvt facet [22.2.1.5].
+  class codecvt_base
+  {
+  public:
+    enum result
+    {
+      ok,
+      partial,
+      error,
+      noconv
+    };
+  };
+
+  /**
+   *  @brief  Common base for codecvt functions.
+   *
+   *  This template class provides implementations of the public functions
+   *  that forward to the protected virtual functions.
+   *
+   *  This template also provides abstract stubs for the protected virtual
+   *  functions.
+  */
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class __codecvt_abstract_base
+    : public locale::facet, public codecvt_base
+    {
+    public:
+      // Types:
+      typedef codecvt_base::result	result;
+      typedef _InternT			intern_type;
+      typedef _ExternT			extern_type;
+      typedef _StateT			state_type;
+
+      // 22.2.1.5.1 codecvt members
+      /**
+       *  @brief  Convert from internal to external character set.
+       *
+       *  Converts input string of intern_type to output string of
+       *  extern_type.  This is analogous to wcsrtombs.  It does this by
+       *  calling codecvt::do_out.
+       *
+       *  The source and destination character sets are determined by the
+       *  facet's locale, internal and external types.
+       *
+       *  The characters in [from,from_end) are converted and written to
+       *  [to,to_end).  from_next and to_next are set to point to the
+       *  character following the last successfully converted character,
+       *  respectively.  If the result needed no conversion, from_next and
+       *  to_next are not affected.
+       *
+       *  The @a state argument should be initialized if the input is at the
+       *  beginning and carried from a previous call if continuing
+       *  conversion.  There are no guarantees about how @a state is used.
+       *
+       *  The result returned is a member of codecvt_base::result.  If
+       *  all the input is converted, returns codecvt_base::ok.  If no
+       *  conversion is necessary, returns codecvt_base::noconv.  If
+       *  the input ends early or there is insufficient space in the
+       *  output, returns codecvt_base::partial.  Otherwise the
+       *  conversion failed and codecvt_base::error is returned.
+       *
+       *  @param  __state  Persistent conversion state data.
+       *  @param  __from  Start of input.
+       *  @param  __from_end  End of input.
+       *  @param  __from_next  Returns start of unconverted data.
+       *  @param  __to  Start of output buffer.
+       *  @param  __to_end  End of output buffer.
+       *  @param  __to_next  Returns start of unused output area.
+       *  @return  codecvt_base::result.
+      */
+      result
+      out(state_type& __state, const intern_type* __from,
+	  const intern_type* __from_end, const intern_type*& __from_next,
+	  extern_type* __to, extern_type* __to_end,
+	  extern_type*& __to_next) const
+      {
+	return this->do_out(__state, __from, __from_end, __from_next,
+			    __to, __to_end, __to_next);
+      }
+
+      /**
+       *  @brief  Reset conversion state.
+       *
+       *  Writes characters to output that would restore @a state to initial
+       *  conditions.  The idea is that if a partial conversion occurs, then
+       *  the converting the characters written by this function would leave
+       *  the state in initial conditions, rather than partial conversion
+       *  state.  It does this by calling codecvt::do_unshift().
+       *
+       *  For example, if 4 external characters always converted to 1 internal
+       *  character, and input to in() had 6 external characters with state
+       *  saved, this function would write two characters to the output and
+       *  set the state to initialized conditions.
+       *
+       *  The source and destination character sets are determined by the
+       *  facet's locale, internal and external types.
+       *
+       *  The result returned is a member of codecvt_base::result.  If the
+       *  state could be reset and data written, returns codecvt_base::ok.  If
+       *  no conversion is necessary, returns codecvt_base::noconv.  If the
+       *  output has insufficient space, returns codecvt_base::partial.
+       *  Otherwise the reset failed and codecvt_base::error is returned.
+       *
+       *  @param  __state  Persistent conversion state data.
+       *  @param  __to  Start of output buffer.
+       *  @param  __to_end  End of output buffer.
+       *  @param  __to_next  Returns start of unused output area.
+       *  @return  codecvt_base::result.
+      */
+      result
+      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
+	      extern_type*& __to_next) const
+      { return this->do_unshift(__state, __to,__to_end,__to_next); }
+
+      /**
+       *  @brief  Convert from external to internal character set.
+       *
+       *  Converts input string of extern_type to output string of
+       *  intern_type.  This is analogous to mbsrtowcs.  It does this by
+       *  calling codecvt::do_in.
+       *
+       *  The source and destination character sets are determined by the
+       *  facet's locale, internal and external types.
+       *
+       *  The characters in [from,from_end) are converted and written to
+       *  [to,to_end).  from_next and to_next are set to point to the
+       *  character following the last successfully converted character,
+       *  respectively.  If the result needed no conversion, from_next and
+       *  to_next are not affected.
+       *
+       *  The @a state argument should be initialized if the input is at the
+       *  beginning and carried from a previous call if continuing
+       *  conversion.  There are no guarantees about how @a state is used.
+       *
+       *  The result returned is a member of codecvt_base::result.  If
+       *  all the input is converted, returns codecvt_base::ok.  If no
+       *  conversion is necessary, returns codecvt_base::noconv.  If
+       *  the input ends early or there is insufficient space in the
+       *  output, returns codecvt_base::partial.  Otherwise the
+       *  conversion failed and codecvt_base::error is returned.
+       *
+       *  @param  __state  Persistent conversion state data.
+       *  @param  __from  Start of input.
+       *  @param  __from_end  End of input.
+       *  @param  __from_next  Returns start of unconverted data.
+       *  @param  __to  Start of output buffer.
+       *  @param  __to_end  End of output buffer.
+       *  @param  __to_next  Returns start of unused output area.
+       *  @return  codecvt_base::result.
+      */
+      result
+      in(state_type& __state, const extern_type* __from,
+	 const extern_type* __from_end, const extern_type*& __from_next,
+	 intern_type* __to, intern_type* __to_end,
+	 intern_type*& __to_next) const
+      {
+	return this->do_in(__state, __from, __from_end, __from_next,
+			   __to, __to_end, __to_next);
+      }
+
+      int
+      encoding() const throw()
+      { return this->do_encoding(); }
+
+      bool
+      always_noconv() const throw()
+      { return this->do_always_noconv(); }
+
+      int
+      length(state_type& __state, const extern_type* __from,
+	     const extern_type* __end, size_t __max) const
+      { return this->do_length(__state, __from, __end, __max); }
+
+      int
+      max_length() const throw()
+      { return this->do_max_length(); }
+
+    protected:
+      explicit
+      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
+
+      virtual
+      ~__codecvt_abstract_base() { }
+
+      /**
+       *  @brief  Convert from internal to external character set.
+       *
+       *  Converts input string of intern_type to output string of
+       *  extern_type.  This function is a hook for derived classes to change
+       *  the value returned.  @see out for more information.
+      */
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+	     const intern_type* __from_end, const intern_type*& __from_next,
+	     extern_type* __to, extern_type* __to_end,
+	     extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+		 extern_type* __to_end, extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+	    const extern_type* __from_end, const extern_type*& __from_next,
+	    intern_type* __to, intern_type* __to_end,
+	    intern_type*& __to_next) const = 0;
+
+      virtual int
+      do_encoding() const throw() = 0;
+
+      virtual bool
+      do_always_noconv() const throw() = 0;
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+		const extern_type* __end, size_t __max) const = 0;
+
+      virtual int
+      do_max_length() const throw() = 0;
+    };
+
+
+
+  /**
+   *  @brief  Primary class template codecvt.
+   *  @ingroup locales
+   *
+   *  NB: Generic, mostly useless implementation.
+   *
+  */
+   template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt
+    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
+    {
+    public:
+      // Types:
+      typedef codecvt_base::result	result;
+      typedef _InternT			intern_type;
+      typedef _ExternT			extern_type;
+      typedef _StateT			state_type;
+
+    protected:
+      __c_locale			_M_c_locale_codecvt;
+
+    public:
+      static locale::id			id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
+	_M_c_locale_codecvt(0)
+      { }
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt() { }
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+	     const intern_type* __from_end, const intern_type*& __from_next,
+	     extern_type* __to, extern_type* __to_end,
+	     extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+		 extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+	    const extern_type* __from_end, const extern_type*& __from_next,
+	    intern_type* __to, intern_type* __to_end,
+	    intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+		const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    locale::id codecvt<_InternT, _ExternT, _StateT>::id;
+
+  /// class codecvt<char, char, mbstate_t> specialization.
+  template<>
+    class codecvt<char, char, mbstate_t>
+    : public __codecvt_abstract_base<char, char, mbstate_t>
+    {
+    public:
+      // Types:
+      typedef char			intern_type;
+      typedef char			extern_type;
+      typedef mbstate_t			state_type;
+
+    protected:
+      __c_locale			_M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+	     const intern_type* __from_end, const intern_type*& __from_next,
+	     extern_type* __to, extern_type* __to_end,
+	     extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+		 extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+	    const extern_type* __from_end, const extern_type*& __from_next,
+	    intern_type* __to, intern_type* __to_end,
+	    intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+		const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+  };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /// class codecvt<wchar_t, char, mbstate_t> specialization.
+  template<>
+    class codecvt<wchar_t, char, mbstate_t>
+    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
+    {
+    public:
+      // Types:
+      typedef wchar_t			intern_type;
+      typedef char			extern_type;
+      typedef mbstate_t			state_type;
+
+    protected:
+      __c_locale			_M_c_locale_codecvt;
+
+    public:
+      static locale::id			id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+	     const intern_type* __from_end, const intern_type*& __from_next,
+	     extern_type* __to, extern_type* __to_end,
+	     extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+		 extern_type* __to, extern_type* __to_end,
+		 extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+	     const extern_type* __from, const extern_type* __from_end,
+	     const extern_type*& __from_next,
+	     intern_type* __to, intern_type* __to_end,
+	     intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+		    const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+#endif //_GLIBCXX_USE_WCHAR_T
+
+  /// class codecvt_byname [22.2.1.6].
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
+    {
+    public:
+      explicit
+      codecvt_byname(const char* __s, size_t __refs = 0)
+      : codecvt<_InternT, _ExternT, _StateT>(__refs)
+      {
+	if (__builtin_strcmp(__s, "C") != 0
+	    && __builtin_strcmp(__s, "POSIX") != 0)
+	  {
+	    this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
+	    this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
+	  }
+      }
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class codecvt_byname<char, char, mbstate_t>;
+
+  extern template
+    const codecvt<char, char, mbstate_t>&
+    use_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
+
+  extern template
+    const codecvt<wchar_t, char, mbstate_t>&
+    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // _CODECVT_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/concept_check.h b/gcc-4.9/libstdc++-v3/include/bits/concept_check.h
new file mode 100644
index 0000000..eb5b794
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/concept_check.h
@@ -0,0 +1,80 @@
+// Concept-checking control -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/concept_check.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ */
+
+#ifndef _CONCEPT_CHECK_H
+#define _CONCEPT_CHECK_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+// All places in libstdc++-v3 where these are used, or /might/ be used, or
+// don't need to be used, or perhaps /should/ be used, are commented with
+// "concept requirements" (and maybe some more text).  So grep like crazy
+// if you're looking for additional places to use these.
+
+// Concept-checking code is off by default unless users turn it on via
+// configure options or editing c++config.h.
+
+#ifndef _GLIBCXX_CONCEPT_CHECKS
+
+#define __glibcxx_function_requires(...)
+#define __glibcxx_class_requires(_a,_b)
+#define __glibcxx_class_requires2(_a,_b,_c)
+#define __glibcxx_class_requires3(_a,_b,_c,_d)
+#define __glibcxx_class_requires4(_a,_b,_c,_d,_e)
+
+#else // the checks are on
+
+#include <bits/boost_concept_check.h>
+
+// Note that the obvious and elegant approach of
+//
+//#define glibcxx_function_requires(C) debug::function_requires< debug::C >()
+//
+// won't work due to concept templates with more than one parameter, e.g.,
+// BinaryPredicateConcept.  The preprocessor tries to split things up on
+// the commas in the template argument list.  We can't use an inner pair of
+// parenthesis to hide the commas, because "debug::(Temp<Foo,Bar>)" isn't
+// a valid instantiation pattern.  Thus, we steal a feature from C99.
+
+#define __glibcxx_function_requires(...)                                 \
+            __gnu_cxx::__function_requires< __gnu_cxx::__VA_ARGS__ >();
+#define __glibcxx_class_requires(_a,_C)                                  \
+            _GLIBCXX_CLASS_REQUIRES(_a, __gnu_cxx, _C);
+#define __glibcxx_class_requires2(_a,_b,_C)                              \
+            _GLIBCXX_CLASS_REQUIRES2(_a, _b, __gnu_cxx, _C);
+#define __glibcxx_class_requires3(_a,_b,_c,_C)                           \
+            _GLIBCXX_CLASS_REQUIRES3(_a, _b, _c, __gnu_cxx, _C);
+#define __glibcxx_class_requires4(_a,_b,_c,_d,_C)                        \
+            _GLIBCXX_CLASS_REQUIRES4(_a, _b, _c, _d, __gnu_cxx, _C);
+
+#endif // enable/disable
+
+#endif // _GLIBCXX_CONCEPT_CHECK
diff --git a/gcc-4.9/libstdc++-v3/include/bits/cpp_type_traits.h b/gcc-4.9/libstdc++-v3/include/bits/cpp_type_traits.h
new file mode 100644
index 0000000..8df81a7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/cpp_type_traits.h
@@ -0,0 +1,416 @@
+// The  -*- C++ -*- type traits classes for internal use in libstdc++
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/cpp_type_traits.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/type_traits}
+ */
+
+// Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
+
+#ifndef _CPP_TYPE_TRAITS_H
+#define _CPP_TYPE_TRAITS_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+//
+// This file provides some compile-time information about various types.
+// These representations were designed, on purpose, to be constant-expressions
+// and not types as found in <bits/type_traits.h>.  In particular, they
+// can be used in control structures and the optimizer hopefully will do
+// the obvious thing.
+//
+// Why integral expressions, and not functions nor types?
+// Firstly, these compile-time entities are used as template-arguments
+// so function return values won't work:  We need compile-time entities.
+// We're left with types and constant  integral expressions.
+// Secondly, from the point of view of ease of use, type-based compile-time
+// information is -not- *that* convenient.  On has to write lots of
+// overloaded functions and to hope that the compiler will select the right
+// one. As a net effect, the overall structure isn't very clear at first
+// glance.
+// Thirdly, partial ordering and overload resolution (of function templates)
+// is highly costly in terms of compiler-resource.  It is a Good Thing to
+// keep these resource consumption as least as possible.
+//
+// See valarray_array.h for a case use.
+//
+// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
+//
+// Update 2005: types are also provided and <bits/type_traits.h> has been
+// removed.
+//
+
+// Forward declaration hack, should really include this from somewhere.
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  struct __true_type { };
+  struct __false_type { };
+
+  template<bool>
+    struct __truth_type
+    { typedef __false_type __type; };
+
+  template<>
+    struct __truth_type<true>
+    { typedef __true_type __type; };
+
+  // N.B. The conversions to bool are needed due to the issue
+  // explained in c++/19404.
+  template<class _Sp, class _Tp>
+    struct __traitor
+    {
+      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
+      typedef typename __truth_type<__value>::__type __type;
+    };
+
+  // Compare for equality of types.
+  template<typename, typename>
+    struct __are_same
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Tp>
+    struct __are_same<_Tp, _Tp>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  // Holds if the template-argument is a void type.
+  template<typename _Tp>
+    struct __is_void
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_void<void>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  //
+  // Integer types
+  //
+  template<typename _Tp>
+    struct __is_integer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  // Thirteen specializations (yes there are eleven standard integer
+  // types; <em>long long</em> and <em>unsigned long long</em> are
+  // supported as extensions)
+  template<>
+    struct __is_integer<bool>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+# ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    struct __is_integer<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+# endif
+
+#if __cplusplus >= 201103L
+  template<>
+    struct __is_integer<char16_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<char32_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+#endif
+
+  template<>
+    struct __is_integer<short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  //
+  // Floating point types
+  //
+  template<typename _Tp>
+    struct __is_floating
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  // three specializations (float, double and 'long double')
+  template<>
+    struct __is_floating<float>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_floating<double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_floating<long double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  //
+  // Pointer types
+  //
+  template<typename _Tp>
+    struct __is_pointer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Tp>
+    struct __is_pointer<_Tp*>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  //
+  // Normal iterator type
+  //
+  template<typename _Tp>
+    struct __is_normal_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Iterator, typename _Container>
+    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
+							      _Container> >
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  //
+  // An arithmetic type is an integer type or a floating point type
+  //
+  template<typename _Tp>
+    struct __is_arithmetic
+    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
+    { };
+
+  //
+  // A scalar type is an arithmetic type or a pointer type
+  // 
+  template<typename _Tp>
+    struct __is_scalar
+    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
+    { };
+
+  //
+  // For use in std::copy and std::find overloads for streambuf iterators.
+  //
+  template<typename _Tp>
+    struct __is_char
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_char<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    struct __is_char<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+#endif
+
+  template<typename _Tp>
+    struct __is_byte
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_byte<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_byte<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_byte<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  //
+  // Move iterator type
+  //
+  template<typename _Tp>
+    struct __is_move_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+#if __cplusplus >= 201103L
+  template<typename _Iterator>
+    class move_iterator;
+
+  template<typename _Iterator>
+    struct __is_move_iterator< move_iterator<_Iterator> >
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif //_CPP_TYPE_TRAITS_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/deque.tcc b/gcc-4.9/libstdc++-v3/include/bits/deque.tcc
new file mode 100644
index 0000000..ebf5d3a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/deque.tcc
@@ -0,0 +1,1073 @@
+// Deque implementation (out of line) -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/deque.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{deque}
+ */
+
+#ifndef _DEQUE_TCC
+#define _DEQUE_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+#if __cplusplus >= 201103L
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_default_initialize()
+    {
+      _Map_pointer __cur;
+      __try
+        {
+          for (__cur = this->_M_impl._M_start._M_node;
+	       __cur < this->_M_impl._M_finish._M_node;
+	       ++__cur)
+            std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
+					   _M_get_Tp_allocator());
+          std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
+					 this->_M_impl._M_finish._M_cur,
+					 _M_get_Tp_allocator());
+        }
+      __catch(...)
+        {
+          std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+			_M_get_Tp_allocator());
+          __throw_exception_again;
+        }
+    }
+#endif
+
+  template <typename _Tp, typename _Alloc>
+    deque<_Tp, _Alloc>&
+    deque<_Tp, _Alloc>::
+    operator=(const deque& __x)
+    {
+      const size_type __len = size();
+      if (&__x != this)
+	{
+	  if (__len >= __x.size())
+	    _M_erase_at_end(std::copy(__x.begin(), __x.end(),
+				      this->_M_impl._M_start));
+	  else
+	    {
+	      const_iterator __mid = __x.begin() + difference_type(__len);
+	      std::copy(__x.begin(), __mid, this->_M_impl._M_start);
+	      insert(this->_M_impl._M_finish, __mid, __x.end());
+	    }
+	}
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      emplace_front(_Args&&... __args)
+      {
+	if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
+	  {
+	    this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1,
+				    std::forward<_Args>(__args)...);
+	    --this->_M_impl._M_start._M_cur;
+	  }
+	else
+	  _M_push_front_aux(std::forward<_Args>(__args)...);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      emplace_back(_Args&&... __args)
+      {
+	if (this->_M_impl._M_finish._M_cur
+	    != this->_M_impl._M_finish._M_last - 1)
+	  {
+	    this->_M_impl.construct(this->_M_impl._M_finish._M_cur,
+				    std::forward<_Args>(__args)...);
+	    ++this->_M_impl._M_finish._M_cur;
+	  }
+	else
+	  _M_push_back_aux(std::forward<_Args>(__args)...);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      emplace(const_iterator __position, _Args&&... __args)
+      {
+	if (__position._M_cur == this->_M_impl._M_start._M_cur)
+	  {
+	    emplace_front(std::forward<_Args>(__args)...);
+	    return this->_M_impl._M_start;
+	  }
+	else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
+	  {
+	    emplace_back(std::forward<_Args>(__args)...);
+	    iterator __tmp = this->_M_impl._M_finish;
+	    --__tmp;
+	    return __tmp;
+	  }
+	else
+	  return _M_insert_aux(__position._M_const_cast(),
+			       std::forward<_Args>(__args)...);
+      }
+#endif
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+#if __cplusplus >= 201103L
+    insert(const_iterator __position, const value_type& __x)
+#else
+    insert(iterator __position, const value_type& __x)
+#endif
+    {
+      if (__position._M_cur == this->_M_impl._M_start._M_cur)
+	{
+	  push_front(__x);
+	  return this->_M_impl._M_start;
+	}
+      else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
+	{
+	  push_back(__x);
+	  iterator __tmp = this->_M_impl._M_finish;
+	  --__tmp;
+	  return __tmp;
+	}
+      else
+	return _M_insert_aux(__position._M_const_cast(), __x);
+   }
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      iterator __next = __position;
+      ++__next;
+      const difference_type __index = __position - begin();
+      if (static_cast<size_type>(__index) < (size() >> 1))
+	{
+	  if (__position != begin())
+	    _GLIBCXX_MOVE_BACKWARD3(begin(), __position, __next);
+	  pop_front();
+	}
+      else
+	{
+	  if (__next != end())
+	    _GLIBCXX_MOVE3(__next, end(), __position);
+	  pop_back();
+	}
+      return begin() + __index;
+    }
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first == __last)
+	return __first;
+      else if (__first == begin() && __last == end())
+	{
+	  clear();
+	  return end();
+	}
+      else
+	{
+	  const difference_type __n = __last - __first;
+	  const difference_type __elems_before = __first - begin();
+	  if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
+	    {
+	      if (__first != begin())
+		_GLIBCXX_MOVE_BACKWARD3(begin(), __first, __last);
+	      _M_erase_at_begin(begin() + __n);
+	    }
+	  else
+	    {
+	      if (__last != end())
+		_GLIBCXX_MOVE3(__last, end(), __first);
+	      _M_erase_at_end(end() - __n);
+	    }
+	  return begin() + __elems_before;
+	}
+    }
+
+  template <typename _Tp, class _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+		    std::input_iterator_tag)
+      {
+        iterator __cur = begin();
+        for (; __first != __last && __cur != end(); ++__cur, ++__first)
+          *__cur = *__first;
+        if (__first == __last)
+          _M_erase_at_end(__cur);
+        else
+          insert(end(), __first, __last);
+      }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
+    {
+      if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+	{
+	  iterator __new_start = _M_reserve_elements_at_front(__n);
+	  __try
+	    {
+	      std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
+					  __x, _M_get_Tp_allocator());
+	      this->_M_impl._M_start = __new_start;
+	    }
+	  __catch(...)
+	    {
+	      _M_destroy_nodes(__new_start._M_node,
+			       this->_M_impl._M_start._M_node);
+	      __throw_exception_again;
+	    }
+	}
+      else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+	{
+	  iterator __new_finish = _M_reserve_elements_at_back(__n);
+	  __try
+	    {
+	      std::__uninitialized_fill_a(this->_M_impl._M_finish,
+					  __new_finish, __x,
+					  _M_get_Tp_allocator());
+	      this->_M_impl._M_finish = __new_finish;
+	    }
+	  __catch(...)
+	    {
+	      _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+			       __new_finish._M_node + 1);
+	      __throw_exception_again;
+	    }
+	}
+      else
+        _M_insert_aux(__pos, __n, __x);
+    }
+
+#if __cplusplus >= 201103L
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      if (__n)
+	{
+	  iterator __new_finish = _M_reserve_elements_at_back(__n);
+	  __try
+	    {
+	      std::__uninitialized_default_a(this->_M_impl._M_finish,
+					     __new_finish,
+					     _M_get_Tp_allocator());
+	      this->_M_impl._M_finish = __new_finish;
+	    }
+	  __catch(...)
+	    {
+	      _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+			       __new_finish._M_node + 1);
+	      __throw_exception_again;
+	    }
+	}
+    }
+
+  template <typename _Tp, typename _Alloc>
+    bool
+    deque<_Tp, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      const difference_type __front_capacity
+	= (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first);
+      if (__front_capacity == 0)
+	return false;
+
+      const difference_type __back_capacity
+	= (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur);
+      if (__front_capacity + __back_capacity < _S_buffer_size())
+	return false;
+
+      return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
+    }
+#endif
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_initialize(const value_type& __value)
+    {
+      _Map_pointer __cur;
+      __try
+        {
+          for (__cur = this->_M_impl._M_start._M_node;
+	       __cur < this->_M_impl._M_finish._M_node;
+	       ++__cur)
+            std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
+					__value, _M_get_Tp_allocator());
+          std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
+				      this->_M_impl._M_finish._M_cur,
+				      __value, _M_get_Tp_allocator());
+        }
+      __catch(...)
+        {
+          std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+			_M_get_Tp_allocator());
+          __throw_exception_again;
+        }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_InputIterator __first, _InputIterator __last,
+                          std::input_iterator_tag)
+      {
+        this->_M_initialize_map(0);
+        __try
+          {
+            for (; __first != __last; ++__first)
+#if __cplusplus >= 201103L
+	      emplace_back(*__first);
+#else
+              push_back(*__first);
+#endif
+          }
+        __catch(...)
+          {
+            clear();
+            __throw_exception_again;
+          }
+      }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+                          std::forward_iterator_tag)
+      {
+        const size_type __n = std::distance(__first, __last);
+        this->_M_initialize_map(__n);
+
+        _Map_pointer __cur_node;
+        __try
+          {
+            for (__cur_node = this->_M_impl._M_start._M_node;
+                 __cur_node < this->_M_impl._M_finish._M_node;
+                 ++__cur_node)
+	      {
+		_ForwardIterator __mid = __first;
+		std::advance(__mid, _S_buffer_size());
+		std::__uninitialized_copy_a(__first, __mid, *__cur_node,
+					    _M_get_Tp_allocator());
+		__first = __mid;
+	      }
+            std::__uninitialized_copy_a(__first, __last,
+					this->_M_impl._M_finish._M_first,
+					_M_get_Tp_allocator());
+          }
+        __catch(...)
+          {
+            std::_Destroy(this->_M_impl._M_start,
+			  iterator(*__cur_node, __cur_node),
+			  _M_get_Tp_allocator());
+            __throw_exception_again;
+          }
+      }
+
+  // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_last - 1.
+  template<typename _Tp, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_back_aux(_Args&&... __args)
+#else
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_back_aux(const value_type& __t)
+#endif
+      {
+	_M_reserve_map_at_back();
+	*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
+	__try
+	  {
+#if __cplusplus >= 201103L
+	    this->_M_impl.construct(this->_M_impl._M_finish._M_cur,
+				    std::forward<_Args>(__args)...);
+#else
+	    this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
+#endif
+	    this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+						+ 1);
+	    this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
+	  }
+	__catch(...)
+	  {
+	    _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
+	    __throw_exception_again;
+	  }
+      }
+
+  // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_first.
+  template<typename _Tp, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_front_aux(_Args&&... __args)
+#else
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_front_aux(const value_type& __t)
+#endif
+      {
+	_M_reserve_map_at_front();
+	*(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
+	__try
+	  {
+	    this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
+					       - 1);
+	    this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
+#if __cplusplus >= 201103L
+	    this->_M_impl.construct(this->_M_impl._M_start._M_cur,
+				    std::forward<_Args>(__args)...);
+#else
+	    this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t);
+#endif
+	  }
+	__catch(...)
+	  {
+	    ++this->_M_impl._M_start;
+	    _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
+	    __throw_exception_again;
+	  }
+      }
+
+  // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_first.
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_back_aux()
+    {
+      _M_deallocate_node(this->_M_impl._M_finish._M_first);
+      this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
+      this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
+      this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
+    }
+
+  // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_last - 1.
+  // Note that if the deque has at least one element (a precondition for this
+  // member function), and if
+  //   _M_impl._M_start._M_cur == _M_impl._M_start._M_last,
+  // then the deque must have at least two nodes.
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_front_aux()
+    {
+      this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
+      _M_deallocate_node(this->_M_impl._M_start._M_first);
+      this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
+      this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          std::input_iterator_tag)
+      { std::copy(__first, __last, std::inserter(*this, __pos)); }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+                          _ForwardIterator __first, _ForwardIterator __last,
+                          std::forward_iterator_tag)
+      {
+        const size_type __n = std::distance(__first, __last);
+        if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+	  {
+	    iterator __new_start = _M_reserve_elements_at_front(__n);
+	    __try
+	      {
+		std::__uninitialized_copy_a(__first, __last, __new_start,
+					    _M_get_Tp_allocator());
+		this->_M_impl._M_start = __new_start;
+	      }
+	    __catch(...)
+	      {
+		_M_destroy_nodes(__new_start._M_node,
+				 this->_M_impl._M_start._M_node);
+		__throw_exception_again;
+	      }
+	  }
+        else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+	  {
+	    iterator __new_finish = _M_reserve_elements_at_back(__n);
+	    __try
+	      {
+		std::__uninitialized_copy_a(__first, __last,
+					    this->_M_impl._M_finish,
+					    _M_get_Tp_allocator());
+		this->_M_impl._M_finish = __new_finish;
+	      }
+	    __catch(...)
+	      {
+		_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+				 __new_finish._M_node + 1);
+		__throw_exception_again;
+	      }
+	  }
+        else
+          _M_insert_aux(__pos, __first, __last, __n);
+      }
+
+  template<typename _Tp, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename... _Args>
+      typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos, _Args&&... __args)
+      {
+	value_type __x_copy(std::forward<_Args>(__args)...); // XXX copy
+#else
+    typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos, const value_type& __x)
+      {
+	value_type __x_copy = __x; // XXX copy
+#endif
+	difference_type __index = __pos - this->_M_impl._M_start;
+	if (static_cast<size_type>(__index) < size() / 2)
+	  {
+	    push_front(_GLIBCXX_MOVE(front()));
+	    iterator __front1 = this->_M_impl._M_start;
+	    ++__front1;
+	    iterator __front2 = __front1;
+	    ++__front2;
+	    __pos = this->_M_impl._M_start + __index;
+	    iterator __pos1 = __pos;
+	    ++__pos1;
+	    _GLIBCXX_MOVE3(__front2, __pos1, __front1);
+	  }
+	else
+	  {
+	    push_back(_GLIBCXX_MOVE(back()));
+	    iterator __back1 = this->_M_impl._M_finish;
+	    --__back1;
+	    iterator __back2 = __back1;
+	    --__back2;
+	    __pos = this->_M_impl._M_start + __index;
+	    _GLIBCXX_MOVE_BACKWARD3(__pos, __back2, __back1);
+	  }
+	*__pos = _GLIBCXX_MOVE(__x_copy);
+	return __pos;
+      }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
+    {
+      const difference_type __elems_before = __pos - this->_M_impl._M_start;
+      const size_type __length = this->size();
+      value_type __x_copy = __x;
+      if (__elems_before < difference_type(__length / 2))
+	{
+	  iterator __new_start = _M_reserve_elements_at_front(__n);
+	  iterator __old_start = this->_M_impl._M_start;
+	  __pos = this->_M_impl._M_start + __elems_before;
+	  __try
+	    {
+	      if (__elems_before >= difference_type(__n))
+		{
+		  iterator __start_n = (this->_M_impl._M_start
+					+ difference_type(__n));
+		  std::__uninitialized_move_a(this->_M_impl._M_start,
+					      __start_n, __new_start,
+					      _M_get_Tp_allocator());
+		  this->_M_impl._M_start = __new_start;
+		  _GLIBCXX_MOVE3(__start_n, __pos, __old_start);
+		  std::fill(__pos - difference_type(__n), __pos, __x_copy);
+		}
+	      else
+		{
+		  std::__uninitialized_move_fill(this->_M_impl._M_start,
+						 __pos, __new_start,
+						 this->_M_impl._M_start,
+						 __x_copy,
+						 _M_get_Tp_allocator());
+		  this->_M_impl._M_start = __new_start;
+		  std::fill(__old_start, __pos, __x_copy);
+		}
+	    }
+	  __catch(...)
+	    {
+	      _M_destroy_nodes(__new_start._M_node,
+			       this->_M_impl._M_start._M_node);
+	      __throw_exception_again;
+	    }
+	}
+      else
+	{
+	  iterator __new_finish = _M_reserve_elements_at_back(__n);
+	  iterator __old_finish = this->_M_impl._M_finish;
+	  const difference_type __elems_after =
+	    difference_type(__length) - __elems_before;
+	  __pos = this->_M_impl._M_finish - __elems_after;
+	  __try
+	    {
+	      if (__elems_after > difference_type(__n))
+		{
+		  iterator __finish_n = (this->_M_impl._M_finish
+					 - difference_type(__n));
+		  std::__uninitialized_move_a(__finish_n,
+					      this->_M_impl._M_finish,
+					      this->_M_impl._M_finish,
+					      _M_get_Tp_allocator());
+		  this->_M_impl._M_finish = __new_finish;
+		  _GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish);
+		  std::fill(__pos, __pos + difference_type(__n), __x_copy);
+		}
+	      else
+		{
+		  std::__uninitialized_fill_move(this->_M_impl._M_finish,
+						 __pos + difference_type(__n),
+						 __x_copy, __pos,
+						 this->_M_impl._M_finish,
+						 _M_get_Tp_allocator());
+		  this->_M_impl._M_finish = __new_finish;
+		  std::fill(__pos, __old_finish, __x_copy);
+		}
+	    }
+	  __catch(...)
+	    {
+	      _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+			       __new_finish._M_node + 1);
+	      __throw_exception_again;
+	    }
+	}
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos,
+                    _ForwardIterator __first, _ForwardIterator __last,
+                    size_type __n)
+      {
+        const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
+        const size_type __length = size();
+        if (static_cast<size_type>(__elemsbefore) < __length / 2)
+	  {
+	    iterator __new_start = _M_reserve_elements_at_front(__n);
+	    iterator __old_start = this->_M_impl._M_start;
+	    __pos = this->_M_impl._M_start + __elemsbefore;
+	    __try
+	      {
+		if (__elemsbefore >= difference_type(__n))
+		  {
+		    iterator __start_n = (this->_M_impl._M_start
+					  + difference_type(__n));
+		    std::__uninitialized_move_a(this->_M_impl._M_start,
+						__start_n, __new_start,
+						_M_get_Tp_allocator());
+		    this->_M_impl._M_start = __new_start;
+		    _GLIBCXX_MOVE3(__start_n, __pos, __old_start);
+		    std::copy(__first, __last, __pos - difference_type(__n));
+		  }
+		else
+		  {
+		    _ForwardIterator __mid = __first;
+		    std::advance(__mid, difference_type(__n) - __elemsbefore);
+		    std::__uninitialized_move_copy(this->_M_impl._M_start,
+						   __pos, __first, __mid,
+						   __new_start,
+						   _M_get_Tp_allocator());
+		    this->_M_impl._M_start = __new_start;
+		    std::copy(__mid, __last, __old_start);
+		  }
+	      }
+	    __catch(...)
+	      {
+		_M_destroy_nodes(__new_start._M_node,
+				 this->_M_impl._M_start._M_node);
+		__throw_exception_again;
+	      }
+	  }
+        else
+        {
+          iterator __new_finish = _M_reserve_elements_at_back(__n);
+          iterator __old_finish = this->_M_impl._M_finish;
+          const difference_type __elemsafter =
+            difference_type(__length) - __elemsbefore;
+          __pos = this->_M_impl._M_finish - __elemsafter;
+          __try
+            {
+              if (__elemsafter > difference_type(__n))
+		{
+		  iterator __finish_n = (this->_M_impl._M_finish
+					 - difference_type(__n));
+		  std::__uninitialized_move_a(__finish_n,
+					      this->_M_impl._M_finish,
+					      this->_M_impl._M_finish,
+					      _M_get_Tp_allocator());
+		  this->_M_impl._M_finish = __new_finish;
+		  _GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish);
+		  std::copy(__first, __last, __pos);
+		}
+              else
+		{
+		  _ForwardIterator __mid = __first;
+		  std::advance(__mid, __elemsafter);
+		  std::__uninitialized_copy_move(__mid, __last, __pos,
+						 this->_M_impl._M_finish,
+						 this->_M_impl._M_finish,
+						 _M_get_Tp_allocator());
+		  this->_M_impl._M_finish = __new_finish;
+		  std::copy(__first, __mid, __pos);
+		}
+            }
+          __catch(...)
+            {
+              _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+			       __new_finish._M_node + 1);
+              __throw_exception_again;
+            }
+        }
+      }
+
+   template<typename _Tp, typename _Alloc>
+     void
+     deque<_Tp, _Alloc>::
+     _M_destroy_data_aux(iterator __first, iterator __last)
+     {
+       for (_Map_pointer __node = __first._M_node + 1;
+	    __node < __last._M_node; ++__node)
+	 std::_Destroy(*__node, *__node + _S_buffer_size(),
+		       _M_get_Tp_allocator());
+
+       if (__first._M_node != __last._M_node)
+	 {
+	   std::_Destroy(__first._M_cur, __first._M_last,
+			 _M_get_Tp_allocator());
+	   std::_Destroy(__last._M_first, __last._M_cur,
+			 _M_get_Tp_allocator());
+	 }
+       else
+	 std::_Destroy(__first._M_cur, __last._M_cur,
+		       _M_get_Tp_allocator());
+     }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_front(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+	__throw_length_error(__N("deque::_M_new_elements_at_front"));
+
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+				     / _S_buffer_size());
+      _M_reserve_map_at_front(__new_nodes);
+      size_type __i;
+      __try
+        {
+          for (__i = 1; __i <= __new_nodes; ++__i)
+            *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
+        }
+      __catch(...)
+        {
+          for (size_type __j = 1; __j < __i; ++__j)
+            _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
+          __throw_exception_again;
+        }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_back(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+	__throw_length_error(__N("deque::_M_new_elements_at_back"));
+
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+				     / _S_buffer_size());
+      _M_reserve_map_at_back(__new_nodes);
+      size_type __i;
+      __try
+        {
+          for (__i = 1; __i <= __new_nodes; ++__i)
+            *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
+        }
+      __catch(...)
+        {
+          for (size_type __j = 1; __j < __i; ++__j)
+            _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
+          __throw_exception_again;
+        }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
+    {
+      const size_type __old_num_nodes
+	= this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
+      const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+
+      _Map_pointer __new_nstart;
+      if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
+	{
+	  __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
+					 - __new_num_nodes) / 2
+	                 + (__add_at_front ? __nodes_to_add : 0);
+	  if (__new_nstart < this->_M_impl._M_start._M_node)
+	    std::copy(this->_M_impl._M_start._M_node,
+		      this->_M_impl._M_finish._M_node + 1,
+		      __new_nstart);
+	  else
+	    std::copy_backward(this->_M_impl._M_start._M_node,
+			       this->_M_impl._M_finish._M_node + 1,
+			       __new_nstart + __old_num_nodes);
+	}
+      else
+	{
+	  size_type __new_map_size = this->_M_impl._M_map_size
+	                             + std::max(this->_M_impl._M_map_size,
+						__nodes_to_add) + 2;
+
+	  _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
+	  __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+	                 + (__add_at_front ? __nodes_to_add : 0);
+	  std::copy(this->_M_impl._M_start._M_node,
+		    this->_M_impl._M_finish._M_node + 1,
+		    __new_nstart);
+	  _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+
+	  this->_M_impl._M_map = __new_map;
+	  this->_M_impl._M_map_size = __new_map_size;
+	}
+
+      this->_M_impl._M_start._M_set_node(__new_nstart);
+      this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
+    }
+
+  // Overload for deque::iterators, exploiting the "segmented-iterator
+  // optimization".
+  template<typename _Tp>
+    void
+    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
+	 const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+
+      for (typename _Self::_Map_pointer __node = __first._M_node + 1;
+           __node < __last._M_node; ++__node)
+	std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
+
+      if (__first._M_node != __last._M_node)
+	{
+	  std::fill(__first._M_cur, __first._M_last, __value);
+	  std::fill(__last._M_first, __last._M_cur, __value);
+	}
+      else
+	std::fill(__first._M_cur, __last._M_cur, __value);
+    }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+	 _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+	{
+	  const difference_type __clen
+	    = std::min(__len, std::min(__first._M_last - __first._M_cur,
+				       __result._M_last - __result._M_cur));
+	  std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
+	  __first += __clen;
+	  __result += __clen;
+	  __len -= __clen;
+	}
+      return __result;
+    }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+		  _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+	{
+	  difference_type __llen = __last._M_cur - __last._M_first;
+	  _Tp* __lend = __last._M_cur;
+
+	  difference_type __rlen = __result._M_cur - __result._M_first;
+	  _Tp* __rend = __result._M_cur;
+
+	  if (!__llen)
+	    {
+	      __llen = _Self::_S_buffer_size();
+	      __lend = *(__last._M_node - 1) + __llen;
+	    }
+	  if (!__rlen)
+	    {
+	      __rlen = _Self::_S_buffer_size();
+	      __rend = *(__result._M_node - 1) + __rlen;
+	    }
+
+	  const difference_type __clen = std::min(__len,
+						  std::min(__llen, __rlen));
+	  std::copy_backward(__lend - __clen, __lend, __rend);
+	  __last -= __clen;
+	  __result -= __clen;
+	  __len -= __clen;
+	}
+      return __result;
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+	 _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+	{
+	  const difference_type __clen
+	    = std::min(__len, std::min(__first._M_last - __first._M_cur,
+				       __result._M_last - __result._M_cur));
+	  std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
+	  __first += __clen;
+	  __result += __clen;
+	  __len -= __clen;
+	}
+      return __result;
+    }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+		  _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+	{
+	  difference_type __llen = __last._M_cur - __last._M_first;
+	  _Tp* __lend = __last._M_cur;
+
+	  difference_type __rlen = __result._M_cur - __result._M_first;
+	  _Tp* __rend = __result._M_cur;
+
+	  if (!__llen)
+	    {
+	      __llen = _Self::_S_buffer_size();
+	      __lend = *(__last._M_node - 1) + __llen;
+	    }
+	  if (!__rlen)
+	    {
+	      __rlen = _Self::_S_buffer_size();
+	      __rend = *(__result._M_node - 1) + __rlen;
+	    }
+
+	  const difference_type __clen = std::min(__len,
+						  std::min(__llen, __rlen));
+	  std::move_backward(__lend - __clen, __lend, __rend);
+	  __last -= __clen;
+	  __result -= __clen;
+	  __len -= __clen;
+	}
+      return __result;
+    }
+#endif
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/enable_special_members.h b/gcc-4.9/libstdc++-v3/include/bits/enable_special_members.h
new file mode 100644
index 0000000..b1822a4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/enable_special_members.h
@@ -0,0 +1,278 @@
+// <bits/enable_special_members.h> -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/enable_special_members.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly.
+ */
+
+#ifndef _ENABLE_SPECIAL_MEMBERS_H
+#define _ENABLE_SPECIAL_MEMBERS_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+/**
+  * @brief A mixin helper to conditionally enable or disable the default
+  * constructor.
+  * @sa _Enable_special_members
+  */
+template<bool _Switch, typename _Tag = void>
+  struct _Enable_default_constructor { };
+
+
+/**
+  * @brief A mixin helper to conditionally enable or disable the default
+  * destructor.
+  * @sa _Enable_special_members
+  */
+template<bool _Switch, typename _Tag = void>
+  struct _Enable_destructor { };
+
+/**
+  * @brief A mixin helper to conditionally enable or disable the copy/move
+  * special members.
+  * @sa _Enable_special_members
+  */
+template<bool _Copy, bool _CopyAssignment,
+         bool _Move, bool _MoveAssignment,
+         typename _Tag = void>
+  struct _Enable_copy_move { };
+
+/**
+  * @brief A mixin helper to conditionally enable or disable the special
+  * members.
+  *
+  * The @c _Tag type parameter is to make mixin bases unique and thus avoid
+  * ambiguities.
+  */
+template<bool _Default, bool _Destructor,
+         bool _Copy, bool _CopyAssignment,
+         bool _Move, bool _MoveAssignment,
+         typename _Tag = void>
+  struct _Enable_special_members
+  : private _Enable_default_constructor<_Default, _Tag>,
+    private _Enable_destructor<_Destructor, _Tag>,
+    private _Enable_copy_move<_Copy, _CopyAssignment,
+                              _Move, _MoveAssignment,
+                              _Tag>
+  { };
+
+// Boilerplate follows.
+
+template<typename _Tag>
+  struct _Enable_default_constructor<false, _Tag>
+  { constexpr _Enable_default_constructor() noexcept = delete; };
+
+template<typename _Tag>
+  struct _Enable_destructor<false, _Tag>
+  { ~_Enable_destructor() noexcept = delete; };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept                          = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept  = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept       = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept                    = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept                         = delete;
+  };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // _ENABLE_SPECIAL_MEMBERS_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/forward_list.h b/gcc-4.9/libstdc++-v3/include/bits/forward_list.h
new file mode 100644
index 0000000..524fad1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/forward_list.h
@@ -0,0 +1,1408 @@
+// <forward_list.h> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/forward_list.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{forward_list}
+ */
+
+#ifndef _FORWARD_LIST_H
+#define _FORWARD_LIST_H 1
+
+#pragma GCC system_header
+
+#include <initializer_list>
+#include <bits/stl_iterator_base_types.h>
+#include <bits/stl_iterator.h>
+#include <bits/stl_algobase.h>
+#include <bits/stl_function.h>
+#include <bits/allocator.h>
+#include <ext/alloc_traits.h>
+#include <ext/aligned_buffer.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  @brief  A helper basic node class for %forward_list.
+   *          This is just a linked list with nothing inside it.
+   *          There are purely list shuffling utility methods here.
+   */
+  struct _Fwd_list_node_base
+  {
+    _Fwd_list_node_base() = default;
+
+    _Fwd_list_node_base* _M_next = nullptr;
+
+    _Fwd_list_node_base*
+    _M_transfer_after(_Fwd_list_node_base* __begin,
+		      _Fwd_list_node_base* __end) noexcept
+    {
+      _Fwd_list_node_base* __keep = __begin->_M_next;
+      if (__end)
+	{
+	  __begin->_M_next = __end->_M_next;
+	  __end->_M_next = _M_next;
+	}
+      else
+	__begin->_M_next = 0;
+      _M_next = __keep;
+      return __end;
+    }
+
+    void
+    _M_reverse_after() noexcept
+    {
+      _Fwd_list_node_base* __tail = _M_next;
+      if (!__tail)
+	return;
+      while (_Fwd_list_node_base* __temp = __tail->_M_next)
+	{
+	  _Fwd_list_node_base* __keep = _M_next;
+	  _M_next = __temp;
+	  __tail->_M_next = __temp->_M_next;
+	  _M_next->_M_next = __keep;
+	}
+    }
+  };
+
+  /**
+   *  @brief  A helper node class for %forward_list.
+   *          This is just a linked list with uninitialized storage for a
+   *          data value in each node.
+   *          There is a sorting utility method.
+   */
+  template<typename _Tp>
+    struct _Fwd_list_node
+    : public _Fwd_list_node_base
+    {
+      _Fwd_list_node() = default;
+
+      __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+
+      _Tp*
+      _M_valptr() noexcept
+      { return _M_storage._M_ptr(); }
+
+      const _Tp*
+      _M_valptr() const noexcept
+      { return _M_storage._M_ptr(); }
+    };
+
+  /**
+   *   @brief A forward_list::iterator.
+   * 
+   *   All the functions are op overloads.
+   */
+  template<typename _Tp>
+    struct _Fwd_list_iterator
+    {
+      typedef _Fwd_list_iterator<_Tp>            _Self;
+      typedef _Fwd_list_node<_Tp>                _Node;
+
+      typedef _Tp                                value_type;
+      typedef _Tp*                               pointer;
+      typedef _Tp&                               reference;
+      typedef ptrdiff_t                          difference_type;
+      typedef std::forward_iterator_tag          iterator_category;
+
+      _Fwd_list_iterator() noexcept
+      : _M_node() { }
+
+      explicit
+      _Fwd_list_iterator(_Fwd_list_node_base* __n) noexcept
+      : _M_node(__n) { }
+
+      reference
+      operator*() const noexcept
+      { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Node*>(this->_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() noexcept
+      {
+        _M_node = _M_node->_M_next;
+        return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+        _Self __tmp(*this);
+        _M_node = _M_node->_M_next;
+        return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const noexcept
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const noexcept
+      { return _M_node != __x._M_node; }
+
+      _Self
+      _M_next() const noexcept
+      {
+        if (_M_node)
+          return _Fwd_list_iterator(_M_node->_M_next);
+        else
+          return _Fwd_list_iterator(0);
+      }
+
+      _Fwd_list_node_base* _M_node;
+    };
+
+  /**
+   *   @brief A forward_list::const_iterator.
+   * 
+   *   All the functions are op overloads.
+   */
+  template<typename _Tp>
+    struct _Fwd_list_const_iterator
+    {
+      typedef _Fwd_list_const_iterator<_Tp>      _Self;
+      typedef const _Fwd_list_node<_Tp>          _Node;
+      typedef _Fwd_list_iterator<_Tp>            iterator;
+
+      typedef _Tp                                value_type;
+      typedef const _Tp*                         pointer;
+      typedef const _Tp&                         reference;
+      typedef ptrdiff_t                          difference_type;
+      typedef std::forward_iterator_tag          iterator_category;
+
+      _Fwd_list_const_iterator() noexcept
+      : _M_node() { }
+
+      explicit
+      _Fwd_list_const_iterator(const _Fwd_list_node_base* __n)  noexcept
+      : _M_node(__n) { }
+
+      _Fwd_list_const_iterator(const iterator& __iter) noexcept
+      : _M_node(__iter._M_node) { }
+
+      reference
+      operator*() const noexcept
+      { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Node*>(this->_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() noexcept
+      {
+        _M_node = _M_node->_M_next;
+        return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+        _Self __tmp(*this);
+        _M_node = _M_node->_M_next;
+        return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const noexcept
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const noexcept
+      { return _M_node != __x._M_node; }
+
+      _Self
+      _M_next() const noexcept
+      {
+        if (this->_M_node)
+          return _Fwd_list_const_iterator(_M_node->_M_next);
+        else
+          return _Fwd_list_const_iterator(0);
+      }
+
+      const _Fwd_list_node_base* _M_node;
+    };
+
+  /**
+   *  @brief  Forward list iterator equality comparison.
+   */
+  template<typename _Tp>
+    inline bool
+    operator==(const _Fwd_list_iterator<_Tp>& __x,
+               const _Fwd_list_const_iterator<_Tp>& __y) noexcept
+    { return __x._M_node == __y._M_node; }
+
+  /**
+   *  @brief  Forward list iterator inequality comparison.
+   */
+  template<typename _Tp>
+    inline bool
+    operator!=(const _Fwd_list_iterator<_Tp>& __x,
+               const _Fwd_list_const_iterator<_Tp>& __y) noexcept
+    { return __x._M_node != __y._M_node; }
+
+  /**
+   *  @brief  Base class for %forward_list.
+   */
+  template<typename _Tp, typename _Alloc>
+    struct _Fwd_list_base
+    {
+    protected:
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc> _Alloc_traits;
+      typedef typename _Alloc_traits::template rebind<_Tp>::other
+        _Tp_alloc_type;
+
+      typedef typename _Alloc_traits::template
+        rebind<_Fwd_list_node<_Tp>>::other _Node_alloc_type;
+
+      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
+
+      struct _Fwd_list_impl 
+      : public _Node_alloc_type
+      {
+        _Fwd_list_node_base _M_head;
+
+        _Fwd_list_impl()
+        : _Node_alloc_type(), _M_head()
+        { }
+
+        _Fwd_list_impl(const _Node_alloc_type& __a)
+        : _Node_alloc_type(__a), _M_head()
+        { }
+
+        _Fwd_list_impl(_Node_alloc_type&& __a)
+	: _Node_alloc_type(std::move(__a)), _M_head()
+        { }
+      };
+
+      _Fwd_list_impl _M_impl;
+
+    public:
+      typedef _Fwd_list_iterator<_Tp>                 iterator;
+      typedef _Fwd_list_const_iterator<_Tp>           const_iterator;
+      typedef _Fwd_list_node<_Tp>                     _Node;
+
+      _Node_alloc_type&
+      _M_get_Node_allocator() noexcept
+      { return *static_cast<_Node_alloc_type*>(&this->_M_impl); }
+
+      const _Node_alloc_type&
+      _M_get_Node_allocator() const noexcept
+      { return *static_cast<const _Node_alloc_type*>(&this->_M_impl); }
+
+      _Fwd_list_base()
+      : _M_impl() { }
+
+      _Fwd_list_base(const _Node_alloc_type& __a)
+      : _M_impl(__a) { }
+
+      _Fwd_list_base(_Fwd_list_base&& __lst, const _Node_alloc_type& __a);
+
+      _Fwd_list_base(_Fwd_list_base&& __lst)
+      : _M_impl(std::move(__lst._M_get_Node_allocator()))
+      {
+	this->_M_impl._M_head._M_next = __lst._M_impl._M_head._M_next;
+	__lst._M_impl._M_head._M_next = 0;
+      }
+
+      ~_Fwd_list_base()
+      { _M_erase_after(&_M_impl._M_head, 0); }
+
+    protected:
+
+      _Node*
+      _M_get_node()
+      {
+	auto __ptr = _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1);
+	return std::__addressof(*__ptr);
+      }
+
+      template<typename... _Args>
+        _Node*
+        _M_create_node(_Args&&... __args)
+        {
+          _Node* __node = this->_M_get_node();
+          __try
+            {
+	      _Tp_alloc_type __a(_M_get_Node_allocator());
+	      typedef allocator_traits<_Tp_alloc_type> _Alloc_traits;
+	      ::new ((void*)__node) _Node;
+	      _Alloc_traits::construct(__a, __node->_M_valptr(),
+				       std::forward<_Args>(__args)...);
+            }
+          __catch(...)
+            {
+              this->_M_put_node(__node);
+              __throw_exception_again;
+            }
+          return __node;
+        }
+
+      template<typename... _Args>
+        _Fwd_list_node_base*
+        _M_insert_after(const_iterator __pos, _Args&&... __args);
+
+      void
+      _M_put_node(_Node* __p)
+      {
+	typedef typename _Node_alloc_traits::pointer _Ptr;
+	auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__p);
+	_Node_alloc_traits::deallocate(_M_get_Node_allocator(), __ptr, 1);
+      }
+
+      _Fwd_list_node_base*
+      _M_erase_after(_Fwd_list_node_base* __pos);
+
+      _Fwd_list_node_base*
+      _M_erase_after(_Fwd_list_node_base* __pos, 
+                     _Fwd_list_node_base* __last);
+    };
+
+  /**
+   *  @brief A standard container with linear time access to elements,
+   *  and fixed time insertion/deletion at any point in the sequence.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Tp  Type of element.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_Tp>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#67">sequence</a>, including the
+   *  <a href="tables.html#68">optional sequence requirements</a> with the
+   *  %exception of @c at and @c operator[].
+   *
+   *  This is a @e singly @e linked %list.  Traversal up the
+   *  %list requires linear time, but adding and removing elements (or
+   *  @e nodes) is done in constant time, regardless of where the
+   *  change takes place.  Unlike std::vector and std::deque,
+   *  random-access iterators are not provided, so subscripting ( @c
+   *  [] ) access is not allowed.  For algorithms which only need
+   *  sequential access, this lack makes no difference.
+   *
+   *  Also unlike the other standard containers, std::forward_list provides
+   *  specialized algorithms %unique to linked lists, such as
+   *  splicing, sorting, and in-place reversal.
+   */
+  template<typename _Tp, typename _Alloc = allocator<_Tp> >
+    class forward_list : private _Fwd_list_base<_Tp, _Alloc>
+    {
+    private:
+      typedef _Fwd_list_base<_Tp, _Alloc>                  _Base;
+      typedef _Fwd_list_node<_Tp>                          _Node;
+      typedef _Fwd_list_node_base                          _Node_base;
+      typedef typename _Base::_Tp_alloc_type               _Tp_alloc_type;
+      typedef typename _Base::_Node_alloc_type             _Node_alloc_type;
+      typedef typename _Base::_Node_alloc_traits           _Node_alloc_traits;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type>    _Alloc_traits;
+
+    public:
+      // types:
+      typedef _Tp                                          value_type;
+      typedef typename _Alloc_traits::pointer              pointer;
+      typedef typename _Alloc_traits::const_pointer        const_pointer;
+      typedef value_type&				   reference;
+      typedef const value_type&				   const_reference;
+ 
+      typedef _Fwd_list_iterator<_Tp>                      iterator;
+      typedef _Fwd_list_const_iterator<_Tp>                const_iterator;
+      typedef std::size_t                                  size_type;
+      typedef std::ptrdiff_t                               difference_type;
+      typedef _Alloc                                       allocator_type;
+
+      // 23.3.4.2 construct/copy/destroy:
+
+      /**
+       *  @brief  Creates a %forward_list with no elements.
+       *  @param  __al  An allocator object.
+       */
+      explicit
+      forward_list(const _Alloc& __al = _Alloc())
+      : _Base(_Node_alloc_type(__al))
+      { }
+
+      /**
+       *  @brief  Copy constructor with allocator argument.
+       *  @param  __list  Input list to copy.
+       *  @param  __al    An allocator object.
+       */
+      forward_list(const forward_list& __list, const _Alloc& __al)
+      : _Base(_Node_alloc_type(__al))
+      { _M_range_initialize(__list.begin(), __list.end()); }
+
+      /**
+       *  @brief  Move constructor with allocator argument.
+       *  @param  __list  Input list to move.
+       *  @param  __al    An allocator object.
+       */
+      forward_list(forward_list&& __list, const _Alloc& __al)
+      noexcept(_Node_alloc_traits::_S_always_equal())
+      : _Base(std::move(__list), _Node_alloc_type(__al))
+      { }
+
+      /**
+       *  @brief  Creates a %forward_list with default constructed elements.
+       *  @param  __n  The number of elements to initially create.
+       *
+       *  This constructor creates the %forward_list with @a __n default
+       *  constructed elements.
+       */
+      explicit
+      forward_list(size_type __n, const _Alloc& __al = _Alloc())
+      : _Base(_Node_alloc_type(__al))
+      { _M_default_initialize(__n); }
+
+      /**
+       *  @brief  Creates a %forward_list with copies of an exemplar element.
+       *  @param  __n      The number of elements to initially create.
+       *  @param  __value  An element to copy.
+       *  @param  __al     An allocator object.
+       *
+       *  This constructor fills the %forward_list with @a __n copies of
+       *  @a __value.
+       */
+      forward_list(size_type __n, const _Tp& __value,
+                   const _Alloc& __al = _Alloc())
+      : _Base(_Node_alloc_type(__al))
+      { _M_fill_initialize(__n, __value); }
+
+      /**
+       *  @brief  Builds a %forward_list from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *  @param  __al     An allocator object.
+       *
+       *  Create a %forward_list consisting of copies of the elements from
+       *  [@a __first,@a __last).  This is linear in N (where N is
+       *  distance(@a __first,@a __last)).
+       */
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        forward_list(_InputIterator __first, _InputIterator __last,
+                     const _Alloc& __al = _Alloc())
+	: _Base(_Node_alloc_type(__al))
+        { _M_range_initialize(__first, __last); }
+
+      /**
+       *  @brief  The %forward_list copy constructor.
+       *  @param  __list  A %forward_list of identical element and allocator
+       *                  types.
+       */
+      forward_list(const forward_list& __list)
+      : _Base(_Node_alloc_traits::_S_select_on_copy(
+                __list._M_get_Node_allocator()))
+      { _M_range_initialize(__list.begin(), __list.end()); }
+
+      /**
+       *  @brief  The %forward_list move constructor.
+       *  @param  __list  A %forward_list of identical element and allocator
+       *                  types.
+       *
+       *  The newly-created %forward_list contains the exact contents of @a
+       *  __list. The contents of @a __list are a valid, but unspecified
+       *  %forward_list.
+       */
+      forward_list(forward_list&& __list) noexcept
+      : _Base(std::move(__list)) { }
+
+      /**
+       *  @brief  Builds a %forward_list from an initializer_list
+       *  @param  __il  An initializer_list of value_type.
+       *  @param  __al  An allocator object.
+       *
+       *  Create a %forward_list consisting of copies of the elements
+       *  in the initializer_list @a __il.  This is linear in __il.size().
+       */
+      forward_list(std::initializer_list<_Tp> __il,
+                   const _Alloc& __al = _Alloc())
+      : _Base(_Node_alloc_type(__al))
+      { _M_range_initialize(__il.begin(), __il.end()); }
+
+      /**
+       *  @brief  The forward_list dtor.
+       */
+      ~forward_list() noexcept
+      { }
+
+      /**
+       *  @brief  The %forward_list assignment operator.
+       *  @param  __list  A %forward_list of identical element and allocator
+       *                types.
+       *
+       *  All the elements of @a __list are copied, but unlike the copy
+       *  constructor, the allocator object is not copied.
+       */
+      forward_list&
+      operator=(const forward_list& __list);
+
+      /**
+       *  @brief  The %forward_list move assignment operator.
+       *  @param  __list  A %forward_list of identical element and allocator
+       *                types.
+       *
+       *  The contents of @a __list are moved into this %forward_list
+       *  (without copying, if the allocators permit it).
+       *  @a __list is a valid, but unspecified %forward_list
+       */
+      forward_list&
+      operator=(forward_list&& __list)
+      noexcept(_Node_alloc_traits::_S_nothrow_move())
+      {
+        constexpr bool __move_storage =
+          _Node_alloc_traits::_S_propagate_on_move_assign()
+          || _Node_alloc_traits::_S_always_equal();
+        _M_move_assign(std::move(__list),
+                       integral_constant<bool, __move_storage>());
+	return *this;
+      }
+
+      /**
+       *  @brief  The %forward_list initializer list assignment operator.
+       *  @param  __il  An initializer_list of value_type.
+       *
+       *  Replace the contents of the %forward_list with copies of the
+       *  elements in the initializer_list @a __il.  This is linear in
+       *  __il.size().
+       */
+      forward_list&
+      operator=(std::initializer_list<_Tp> __il)
+      {
+        assign(__il);
+        return *this;
+      }
+
+      /**
+       *  @brief  Assigns a range to a %forward_list.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *
+       *  This function fills a %forward_list with copies of the elements
+       *  in the range [@a __first,@a __last).
+       *
+       *  Note that the assignment completely changes the %forward_list and
+       *  that the number of elements of the resulting %forward_list is the
+       *  same as the number of elements assigned.  Old data is lost.
+       */
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  typedef is_assignable<_Tp, decltype(*__first)> __assignable;
+	  _M_assign(__first, __last, __assignable());
+	}
+
+      /**
+       *  @brief  Assigns a given value to a %forward_list.
+       *  @param  __n  Number of elements to be assigned.
+       *  @param  __val  Value to be assigned.
+       *
+       *  This function fills a %forward_list with @a __n copies of the
+       *  given value.  Note that the assignment completely changes the
+       *  %forward_list, and that the resulting %forward_list has __n
+       *  elements.  Old data is lost.
+       */
+      void
+      assign(size_type __n, const _Tp& __val)
+      { _M_assign_n(__n, __val, is_copy_assignable<_Tp>()); }
+
+      /**
+       *  @brief  Assigns an initializer_list to a %forward_list.
+       *  @param  __il  An initializer_list of value_type.
+       *
+       *  Replace the contents of the %forward_list with copies of the
+       *  elements in the initializer_list @a __il.  This is linear in
+       *  il.size().
+       */
+      void
+      assign(std::initializer_list<_Tp> __il)
+      { assign(__il.begin(), __il.end()); }
+
+      /// Get a copy of the memory allocation object.
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(this->_M_get_Node_allocator()); }
+
+      // 23.3.4.3 iterators:
+
+      /**
+       *  Returns a read/write iterator that points before the first element
+       *  in the %forward_list.  Iteration is done in ordinary element order.
+       */
+      iterator
+      before_begin() noexcept
+      { return iterator(&this->_M_impl._M_head); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points before the
+       *  first element in the %forward_list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      before_begin() const noexcept
+      { return const_iterator(&this->_M_impl._M_head); }
+
+      /**
+       *  Returns a read/write iterator that points to the first element
+       *  in the %forward_list.  Iteration is done in ordinary element order.
+       */
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_head._M_next); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %forward_list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_head._M_next); }
+
+      /**
+       *  Returns a read/write iterator that points one past the last
+       *  element in the %forward_list.  Iteration is done in ordinary
+       *  element order.
+       */
+      iterator
+      end() noexcept
+      { return iterator(0); }
+
+      /**
+       *  Returns a read-only iterator that points one past the last
+       *  element in the %forward_list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      end() const noexcept
+      { return const_iterator(0); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the
+       *  first element in the %forward_list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_head._M_next); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points before the
+       *  first element in the %forward_list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      cbefore_begin() const noexcept
+      { return const_iterator(&this->_M_impl._M_head); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past
+       *  the last element in the %forward_list.  Iteration is done in
+       *  ordinary element order.
+       */
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(0); }
+
+      /**
+       *  Returns true if the %forward_list is empty.  (Thus begin() would
+       *  equal end().)
+       */
+      bool
+      empty() const noexcept
+      { return this->_M_impl._M_head._M_next == 0; }
+
+      /**
+       *  Returns the largest possible number of elements of %forward_list.
+       */
+      size_type
+      max_size() const noexcept
+      { return _Node_alloc_traits::max_size(this->_M_get_Node_allocator()); }
+
+      // 23.3.4.4 element access:
+
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %forward_list.
+       */
+      reference
+      front()
+      {
+        _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next);
+        return *__front->_M_valptr();
+      }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %forward_list.
+       */
+      const_reference
+      front() const
+      {
+        _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next);
+        return *__front->_M_valptr();
+      }
+
+      // 23.3.4.5 modi�ers:
+
+      /**
+       *  @brief  Constructs object in %forward_list at the front of the
+       *          list.
+       *  @param  __args  Arguments.
+       *
+       *  This function will insert an object of type Tp constructed
+       *  with Tp(std::forward<Args>(args)...) at the front of the list
+       *  Due to the nature of a %forward_list this operation can
+       *  be done in constant time, and does not invalidate iterators
+       *  and references.
+       */
+      template<typename... _Args>
+        void
+        emplace_front(_Args&&... __args)
+        { this->_M_insert_after(cbefore_begin(),
+                                std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief  Add data to the front of the %forward_list.
+       *  @param  __val  Data to be added.
+       *
+       *  This is a typical stack operation.  The function creates an
+       *  element at the front of the %forward_list and assigns the given
+       *  data to it.  Due to the nature of a %forward_list this operation
+       *  can be done in constant time, and does not invalidate iterators
+       *  and references.
+       */
+      void
+      push_front(const _Tp& __val)
+      { this->_M_insert_after(cbefore_begin(), __val); }
+
+      /**
+       *
+       */
+      void
+      push_front(_Tp&& __val)
+      { this->_M_insert_after(cbefore_begin(), std::move(__val)); }
+
+      /**
+       *  @brief  Removes first element.
+       *
+       *  This is a typical stack operation.  It shrinks the %forward_list
+       *  by one.  Due to the nature of a %forward_list this operation can
+       *  be done in constant time, and only invalidates iterators/references
+       *  to the element being removed.
+       *
+       *  Note that no data is returned, and if the first element's data
+       *  is needed, it should be retrieved before pop_front() is
+       *  called.
+       */
+      void
+      pop_front()
+      { this->_M_erase_after(&this->_M_impl._M_head); }
+
+      /**
+       *  @brief  Constructs object in %forward_list after the specified
+       *          iterator.
+       *  @param  __pos  A const_iterator into the %forward_list.
+       *  @param  __args  Arguments.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert an object of type T constructed
+       *  with T(std::forward<Args>(args)...) after the specified
+       *  location.  Due to the nature of a %forward_list this operation can
+       *  be done in constant time, and does not invalidate iterators
+       *  and references.
+       */
+      template<typename... _Args>
+        iterator
+        emplace_after(const_iterator __pos, _Args&&... __args)
+        { return iterator(this->_M_insert_after(__pos,
+                                          std::forward<_Args>(__args)...)); }
+
+      /**
+       *  @brief  Inserts given value into %forward_list after specified
+       *          iterator.
+       *  @param  __pos  An iterator into the %forward_list.
+       *  @param  __val  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given value after
+       *  the specified location.  Due to the nature of a %forward_list this
+       *  operation can be done in constant time, and does not
+       *  invalidate iterators and references.
+       */
+      iterator
+      insert_after(const_iterator __pos, const _Tp& __val)
+      { return iterator(this->_M_insert_after(__pos, __val)); }
+
+      /**
+       *
+       */
+      iterator
+      insert_after(const_iterator __pos, _Tp&& __val)
+      { return iterator(this->_M_insert_after(__pos, std::move(__val))); }
+
+      /**
+       *  @brief  Inserts a number of copies of given data into the
+       *          %forward_list.
+       *  @param  __pos  An iterator into the %forward_list.
+       *  @param  __n  Number of elements to be inserted.
+       *  @param  __val  Data to be inserted.
+       *  @return  An iterator pointing to the last inserted copy of
+       *           @a val or @a pos if @a n == 0.
+       *
+       *  This function will insert a specified number of copies of the
+       *  given data after the location specified by @a pos.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      iterator
+      insert_after(const_iterator __pos, size_type __n, const _Tp& __val);
+
+      /**
+       *  @brief  Inserts a range into the %forward_list.
+       *  @param  __pos  An iterator into the %forward_list.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *  @return  An iterator pointing to the last inserted element or
+       *           @a __pos if @a __first == @a __last.
+       *
+       *  This function will insert copies of the data in the range
+       *  [@a __first,@a __last) into the %forward_list after the
+       *  location specified by @a __pos.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert_after(const_iterator __pos,
+                     _InputIterator __first, _InputIterator __last);
+
+      /**
+       *  @brief  Inserts the contents of an initializer_list into
+       *          %forward_list after the specified iterator.
+       *  @param  __pos  An iterator into the %forward_list.
+       *  @param  __il  An initializer_list of value_type.
+       *  @return  An iterator pointing to the last inserted element
+       *           or @a __pos if @a __il is empty.
+       *
+       *  This function will insert copies of the data in the
+       *  initializer_list @a __il into the %forward_list before the location
+       *  specified by @a __pos.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      iterator
+      insert_after(const_iterator __pos, std::initializer_list<_Tp> __il)
+      { return insert_after(__pos, __il.begin(), __il.end()); }
+
+      /**
+       *  @brief  Removes the element pointed to by the iterator following
+       *          @c pos.
+       *  @param  __pos  Iterator pointing before element to be erased.
+       *  @return  An iterator pointing to the element following the one
+       *           that was erased, or end() if no such element exists.
+       *
+       *  This function will erase the element at the given position and
+       *  thus shorten the %forward_list by one.
+       *
+       *  Due to the nature of a %forward_list this operation can be done
+       *  in constant time, and only invalidates iterators/references to
+       *  the element being removed.  The user is also cautioned that
+       *  this function only erases the element, and that if the element
+       *  is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase_after(const_iterator __pos)
+      { return iterator(this->_M_erase_after(const_cast<_Node_base*>
+					     (__pos._M_node))); }
+
+      /**
+       *  @brief  Remove a range of elements.
+       *  @param  __pos  Iterator pointing before the first element to be
+       *                 erased.
+       *  @param  __last  Iterator pointing to one past the last element to be
+       *                  erased.
+       *  @return  @ __last.
+       *
+       *  This function will erase the elements in the range
+       *  @a (__pos,__last) and shorten the %forward_list accordingly.
+       *
+       *  This operation is linear time in the size of the range and only
+       *  invalidates iterators/references to the element being removed.
+       *  The user is also cautioned that this function only erases the
+       *  elements, and that if the elements themselves are pointers, the
+       *  pointed-to memory is not touched in any way.  Managing the pointer
+       *  is the user's responsibility.
+       */
+      iterator
+      erase_after(const_iterator __pos, const_iterator __last)
+      { return iterator(this->_M_erase_after(const_cast<_Node_base*>
+					     (__pos._M_node),
+					     const_cast<_Node_base*>
+					     (__last._M_node))); }
+
+      /**
+       *  @brief  Swaps data with another %forward_list.
+       *  @param  __list  A %forward_list of the same element and allocator
+       *                  types.
+       *
+       *  This exchanges the elements between two lists in constant
+       *  time.  Note that the global std::swap() function is
+       *  specialized such that std::swap(l1,l2) will feed to this
+       *  function.
+       */
+      void
+      swap(forward_list& __list)
+      noexcept(_Node_alloc_traits::_S_nothrow_swap())
+      {
+        std::swap(this->_M_impl._M_head._M_next,
+		  __list._M_impl._M_head._M_next);
+	_Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(),
+                                       __list._M_get_Node_allocator());
+      }
+
+      /**
+       *  @brief Resizes the %forward_list to the specified number of
+       *         elements.
+       *  @param __sz Number of elements the %forward_list should contain.
+       *
+       *  This function will %resize the %forward_list to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %forward_list's current number of elements the %forward_list
+       *  is truncated, otherwise the %forward_list is extended and the
+       *  new elements are default constructed.
+       */
+      void
+      resize(size_type __sz);
+
+      /**
+       *  @brief Resizes the %forward_list to the specified number of
+       *         elements.
+       *  @param __sz Number of elements the %forward_list should contain.
+       *  @param __val Data with which new elements should be populated.
+       *
+       *  This function will %resize the %forward_list to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %forward_list's current number of elements the %forward_list
+       *  is truncated, otherwise the %forward_list is extended and new
+       *  elements are populated with given data.
+       */
+      void
+      resize(size_type __sz, const value_type& __val);
+
+      /**
+       *  @brief  Erases all the elements.
+       *
+       *  Note that this function only erases
+       *  the elements, and that if the elements themselves are
+       *  pointers, the pointed-to memory is not touched in any way.
+       *  Managing the pointer is the user's responsibility.
+       */
+      void
+      clear() noexcept
+      { this->_M_erase_after(&this->_M_impl._M_head, 0); }
+
+      // 23.3.4.6 forward_list operations:
+
+      /**
+       *  @brief  Insert contents of another %forward_list.
+       *  @param  __pos  Iterator referencing the element to insert after.
+       *  @param  __list  Source list.
+       *
+       *  The elements of @a list are inserted in constant time after
+       *  the element referenced by @a pos.  @a list becomes an empty
+       *  list.
+       *
+       *  Requires this != @a x.
+       */
+      void
+      splice_after(const_iterator __pos, forward_list&& __list)
+      {
+	if (!__list.empty())
+	  _M_splice_after(__pos, __list.before_begin(), __list.end());
+      }
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list)
+      { splice_after(__pos, std::move(__list)); }
+
+      /**
+       *  @brief  Insert element from another %forward_list.
+       *  @param  __pos  Iterator referencing the element to insert after.
+       *  @param  __list  Source list.
+       *  @param  __i   Iterator referencing the element before the element
+       *                to move.
+       *
+       *  Removes the element in list @a list referenced by @a i and
+       *  inserts it into the current list after @a pos.
+       */
+      void
+      splice_after(const_iterator __pos, forward_list&& __list,
+                   const_iterator __i);
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list,
+                   const_iterator __i)
+      { splice_after(__pos, std::move(__list), __i); }
+
+      /**
+       *  @brief  Insert range from another %forward_list.
+       *  @param  __pos  Iterator referencing the element to insert after.
+       *  @param  __list  Source list.
+       *  @param  __before  Iterator referencing before the start of range
+       *                    in list.
+       *  @param  __last  Iterator referencing the end of range in list.
+       *
+       *  Removes elements in the range (__before,__last) and inserts them
+       *  after @a __pos in constant time.
+       *
+       *  Undefined if @a __pos is in (__before,__last).
+       */
+      void
+      splice_after(const_iterator __pos, forward_list&&,
+                   const_iterator __before, const_iterator __last)
+      { _M_splice_after(__pos, __before, __last); }
+
+      void
+      splice_after(const_iterator __pos, forward_list&,
+                   const_iterator __before, const_iterator __last)
+      { _M_splice_after(__pos, __before, __last); }
+
+      /**
+       *  @brief  Remove all elements equal to value.
+       *  @param  __val  The value to remove.
+       *
+       *  Removes every element in the list equal to @a __val.
+       *  Remaining elements stay in list order.  Note that this
+       *  function only erases the elements, and that if the elements
+       *  themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      void
+      remove(const _Tp& __val);
+
+      /**
+       *  @brief  Remove all elements satisfying a predicate.
+       *  @param  __pred  Unary predicate function or object.
+       *
+       *  Removes every element in the list for which the predicate
+       *  returns true.  Remaining elements stay in list order.  Note
+       *  that this function only erases the elements, and that if the
+       *  elements themselves are pointers, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      template<typename _Pred>
+        void
+        remove_if(_Pred __pred);
+
+      /**
+       *  @brief  Remove consecutive duplicate elements.
+       *
+       *  For each consecutive set of elements with the same value,
+       *  remove all but the first one.  Remaining elements stay in
+       *  list order.  Note that this function only erases the
+       *  elements, and that if the elements themselves are pointers,
+       *  the pointed-to memory is not touched in any way.  Managing
+       *  the pointer is the user's responsibility.
+       */
+      void
+      unique()
+      { unique(std::equal_to<_Tp>()); }
+
+      /**
+       *  @brief  Remove consecutive elements satisfying a predicate.
+       *  @param  __binary_pred  Binary predicate function or object.
+       *
+       *  For each consecutive set of elements [first,last) that
+       *  satisfy predicate(first,i) where i is an iterator in
+       *  [first,last), remove all but the first one.  Remaining
+       *  elements stay in list order.  Note that this function only
+       *  erases the elements, and that if the elements themselves are
+       *  pointers, the pointed-to memory is not touched in any way.
+       *  Managing the pointer is the user's responsibility.
+       */
+      template<typename _BinPred>
+        void
+        unique(_BinPred __binary_pred);
+
+      /**
+       *  @brief  Merge sorted lists.
+       *  @param  __list  Sorted list to merge.
+       *
+       *  Assumes that both @a list and this list are sorted according to
+       *  operator<().  Merges elements of @a __list into this list in
+       *  sorted order, leaving @a __list empty when complete.  Elements in
+       *  this list precede elements in @a __list that are equal.
+       */
+      void
+      merge(forward_list&& __list)
+      { merge(std::move(__list), std::less<_Tp>()); }
+
+      void
+      merge(forward_list& __list)
+      { merge(std::move(__list)); }
+
+      /**
+       *  @brief  Merge sorted lists according to comparison function.
+       *  @param  __list  Sorted list to merge.
+       *  @param  __comp Comparison function defining sort order.
+       *
+       *  Assumes that both @a __list and this list are sorted according to
+       *  comp.  Merges elements of @a __list into this list
+       *  in sorted order, leaving @a __list empty when complete.  Elements
+       *  in this list precede elements in @a __list that are equivalent
+       *  according to comp().
+       */
+      template<typename _Comp>
+        void
+        merge(forward_list&& __list, _Comp __comp);
+
+      template<typename _Comp>
+        void
+        merge(forward_list& __list, _Comp __comp)
+        { merge(std::move(__list), __comp); }
+
+      /**
+       *  @brief  Sort the elements of the list.
+       *
+       *  Sorts the elements of this list in NlogN time.  Equivalent
+       *  elements remain in list order.
+       */
+      void
+      sort()
+      { sort(std::less<_Tp>()); }
+
+      /**
+       *  @brief  Sort the forward_list using a comparison function.
+       *
+       *  Sorts the elements of this list in NlogN time.  Equivalent
+       *  elements remain in list order.
+       */
+      template<typename _Comp>
+        void
+        sort(_Comp __comp);
+
+      /**
+       *  @brief  Reverse the elements in list.
+       *
+       *  Reverse the order of elements in the list in linear time.
+       */
+      void
+      reverse() noexcept
+      { this->_M_impl._M_head._M_reverse_after(); }
+
+    private:
+      // Called by the range constructor to implement [23.3.4.2]/9
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first, _InputIterator __last);
+
+      // Called by forward_list(n,v,a), and the range constructor when it
+      // turns out to be the same thing.
+      void
+      _M_fill_initialize(size_type __n, const value_type& __value);
+
+      // Called by splice_after and insert_after.
+      iterator
+      _M_splice_after(const_iterator __pos, const_iterator __before,
+		      const_iterator __last);
+
+      // Called by forward_list(n).
+      void
+      _M_default_initialize(size_type __n);
+
+      // Called by resize(sz).
+      void
+      _M_default_insert_after(const_iterator __pos, size_type __n);
+
+      // Called by operator=(forward_list&&)
+      void
+      _M_move_assign(forward_list&& __list, std::true_type) noexcept
+      {
+        clear();
+        std::swap(this->_M_impl._M_head._M_next,
+                  __list._M_impl._M_head._M_next);
+        std::__alloc_on_move(this->_M_get_Node_allocator(),
+                             __list._M_get_Node_allocator());
+      }
+
+      // Called by operator=(forward_list&&)
+      void
+      _M_move_assign(forward_list&& __list, std::false_type)
+      {
+        if (__list._M_get_Node_allocator() == this->_M_get_Node_allocator())
+          _M_move_assign(std::move(__list), std::true_type());
+        else
+	  // The rvalue's allocator cannot be moved, or is not equal,
+	  // so we need to individually move each element.
+	  this->assign(std::__make_move_if_noexcept_iterator(__list.begin()),
+		       std::__make_move_if_noexcept_iterator(__list.end()));
+      }
+
+      // Called by assign(_InputIterator, _InputIterator) if _Tp is
+      // CopyAssignable.
+      template<typename _InputIterator>
+	void
+        _M_assign(_InputIterator __first, _InputIterator __last, true_type)
+	{
+	  auto __prev = before_begin();
+	  auto __curr = begin();
+	  auto __end = end();
+	  while (__curr != __end && __first != __last)
+	    {
+	      *__curr = *__first;
+	      ++__prev;
+	      ++__curr;
+	      ++__first;
+	    }
+	  if (__first != __last)
+	    insert_after(__prev, __first, __last);
+	  else if (__curr != __end)
+	    erase_after(__prev, __end);
+        }
+
+      // Called by assign(_InputIterator, _InputIterator) if _Tp is not
+      // CopyAssignable.
+      template<typename _InputIterator>
+	void
+        _M_assign(_InputIterator __first, _InputIterator __last, false_type)
+	{
+	  clear();
+	  insert_after(cbefore_begin(), __first, __last);
+	}
+
+      // Called by assign(size_type, const _Tp&) if Tp is CopyAssignable
+      void
+      _M_assign_n(size_type __n, const _Tp& __val, true_type)
+      {
+	auto __prev = before_begin();
+	auto __curr = begin();
+	auto __end = end();
+	while (__curr != __end && __n > 0)
+	  {
+	    *__curr = __val;
+	    ++__prev;
+	    ++__curr;
+	    --__n;
+	  }
+	if (__n > 0)
+	  insert_after(__prev, __n, __val);
+	else if (__curr != __end)
+	  erase_after(__prev, __end);
+      }
+
+      // Called by assign(size_type, const _Tp&) if Tp is non-CopyAssignable
+      void
+      _M_assign_n(size_type __n, const _Tp& __val, false_type)
+      {
+	clear();
+	insert_after(cbefore_begin(), __n, __val);
+      }
+    };
+
+  /**
+   *  @brief  Forward list equality comparison.
+   *  @param  __lx  A %forward_list
+   *  @param  __ly  A %forward_list of the same type as @a __lx.
+   *  @return  True iff the elements of the forward lists are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the number of 
+   *  elements of the forward lists.  Deques are considered equivalent
+   *  if corresponding elements compare equal.
+   */
+  template<typename _Tp, typename _Alloc>
+    bool
+    operator==(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly);
+
+  /**
+   *  @brief  Forward list ordering relation.
+   *  @param  __lx  A %forward_list.
+   *  @param  __ly  A %forward_list of the same type as @a __lx.
+   *  @return  True iff @a __lx is lexicographically less than @a __ly.
+   *
+   *  This is a total ordering relation.  It is linear in the number of 
+   *  elements of the forward lists.  The elements must be comparable
+   *  with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+   */
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const forward_list<_Tp, _Alloc>& __lx,
+              const forward_list<_Tp, _Alloc>& __ly)
+    { return std::lexicographical_compare(__lx.cbegin(), __lx.cend(),
+					  __ly.cbegin(), __ly.cend()); }
+
+  /// Based on operator==
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__lx == __ly); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const forward_list<_Tp, _Alloc>& __lx,
+              const forward_list<_Tp, _Alloc>& __ly)
+    { return (__ly < __lx); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__lx < __ly); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__ly < __lx); }
+
+  /// See std::forward_list::swap().
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(forward_list<_Tp, _Alloc>& __lx,
+	 forward_list<_Tp, _Alloc>& __ly)
+    { __lx.swap(__ly); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif // _FORWARD_LIST_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/forward_list.tcc b/gcc-4.9/libstdc++-v3/include/bits/forward_list.tcc
new file mode 100644
index 0000000..2d83171
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/forward_list.tcc
@@ -0,0 +1,511 @@
+// <forward_list.tcc> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/forward_list.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{forward_list}
+ */
+
+#ifndef _FORWARD_LIST_TCC
+#define _FORWARD_LIST_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  template<typename _Tp, typename _Alloc>
+    _Fwd_list_base<_Tp, _Alloc>::
+    _Fwd_list_base(_Fwd_list_base&& __lst, const _Node_alloc_type& __a)
+    : _M_impl(__a)
+    {
+      if (__lst._M_get_Node_allocator() == __a)
+	{
+	  this->_M_impl._M_head._M_next = __lst._M_impl._M_head._M_next;
+	  __lst._M_impl._M_head._M_next = 0;
+	}
+      else
+        {
+          this->_M_impl._M_head._M_next = 0;
+          _Fwd_list_node_base* __to = &this->_M_impl._M_head;
+          _Node* __curr = static_cast<_Node*>(__lst._M_impl._M_head._M_next);
+
+          while (__curr)
+            {
+              __to->_M_next =
+                _M_create_node(std::move_if_noexcept(*__curr->_M_valptr()));
+              __to = __to->_M_next;
+              __curr = static_cast<_Node*>(__curr->_M_next);
+            }
+        }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      _Fwd_list_node_base*
+      _Fwd_list_base<_Tp, _Alloc>::
+      _M_insert_after(const_iterator __pos, _Args&&... __args)
+      {
+        _Fwd_list_node_base* __to
+	  = const_cast<_Fwd_list_node_base*>(__pos._M_node);
+	_Node* __thing = _M_create_node(std::forward<_Args>(__args)...);
+        __thing->_M_next = __to->_M_next;
+        __to->_M_next = __thing;
+        return __to->_M_next;
+      }
+
+  template<typename _Tp, typename _Alloc>
+    _Fwd_list_node_base*
+    _Fwd_list_base<_Tp, _Alloc>::
+    _M_erase_after(_Fwd_list_node_base* __pos)
+    {
+      _Node* __curr = static_cast<_Node*>(__pos->_M_next);
+      __pos->_M_next = __curr->_M_next;
+      _Tp_alloc_type __a(_M_get_Node_allocator());
+      allocator_traits<_Tp_alloc_type>::destroy(__a, __curr->_M_valptr());
+      __curr->~_Node();
+      _M_put_node(__curr);
+      return __pos->_M_next;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    _Fwd_list_node_base*
+    _Fwd_list_base<_Tp, _Alloc>::
+    _M_erase_after(_Fwd_list_node_base* __pos, 
+                   _Fwd_list_node_base* __last)
+    {
+      _Node* __curr = static_cast<_Node*>(__pos->_M_next);
+      while (__curr != __last)
+        {
+          _Node* __temp = __curr;
+          __curr = static_cast<_Node*>(__curr->_M_next);
+	  _Tp_alloc_type __a(_M_get_Node_allocator());
+	  allocator_traits<_Tp_alloc_type>::destroy(__a, __temp->_M_valptr());
+	  __temp->~_Node();
+          _M_put_node(__temp);
+        }
+      __pos->_M_next = __last;
+      return __last;
+    }
+
+  // Called by the range constructor to implement [23.3.4.2]/9
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      forward_list<_Tp, _Alloc>::
+      _M_range_initialize(_InputIterator __first, _InputIterator __last)
+      {
+        _Node_base* __to = &this->_M_impl._M_head;
+        for (; __first != __last; ++__first)
+          {
+            __to->_M_next = this->_M_create_node(*__first);
+            __to = __to->_M_next;
+          }
+      }
+
+  // Called by forward_list(n,v,a).
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    _M_fill_initialize(size_type __n, const value_type& __value)
+    {
+      _Node_base* __to = &this->_M_impl._M_head;
+      for (; __n; --__n)
+        {
+          __to->_M_next = this->_M_create_node(__value);
+          __to = __to->_M_next;
+        }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    _M_default_initialize(size_type __n)
+    {
+      _Node_base* __to = &this->_M_impl._M_head;
+      for (; __n; --__n)
+        {
+          __to->_M_next = this->_M_create_node();
+          __to = __to->_M_next;
+        }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    forward_list<_Tp, _Alloc>&
+    forward_list<_Tp, _Alloc>::
+    operator=(const forward_list& __list)
+    {
+      if (&__list != this)
+        {
+	  if (_Node_alloc_traits::_S_propagate_on_copy_assign())
+	    {
+              auto& __this_alloc = this->_M_get_Node_allocator();
+              auto& __that_alloc = __list._M_get_Node_allocator();
+              if (!_Node_alloc_traits::_S_always_equal()
+	          && __this_alloc != __that_alloc)
+	        {
+		  // replacement allocator cannot free existing storage
+		  clear();
+		}
+	      std::__alloc_on_copy(__this_alloc, __that_alloc);
+            }
+	  assign(__list.cbegin(), __list.cend());
+        }
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    _M_default_insert_after(const_iterator __pos, size_type __n)
+    {
+      const_iterator __saved_pos = __pos;
+      __try
+	{
+	  for (; __n; --__n)
+	    __pos = emplace_after(__pos);
+	}
+      __catch(...)
+	{
+	  erase_after(__saved_pos, ++__pos);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    resize(size_type __sz)
+    {
+      iterator __k = before_begin();
+
+      size_type __len = 0;
+      while (__k._M_next() != end() && __len < __sz)
+        {
+          ++__k;
+          ++__len;
+        }
+      if (__len == __sz)
+        erase_after(__k, end());
+      else
+	_M_default_insert_after(__k, __sz - __len);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    resize(size_type __sz, const value_type& __val)
+    {
+      iterator __k = before_begin();
+
+      size_type __len = 0;
+      while (__k._M_next() != end() && __len < __sz)
+        {
+          ++__k;
+          ++__len;
+        }
+      if (__len == __sz)
+        erase_after(__k, end());
+      else
+        insert_after(__k, __sz - __len, __val);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename forward_list<_Tp, _Alloc>::iterator
+    forward_list<_Tp, _Alloc>::
+    _M_splice_after(const_iterator __pos,
+		    const_iterator __before, const_iterator __last)
+    {
+      _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node);
+      _Node_base* __b = const_cast<_Node_base*>(__before._M_node);
+      _Node_base* __end = __b;
+
+      while (__end && __end->_M_next != __last._M_node)
+	__end = __end->_M_next;
+
+      if (__b != __end)
+	return iterator(__tmp->_M_transfer_after(__b, __end));      
+      else
+	return iterator(__tmp);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    splice_after(const_iterator __pos, forward_list&&,
+		 const_iterator __i)
+    {
+      const_iterator __j = __i;
+      ++__j;
+
+      if (__pos == __i || __pos == __j)
+	return;
+
+      _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node);
+      __tmp->_M_transfer_after(const_cast<_Node_base*>(__i._M_node),
+			       const_cast<_Node_base*>(__j._M_node));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename forward_list<_Tp, _Alloc>::iterator
+    forward_list<_Tp, _Alloc>::
+    insert_after(const_iterator __pos, size_type __n, const _Tp& __val)
+    {
+      if (__n)
+	{
+	  forward_list __tmp(__n, __val, get_allocator());
+	  return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end());
+	}
+      else
+	return iterator(const_cast<_Node_base*>(__pos._M_node));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator, typename>
+      typename forward_list<_Tp, _Alloc>::iterator
+      forward_list<_Tp, _Alloc>::
+      insert_after(const_iterator __pos,
+		   _InputIterator __first, _InputIterator __last)
+      {
+	forward_list __tmp(__first, __last, get_allocator());
+	if (!__tmp.empty())
+	  return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end());
+	else
+	  return iterator(const_cast<_Node_base*>(__pos._M_node));
+      }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    remove(const _Tp& __val)
+    {
+      _Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
+      _Node* __extra = 0;
+
+      while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next))
+        {
+          if (*__tmp->_M_valptr() == __val)
+	    {
+	      if (__tmp->_M_valptr() != std::__addressof(__val))
+		{
+		  this->_M_erase_after(__curr);
+		  continue;
+		}
+	      else
+		__extra = __curr;
+	    }
+	  __curr = static_cast<_Node*>(__curr->_M_next);
+        }
+
+      if (__extra)
+	this->_M_erase_after(__extra);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _Pred>
+      void
+      forward_list<_Tp, _Alloc>::
+      remove_if(_Pred __pred)
+      {
+	_Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
+        while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next))
+          {
+            if (__pred(*__tmp->_M_valptr()))
+              this->_M_erase_after(__curr);
+            else
+              __curr = static_cast<_Node*>(__curr->_M_next);
+          }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _BinPred>
+      void
+      forward_list<_Tp, _Alloc>::
+      unique(_BinPred __binary_pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        if (__first == __last)
+          return;
+        iterator __next = __first;
+        while (++__next != __last)
+        {
+          if (__binary_pred(*__first, *__next))
+            erase_after(__first);
+          else
+            __first = __next;
+          __next = __first;
+        }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _Comp>
+      void
+      forward_list<_Tp, _Alloc>::
+      merge(forward_list&& __list, _Comp __comp)
+      {
+        _Node_base* __node = &this->_M_impl._M_head;
+        while (__node->_M_next && __list._M_impl._M_head._M_next)
+          {
+            if (__comp(*static_cast<_Node*>
+                       (__list._M_impl._M_head._M_next)->_M_valptr(),
+                       *static_cast<_Node*>
+                       (__node->_M_next)->_M_valptr()))
+              __node->_M_transfer_after(&__list._M_impl._M_head,
+                                        __list._M_impl._M_head._M_next);
+            __node = __node->_M_next;
+          }
+        if (__list._M_impl._M_head._M_next)
+          {
+            __node->_M_next = __list._M_impl._M_head._M_next;
+            __list._M_impl._M_head._M_next = 0;
+          }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    bool
+    operator==(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    {
+      //  We don't have size() so we need to walk through both lists
+      //  making sure both iterators are valid.
+      auto __ix = __lx.cbegin();
+      auto __iy = __ly.cbegin();
+      while (__ix != __lx.cend() && __iy != __ly.cend())
+        {
+          if (*__ix != *__iy)
+            return false;
+          ++__ix;
+          ++__iy;
+        }
+      if (__ix == __lx.cend() && __iy == __ly.cend())
+        return true;
+      else
+        return false;
+    }
+
+  template<typename _Tp, class _Alloc>
+    template<typename _Comp>
+      void
+      forward_list<_Tp, _Alloc>::
+      sort(_Comp __comp)
+      {
+        // If `next' is 0, return immediately.
+        _Node* __list = static_cast<_Node*>(this->_M_impl._M_head._M_next);
+        if (!__list)
+          return;
+
+        unsigned long __insize = 1;
+
+        while (1)
+          {
+            _Node* __p = __list;
+            __list = 0;
+            _Node* __tail = 0;
+
+            // Count number of merges we do in this pass.
+            unsigned long __nmerges = 0;
+
+            while (__p)
+              {
+                ++__nmerges;
+                // There exists a merge to be done.
+                // Step `insize' places along from p.
+                _Node* __q = __p;
+                unsigned long __psize = 0;
+                for (unsigned long __i = 0; __i < __insize; ++__i)
+                  {
+                    ++__psize;
+                    __q = static_cast<_Node*>(__q->_M_next);
+                    if (!__q)
+                      break;
+                  }
+
+                // If q hasn't fallen off end, we have two lists to merge.
+                unsigned long __qsize = __insize;
+
+                // Now we have two lists; merge them.
+                while (__psize > 0 || (__qsize > 0 && __q))
+                  {
+                    // Decide whether next node of merge comes from p or q.
+                    _Node* __e;
+                    if (__psize == 0)
+                      {
+                        // p is empty; e must come from q.
+                        __e = __q;
+                        __q = static_cast<_Node*>(__q->_M_next);
+                        --__qsize;
+                      }
+                    else if (__qsize == 0 || !__q)
+                      {
+                        // q is empty; e must come from p.
+                        __e = __p;
+                        __p = static_cast<_Node*>(__p->_M_next);
+                        --__psize;
+                      }
+                    else if (__comp(*__p->_M_valptr(), *__q->_M_valptr()))
+                      {
+                        // First node of p is lower; e must come from p.
+                        __e = __p;
+                        __p = static_cast<_Node*>(__p->_M_next);
+                        --__psize;
+                      }
+                    else
+                      {
+                        // First node of q is lower; e must come from q.
+                        __e = __q;
+                        __q = static_cast<_Node*>(__q->_M_next);
+                        --__qsize;
+                      }
+
+                    // Add the next node to the merged list.
+                    if (__tail)
+                      __tail->_M_next = __e;
+                    else
+                      __list = __e;
+                    __tail = __e;
+                  }
+
+                // Now p has stepped `insize' places along, and q has too.
+                __p = __q;
+              }
+            __tail->_M_next = 0;
+
+            // If we have done only one merge, we're finished.
+            // Allow for nmerges == 0, the empty list case.
+            if (__nmerges <= 1)
+              {
+                this->_M_impl._M_head._M_next = __list;
+                return;
+              }
+
+            // Otherwise repeat, merging lists twice the size.
+            __insize *= 2;
+          }
+      }
+ 
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _FORWARD_LIST_TCC */
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/fstream.tcc b/gcc-4.9/libstdc++-v3/include/bits/fstream.tcc
new file mode 100644
index 0000000..21a67cd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/fstream.tcc
@@ -0,0 +1,984 @@
+// File based streams -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/fstream.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{fstream}
+ */
+
+//
+// ISO C++ 14882: 27.8  File-based streams
+//
+
+#ifndef _FSTREAM_TCC
+#define _FSTREAM_TCC 1
+
+#pragma GCC system_header
+
+#include <bits/cxxabi_forced.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    _M_allocate_internal_buffer()
+    {
+      // Allocate internal buffer only if one doesn't already exist
+      // (either allocated or provided by the user via setbuf).
+      if (!_M_buf_allocated && !_M_buf)
+	{
+	  _M_buf = new char_type[_M_buf_size];
+	  _M_buf_allocated = true;
+	}
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    _M_destroy_internal_buffer() throw()
+    {
+      if (_M_buf_allocated)
+	{
+	  delete [] _M_buf;
+	  _M_buf = 0;
+	  _M_buf_allocated = false;
+	}
+      delete [] _M_ext_buf;
+      _M_ext_buf = 0;
+      _M_ext_buf_size = 0;
+      _M_ext_next = 0;
+      _M_ext_end = 0;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_filebuf<_CharT, _Traits>::
+    basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
+    _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
+    _M_state_last(), _M_buf(0), _M_buf_size(BUFSIZ),
+    _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), 
+    _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
+    _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
+    _M_ext_end(0)
+    {
+      if (has_facet<__codecvt_type>(this->_M_buf_locale))
+	_M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    open(const char* __s, ios_base::openmode __mode)
+    {
+      __filebuf_type *__ret = 0;
+      if (!this->is_open())
+	{
+	  _M_file.open(__s, __mode);
+	  if (this->is_open())
+	    {
+	      _M_allocate_internal_buffer();
+	      _M_mode = __mode;
+
+	      // Setup initial buffer to 'uncommitted' mode.
+	      _M_reading = false;
+	      _M_writing = false;
+	      _M_set_buffer(-1);
+
+	      // Reset to initial state.
+	      _M_state_last = _M_state_cur = _M_state_beg;
+
+	      // 27.8.1.3,4
+	      if ((__mode & ios_base::ate)
+		  && this->seekoff(0, ios_base::end, __mode)
+		  == pos_type(off_type(-1)))
+		this->close();
+	      else
+		__ret = this;
+	    }
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    close()
+    {
+      if (!this->is_open())
+	return 0;
+
+      bool __testfail = false;
+      {
+	// NB: Do this here so that re-opened filebufs will be cool...
+	struct __close_sentry
+	{
+	  basic_filebuf *__fb;
+	  __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
+	  ~__close_sentry ()
+	  {
+	    __fb->_M_mode = ios_base::openmode(0);
+	    __fb->_M_pback_init = false;
+	    __fb->_M_destroy_internal_buffer();
+	    __fb->_M_reading = false;
+	    __fb->_M_writing = false;
+	    __fb->_M_set_buffer(-1);
+	    __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
+	  }
+	} __cs (this);
+
+	__try
+	  {
+	    if (!_M_terminate_output())
+	      __testfail = true;
+	  }
+	__catch(__cxxabiv1::__forced_unwind&)
+	  {
+	    _M_file.close();
+	    __throw_exception_again;
+	  }
+	__catch(...)
+	  { __testfail = true; }
+      }
+
+      if (!_M_file.close())
+	__testfail = true;
+
+      if (__testfail)
+	return 0;
+      else
+	return this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    showmanyc()
+    {
+      streamsize __ret = -1;
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin && this->is_open())
+	{
+	  // For a stateful encoding (-1) the pending sequence might be just
+	  // shift and unshift prefixes with no actual character.
+	  __ret = this->egptr() - this->gptr();
+
+#if _GLIBCXX_HAVE_DOS_BASED_FILESYSTEM
+	  // About this workaround, see libstdc++/20806.
+	  const bool __testbinary = _M_mode & ios_base::binary;
+	  if (__check_facet(_M_codecvt).encoding() >= 0
+	      && __testbinary)
+#else
+	  if (__check_facet(_M_codecvt).encoding() >= 0)
+#endif
+	    __ret += _M_file.showmanyc() / _M_codecvt->max_length();
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin)
+	{
+	  if (_M_writing)
+	    {
+	      if (overflow() == traits_type::eof())
+		return __ret;
+	      _M_set_buffer(-1);
+	      _M_writing = false;
+	    }
+	  // Check for pback madness, and if so switch back to the
+	  // normal buffers and jet outta here before expensive
+	  // fileops happen...
+	  _M_destroy_pback();
+
+	  if (this->gptr() < this->egptr())
+	    return traits_type::to_int_type(*this->gptr());
+
+	  // Get and convert input sequence.
+	  const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
+
+	  // Will be set to true if ::read() returns 0 indicating EOF.
+	  bool __got_eof = false;
+	  // Number of internal characters produced.
+	  streamsize __ilen = 0;
+	  codecvt_base::result __r = codecvt_base::ok;
+	  if (__check_facet(_M_codecvt).always_noconv())
+	    {
+	      __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
+				      __buflen);
+	      if (__ilen == 0)
+		__got_eof = true;
+	    }
+	  else
+	    {
+              // Worst-case number of external bytes.
+	      // XXX Not done encoding() == -1.
+	      const int __enc = _M_codecvt->encoding();
+	      streamsize __blen; // Minimum buffer size.
+	      streamsize __rlen; // Number of chars to read.
+	      if (__enc > 0)
+		__blen = __rlen = __buflen * __enc;
+	      else
+		{
+		  __blen = __buflen + _M_codecvt->max_length() - 1;
+		  __rlen = __buflen;
+		}
+	      const streamsize __remainder = _M_ext_end - _M_ext_next;
+	      __rlen = __rlen > __remainder ? __rlen - __remainder : 0;
+
+	      // An imbue in 'read' mode implies first converting the external
+	      // chars already present.
+	      if (_M_reading && this->egptr() == this->eback() && __remainder)
+		__rlen = 0;
+
+	      // Allocate buffer if necessary and move unconverted
+	      // bytes to front.
+	      if (_M_ext_buf_size < __blen)
+		{
+		  char* __buf = new char[__blen];
+		  if (__remainder)
+		    __builtin_memcpy(__buf, _M_ext_next, __remainder);
+
+		  delete [] _M_ext_buf;
+		  _M_ext_buf = __buf;
+		  _M_ext_buf_size = __blen;
+		}
+	      else if (__remainder)
+		__builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
+
+	      _M_ext_next = _M_ext_buf;
+	      _M_ext_end = _M_ext_buf + __remainder;
+	      _M_state_last = _M_state_cur;
+
+	      do
+		{
+		  if (__rlen > 0)
+		    {
+		      // Sanity check!
+		      // This may fail if the return value of
+		      // codecvt::max_length() is bogus.
+		      if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
+			{
+			  __throw_ios_failure(__N("basic_filebuf::underflow "
+					      "codecvt::max_length() "
+					      "is not valid"));
+			}
+		      streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
+		      if (__elen == 0)
+			__got_eof = true;
+		      else if (__elen == -1)
+			break;
+		      _M_ext_end += __elen;
+		    }
+
+		  char_type* __iend = this->eback();
+		  if (_M_ext_next < _M_ext_end)
+		    __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
+					 _M_ext_end, _M_ext_next,
+					 this->eback(),
+					 this->eback() + __buflen, __iend);
+		  if (__r == codecvt_base::noconv)
+		    {
+		      size_t __avail = _M_ext_end - _M_ext_buf;
+		      __ilen = std::min(__avail, __buflen);
+		      traits_type::copy(this->eback(),
+					reinterpret_cast<char_type*>
+					(_M_ext_buf), __ilen);
+		      _M_ext_next = _M_ext_buf + __ilen;
+		    }
+		  else
+		    __ilen = __iend - this->eback();
+
+		  // _M_codecvt->in may return error while __ilen > 0: this is
+		  // ok, and actually occurs in case of mixed encodings (e.g.,
+		  // XML files).
+		  if (__r == codecvt_base::error)
+		    break;
+
+		  __rlen = 1;
+		}
+	      while (__ilen == 0 && !__got_eof);
+	    }
+
+	  if (__ilen > 0)
+	    {
+	      _M_set_buffer(__ilen);
+	      _M_reading = true;
+	      __ret = traits_type::to_int_type(*this->gptr());
+	    }
+	  else if (__got_eof)
+	    {
+	      // If the actual end of file is reached, set 'uncommitted'
+	      // mode, thus allowing an immediate write without an
+	      // intervening seek.
+	      _M_set_buffer(-1);
+	      _M_reading = false;
+	      // However, reaching it while looping on partial means that
+	      // the file has got an incomplete character.
+	      if (__r == codecvt_base::partial)
+		__throw_ios_failure(__N("basic_filebuf::underflow "
+				    "incomplete character in file"));
+	    }
+	  else if (__r == codecvt_base::error)
+	    __throw_ios_failure(__N("basic_filebuf::underflow "
+				"invalid byte sequence in file"));
+	  else
+	    __throw_ios_failure(__N("basic_filebuf::underflow "
+				"error reading the file"));
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    pbackfail(int_type __i)
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin)
+	{
+	  if (_M_writing)
+	    {
+	      if (overflow() == traits_type::eof())
+		return __ret;
+	      _M_set_buffer(-1);
+	      _M_writing = false;
+	    }
+	  // Remember whether the pback buffer is active, otherwise below
+	  // we may try to store in it a second char (libstdc++/9761).
+	  const bool __testpb = _M_pback_init;
+	  const bool __testeof = traits_type::eq_int_type(__i, __ret);
+	  int_type __tmp;
+	  if (this->eback() < this->gptr())
+	    {
+	      this->gbump(-1);
+	      __tmp = traits_type::to_int_type(*this->gptr());
+	    }
+	  else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
+	    {
+	      __tmp = this->underflow();
+	      if (traits_type::eq_int_type(__tmp, __ret))
+		return __ret;
+	    }
+	  else
+	    {
+	      // At the beginning of the buffer, need to make a
+	      // putback position available.  But the seek may fail
+	      // (f.i., at the beginning of a file, see
+	      // libstdc++/9439) and in that case we return
+	      // traits_type::eof().
+	      return __ret;
+	    }
+
+	  // Try to put back __i into input sequence in one of three ways.
+	  // Order these tests done in is unspecified by the standard.
+	  if (!__testeof && traits_type::eq_int_type(__i, __tmp))
+	    __ret = __i;
+	  else if (__testeof)
+	    __ret = traits_type::not_eof(__i);
+	  else if (!__testpb)
+	    {
+	      _M_create_pback();
+	      _M_reading = true;
+	      *this->gptr() = traits_type::to_char_type(__i);
+	      __ret = __i;
+	    }
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    overflow(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testeof = traits_type::eq_int_type(__c, __ret);
+      const bool __testout = (_M_mode & ios_base::out
+			      || _M_mode & ios_base::app);
+      if (__testout)
+	{
+          if (_M_reading)
+            {
+              _M_destroy_pback();
+              const int __gptr_off = _M_get_ext_pos(_M_state_last);
+              if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
+                  == pos_type(off_type(-1)))
+                return __ret;
+            }
+	  if (this->pbase() < this->pptr())
+	    {
+	      // If appropriate, append the overflow char.
+	      if (!__testeof)
+		{
+		  *this->pptr() = traits_type::to_char_type(__c);
+		  this->pbump(1);
+		}
+
+	      // Convert pending sequence to external representation,
+	      // and output.
+	      if (_M_convert_to_external(this->pbase(),
+					 this->pptr() - this->pbase()))
+		{
+		  _M_set_buffer(0);
+		  __ret = traits_type::not_eof(__c);
+		}
+	    }
+	  else if (_M_buf_size > 1)
+	    {
+	      // Overflow in 'uncommitted' mode: set _M_writing, set
+	      // the buffer to the initial 'write' mode, and put __c
+	      // into the buffer.
+	      _M_set_buffer(0);
+	      _M_writing = true;
+	      if (!__testeof)
+		{
+		  *this->pptr() = traits_type::to_char_type(__c);
+		  this->pbump(1);
+		}
+	      __ret = traits_type::not_eof(__c);
+	    }
+	  else
+	    {
+	      // Unbuffered.
+	      char_type __conv = traits_type::to_char_type(__c);
+	      if (__testeof || _M_convert_to_external(&__conv, 1))
+		{
+		  _M_writing = true;
+		  __ret = traits_type::not_eof(__c);
+		}
+	    }
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    basic_filebuf<_CharT, _Traits>::
+    _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
+    {
+      // Sizes of external and pending output.
+      streamsize __elen;
+      streamsize __plen;
+      if (__check_facet(_M_codecvt).always_noconv())
+	{
+	  __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
+	  __plen = __ilen;
+	}
+      else
+	{
+	  // Worst-case number of external bytes needed.
+	  // XXX Not done encoding() == -1.
+	  streamsize __blen = __ilen * _M_codecvt->max_length();
+	  char* __buf = static_cast<char*>(__builtin_alloca(__blen));
+
+	  char* __bend;
+	  const char_type* __iend;
+	  codecvt_base::result __r;
+	  __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
+				__iend, __buf, __buf + __blen, __bend);
+
+	  if (__r == codecvt_base::ok || __r == codecvt_base::partial)
+	    __blen = __bend - __buf;
+	  else if (__r == codecvt_base::noconv)
+	    {
+	      // Same as the always_noconv case above.
+	      __buf = reinterpret_cast<char*>(__ibuf);
+	      __blen = __ilen;
+	    }
+	  else
+	    __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external "
+				    "conversion error"));
+  
+	  __elen = _M_file.xsputn(__buf, __blen);
+	  __plen = __blen;
+
+	  // Try once more for partial conversions.
+	  if (__r == codecvt_base::partial && __elen == __plen)
+	    {
+	      const char_type* __iresume = __iend;
+	      streamsize __rlen = this->pptr() - __iend;
+	      __r = _M_codecvt->out(_M_state_cur, __iresume,
+				    __iresume + __rlen, __iend, __buf,
+				    __buf + __blen, __bend);
+	      if (__r != codecvt_base::error)
+		{
+		  __rlen = __bend - __buf;
+		  __elen = _M_file.xsputn(__buf, __rlen);
+		  __plen = __rlen;
+		}
+	      else
+		__throw_ios_failure(__N("basic_filebuf::_M_convert_to_external "
+					"conversion error"));
+	    }
+	}
+      return __elen == __plen;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    xsgetn(_CharT* __s, streamsize __n)
+    {
+      // Clear out pback buffer before going on to the real deal...
+      streamsize __ret = 0;
+      if (_M_pback_init)
+	{
+	  if (__n > 0 && this->gptr() == this->eback())
+	    {
+	      *__s++ = *this->gptr(); // emulate non-underflowing sbumpc
+	      this->gbump(1);
+	      __ret = 1;
+	      --__n;
+	    }
+	  _M_destroy_pback();
+	}
+      else if (_M_writing)
+	{
+ 	  if (overflow() == traits_type::eof())
+ 	    return __ret;
+ 	  _M_set_buffer(-1);
+ 	  _M_writing = false;
+ 	}
+ 
+      // Optimization in the always_noconv() case, to be generalized in the
+      // future: when __n > __buflen we read directly instead of using the
+      // buffer repeatedly.
+      const bool __testin = _M_mode & ios_base::in;
+      const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
+ 
+      if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
+ 	   && __testin)
+ 	 {
+ 	   // First, copy the chars already present in the buffer.
+ 	   const streamsize __avail = this->egptr() - this->gptr();
+ 	   if (__avail != 0)
+ 	     {
+	       traits_type::copy(__s, this->gptr(), __avail);
+ 	       __s += __avail;
+	       this->setg(this->eback(), this->gptr() + __avail,
+			  this->egptr());
+	       __ret += __avail;
+	       __n -= __avail;
+ 	     }
+ 
+ 	   // Need to loop in case of short reads (relatively common
+ 	   // with pipes).
+ 	   streamsize __len;
+ 	   for (;;)
+ 	     {
+ 	       __len = _M_file.xsgetn(reinterpret_cast<char*>(__s),
+ 				      __n);
+ 	       if (__len == -1)
+ 		 __throw_ios_failure(__N("basic_filebuf::xsgetn "
+ 					 "error reading the file"));
+ 	       if (__len == 0)
+ 		 break;
+ 
+ 	       __n -= __len;
+ 	       __ret += __len;
+ 	       if (__n == 0)
+ 		 break;
+ 
+ 	       __s += __len;
+ 	     }
+ 
+ 	   if (__n == 0)
+ 	     {
+ 	       _M_set_buffer(0);
+ 	       _M_reading = true;
+ 	     }
+ 	   else if (__len == 0)
+ 	     {
+ 	       // If end of file is reached, set 'uncommitted'
+ 	       // mode, thus allowing an immediate write without
+ 	       // an intervening seek.
+ 	       _M_set_buffer(-1);
+ 	       _M_reading = false;
+ 	     }
+ 	 }
+      else
+ 	 __ret += __streambuf_type::xsgetn(__s, __n);
+ 
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    xsputn(const _CharT* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      // Optimization in the always_noconv() case, to be generalized in the
+      // future: when __n is sufficiently large we write directly instead of
+      // using the buffer.
+      const bool __testout = (_M_mode & ios_base::out
+			      || _M_mode & ios_base::app);
+      if (__check_facet(_M_codecvt).always_noconv()
+ 	   && __testout && !_M_reading)
+	{
+	  // Measurement would reveal the best choice.
+	  const streamsize __chunk = 1ul << 10;
+	  streamsize __bufavail = this->epptr() - this->pptr();
+
+	  // Don't mistake 'uncommitted' mode buffered with unbuffered.
+	  if (!_M_writing && _M_buf_size > 1)
+	    __bufavail = _M_buf_size - 1;
+
+	  const streamsize __limit = std::min(__chunk, __bufavail);
+	  if (__n >= __limit)
+	    {
+	      const streamsize __buffill = this->pptr() - this->pbase();
+	      const char* __buf = reinterpret_cast<const char*>(this->pbase());
+	      __ret = _M_file.xsputn_2(__buf, __buffill,
+				       reinterpret_cast<const char*>(__s),
+				       __n);
+	      if (__ret == __buffill + __n)
+		{
+		  _M_set_buffer(0);
+		  _M_writing = true;
+		}
+	      if (__ret > __buffill)
+		__ret -= __buffill;
+	      else
+		__ret = 0;
+	    }
+	  else
+	    __ret = __streambuf_type::xsputn(__s, __n);
+	}
+       else
+	 __ret = __streambuf_type::xsputn(__s, __n);
+       return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    setbuf(char_type* __s, streamsize __n)
+    {
+      if (!this->is_open())
+	{
+	  if (__s == 0 && __n == 0)
+	    _M_buf_size = 1;
+	  else if (__s && __n > 0)
+	    {
+	      // This is implementation-defined behavior, and assumes that
+	      // an external char_type array of length __n exists and has
+	      // been pre-allocated. If this is not the case, things will
+	      // quickly blow up. When __n > 1, __n - 1 positions will be
+	      // used for the get area, __n - 1 for the put area and 1
+	      // position to host the overflow char of a full put area.
+	      // When __n == 1, 1 position will be used for the get area
+	      // and 0 for the put area, as in the unbuffered case above.
+	      _M_buf = __s;
+	      _M_buf_size = __n;
+	    }
+	}
+      return this;
+    }
+
+
+  // According to 27.8.1.4 p11 - 13, seekoff should ignore the last
+  // argument (of type openmode).
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
+    {
+      int __width = 0;
+      if (_M_codecvt)
+	__width = _M_codecvt->encoding();
+      if (__width < 0)
+	__width = 0;
+
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testfail = __off != 0 && __width <= 0;
+      if (this->is_open() && !__testfail)
+	{
+	  // tellg and tellp queries do not affect any state, unless
+	  // ! always_noconv and the put sequence is not empty.
+	  // In that case, determining the position requires converting the
+	  // put sequence. That doesn't use ext_buf, so requires a flush.
+	  bool __no_movement = __way == ios_base::cur && __off == 0
+	    && (!_M_writing || _M_codecvt->always_noconv());
+
+	  // Ditch any pback buffers to avoid confusion.
+	  if (!__no_movement)
+	    _M_destroy_pback();
+
+	  // Correct state at destination. Note that this is the correct
+	  // state for the current position during output, because
+	  // codecvt::unshift() returns the state to the initial state.
+	  // This is also the correct state at the end of the file because
+	  // an unshift sequence should have been written at the end.
+	  __state_type __state = _M_state_beg;
+	  off_type __computed_off = __off * __width;
+	  if (_M_reading && __way == ios_base::cur)
+	    {
+	      __state = _M_state_last;
+	      __computed_off += _M_get_ext_pos(__state);
+	    }
+	  if (!__no_movement)
+	    __ret = _M_seek(__computed_off, __way, __state);
+	  else
+	    {
+	      if (_M_writing)
+		__computed_off = this->pptr() - this->pbase();
+	      
+ 	      off_type __file_off = _M_file.seekoff(0, ios_base::cur);
+ 	      if (__file_off != off_type(-1))
+		{
+		  __ret = __file_off + __computed_off;
+		  __ret.state(__state);
+		}
+	    }
+	}
+      return __ret;
+    }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 171. Strange seekpos() semantics due to joint position
+  // According to the resolution of DR 171, seekpos should ignore the last
+  // argument (of type openmode).
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    seekpos(pos_type __pos, ios_base::openmode)
+    {
+      pos_type __ret =  pos_type(off_type(-1));
+      if (this->is_open())
+	{
+	  // Ditch any pback buffers to avoid confusion.
+	  _M_destroy_pback();
+	  __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      if (_M_terminate_output())
+	{
+	  off_type __file_off = _M_file.seekoff(__off, __way);
+	  if (__file_off != off_type(-1))
+	    {
+	      _M_reading = false;
+	      _M_writing = false;
+	      _M_ext_next = _M_ext_end = _M_ext_buf;
+	      _M_set_buffer(-1);
+	      _M_state_cur = __state;
+	      __ret = __file_off;
+	      __ret.state(_M_state_cur);
+	    }
+	}
+      return __ret;
+    }
+
+  // Returns the distance from the end of the ext buffer to the point
+  // corresponding to gptr(). This is a negative value. Updates __state
+  // from eback() correspondence to gptr().
+  template<typename _CharT, typename _Traits>
+    int basic_filebuf<_CharT, _Traits>::
+    _M_get_ext_pos(__state_type& __state)
+    {
+      if (_M_codecvt->always_noconv())
+        return this->gptr() - this->egptr();
+      else
+        {
+          // Calculate offset from _M_ext_buf that corresponds to
+          // gptr(). Precondition: __state == _M_state_last, which
+          // corresponds to eback().
+          const int __gptr_off =
+            _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
+                               this->gptr() - this->eback());
+          return _M_ext_buf + __gptr_off - _M_ext_end;
+        }
+    }
+    
+  template<typename _CharT, typename _Traits>
+    bool
+    basic_filebuf<_CharT, _Traits>::
+    _M_terminate_output()
+    {
+      // Part one: update the output sequence.
+      bool __testvalid = true;
+      if (this->pbase() < this->pptr())
+	{
+	  const int_type __tmp = this->overflow();
+	  if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+	    __testvalid = false;
+	}
+
+      // Part two: output unshift sequence.
+      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
+	  && __testvalid)
+	{
+	  // Note: this value is arbitrary, since there is no way to
+	  // get the length of the unshift sequence from codecvt,
+	  // without calling unshift.
+	  const size_t __blen = 128;
+	  char __buf[__blen];
+	  codecvt_base::result __r;
+	  streamsize __ilen = 0;
+
+	  do
+	    {
+	      char* __next;
+	      __r = _M_codecvt->unshift(_M_state_cur, __buf,
+					__buf + __blen, __next);
+	      if (__r == codecvt_base::error)
+		__testvalid = false;
+	      else if (__r == codecvt_base::ok ||
+		       __r == codecvt_base::partial)
+		{
+		  __ilen = __next - __buf;
+		  if (__ilen > 0)
+		    {
+		      const streamsize __elen = _M_file.xsputn(__buf, __ilen);
+		      if (__elen != __ilen)
+			__testvalid = false;
+		    }
+		}
+	    }
+	  while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);
+
+	  if (__testvalid)
+	    {
+	      // This second call to overflow() is required by the standard,
+	      // but it's not clear why it's needed, since the output buffer
+	      // should be empty by this point (it should have been emptied
+	      // in the first call to overflow()).
+	      const int_type __tmp = this->overflow();
+	      if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+		__testvalid = false;
+	    }
+	}
+      return __testvalid;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_filebuf<_CharT, _Traits>::
+    sync()
+    {
+      // Make sure that the internal buffer resyncs its idea of
+      // the file position with the external file.
+      int __ret = 0;
+      if (this->pbase() < this->pptr())
+	{
+	  const int_type __tmp = this->overflow();
+	  if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+	    __ret = -1;
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    imbue(const locale& __loc)
+    {
+      bool __testvalid = true;
+
+      const __codecvt_type* _M_codecvt_tmp = 0;
+      if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
+	_M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);
+
+      if (this->is_open())
+	{
+	  // encoding() == -1 is ok only at the beginning.
+	  if ((_M_reading || _M_writing)
+	      && __check_facet(_M_codecvt).encoding() == -1)
+	    __testvalid = false;
+	  else
+	    {
+	      if (_M_reading)
+		{
+		  if (__check_facet(_M_codecvt).always_noconv())
+		    {
+		      if (_M_codecvt_tmp
+			  && !__check_facet(_M_codecvt_tmp).always_noconv())
+			__testvalid = this->seekoff(0, ios_base::cur, _M_mode)
+			              != pos_type(off_type(-1));
+		    }
+		  else
+		    {
+		      // External position corresponding to gptr().
+		      _M_ext_next = _M_ext_buf
+			+ _M_codecvt->length(_M_state_last, _M_ext_buf,
+					     _M_ext_next,
+					     this->gptr() - this->eback());
+		      const streamsize __remainder = _M_ext_end - _M_ext_next;
+		      if (__remainder)
+			__builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
+
+		      _M_ext_next = _M_ext_buf;
+		      _M_ext_end = _M_ext_buf + __remainder;
+		      _M_set_buffer(-1);
+		      _M_state_last = _M_state_cur = _M_state_beg;
+		    }
+		}
+	      else if (_M_writing && (__testvalid = _M_terminate_output()))
+		_M_set_buffer(-1);
+	    }
+	}
+
+      if (__testvalid)
+	_M_codecvt = _M_codecvt_tmp;
+      else
+	_M_codecvt = 0;
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class basic_filebuf<char>;
+  extern template class basic_ifstream<char>;
+  extern template class basic_ofstream<char>;
+  extern template class basic_fstream<char>;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_filebuf<wchar_t>;
+  extern template class basic_ifstream<wchar_t>;
+  extern template class basic_ofstream<wchar_t>;
+  extern template class basic_fstream<wchar_t>;
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/functexcept.h b/gcc-4.9/libstdc++-v3/include/bits/functexcept.h
new file mode 100644
index 0000000..b8359f9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/functexcept.h
@@ -0,0 +1,110 @@
+// Function-Based Exception Support -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/functexcept.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{exception}
+ *
+ *  This header provides support for -fno-exceptions.
+ */
+
+//
+// ISO C++ 14882: 19.1  Exception classes
+//
+
+#ifndef _FUNCTEXCEPT_H
+#define _FUNCTEXCEPT_H 1
+
+#include <bits/c++config.h>
+#include <bits/exception_defines.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Helper for exception objects in <except>
+  void
+  __throw_bad_exception(void) __attribute__((__noreturn__));
+
+  // Helper for exception objects in <new>
+  void
+  __throw_bad_alloc(void) __attribute__((__noreturn__));
+
+  // Helper for exception objects in <typeinfo>
+  void
+  __throw_bad_cast(void) __attribute__((__noreturn__));
+
+  void
+  __throw_bad_typeid(void) __attribute__((__noreturn__));
+
+  // Helpers for exception objects in <stdexcept>
+  void
+  __throw_logic_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_domain_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_length_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
+    __attribute__((__format__(__printf__, 1, 2)));
+
+  void
+  __throw_runtime_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_range_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_overflow_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_underflow_error(const char*) __attribute__((__noreturn__));
+
+  // Helpers for exception objects in <ios>
+  void
+  __throw_ios_failure(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+
+  // Helpers for exception objects in <functional>
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/functional_hash.h b/gcc-4.9/libstdc++-v3/include/bits/functional_hash.h
new file mode 100644
index 0000000..d46e0a3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/functional_hash.h
@@ -0,0 +1,212 @@
+// functional_hash.h header -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/functional_hash.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _FUNCTIONAL_HASH_H
+#define _FUNCTIONAL_HASH_H 1
+
+#pragma GCC system_header
+
+#include <bits/hash_bytes.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /** @defgroup hashes Hashes
+   *  @ingroup functors
+   *
+   *   Hashing functors taking a variable type and returning a @c std::size_t.
+   *
+   *  @{
+   */
+
+  template<typename _Result, typename _Arg>
+    struct __hash_base
+    {
+      typedef _Result     result_type;
+      typedef _Arg      argument_type;
+    };
+
+  /// Primary class template hash.
+  template<typename _Tp>
+    struct hash;
+
+  /// Partial specializations for pointer types.
+  template<typename _Tp>
+    struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
+    {
+      size_t
+      operator()(_Tp* __p) const noexcept
+      { return reinterpret_cast<size_t>(__p); }
+    };
+
+  // Explicit specializations for integer types.
+#define _Cxx_hashtable_define_trivial_hash(_Tp) 	\
+  template<>						\
+    struct hash<_Tp> : public __hash_base<size_t, _Tp>  \
+    {                                                   \
+      size_t                                            \
+      operator()(_Tp __val) const noexcept              \
+      { return static_cast<size_t>(__val); }            \
+    };
+
+  /// Explicit specialization for bool.
+  _Cxx_hashtable_define_trivial_hash(bool)
+
+  /// Explicit specialization for char.
+  _Cxx_hashtable_define_trivial_hash(char)
+
+  /// Explicit specialization for signed char.
+  _Cxx_hashtable_define_trivial_hash(signed char)
+
+  /// Explicit specialization for unsigned char.
+  _Cxx_hashtable_define_trivial_hash(unsigned char)
+
+  /// Explicit specialization for wchar_t.
+  _Cxx_hashtable_define_trivial_hash(wchar_t)
+
+  /// Explicit specialization for char16_t.
+  _Cxx_hashtable_define_trivial_hash(char16_t)
+
+  /// Explicit specialization for char32_t.
+  _Cxx_hashtable_define_trivial_hash(char32_t)
+
+  /// Explicit specialization for short.
+  _Cxx_hashtable_define_trivial_hash(short)
+
+  /// Explicit specialization for int.
+  _Cxx_hashtable_define_trivial_hash(int)
+
+  /// Explicit specialization for long.
+  _Cxx_hashtable_define_trivial_hash(long)
+
+  /// Explicit specialization for long long.
+  _Cxx_hashtable_define_trivial_hash(long long)
+
+  /// Explicit specialization for unsigned short.
+  _Cxx_hashtable_define_trivial_hash(unsigned short)
+
+  /// Explicit specialization for unsigned int.
+  _Cxx_hashtable_define_trivial_hash(unsigned int)
+
+  /// Explicit specialization for unsigned long.
+  _Cxx_hashtable_define_trivial_hash(unsigned long)
+
+  /// Explicit specialization for unsigned long long.
+  _Cxx_hashtable_define_trivial_hash(unsigned long long)
+
+#undef _Cxx_hashtable_define_trivial_hash
+
+  struct _Hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+	 size_t __seed = static_cast<size_t>(0xc70f6907UL))
+    { return _Hash_bytes(__ptr, __clength, __seed); }
+
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+
+  struct _Fnv_hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+	 size_t __seed = static_cast<size_t>(2166136261UL))
+    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
+
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+
+  /// Specialization for float.
+  template<>
+    struct hash<float> : public __hash_base<size_t, float>
+    {
+      size_t
+      operator()(float __val) const noexcept
+      {
+	// 0 and -0 both hash to zero.
+	return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+
+  /// Specialization for double.
+  template<>
+    struct hash<double> : public __hash_base<size_t, double>
+    {
+      size_t
+      operator()(double __val) const noexcept
+      {
+	// 0 and -0 both hash to zero.
+	return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+
+  /// Specialization for long double.
+  template<>
+    struct hash<long double>
+    : public __hash_base<size_t, long double>
+    {
+      _GLIBCXX_PURE size_t
+      operator()(long double __val) const noexcept;
+    };
+
+  // @} group hashes
+
+  // Hint about performance of hash functor. If not fast the hash based
+  // containers will cache the hash code.
+  // Default behavior is to consider that hasher are fast unless specified
+  // otherwise.
+  template<typename _Hash>
+    struct __is_fast_hash : public std::true_type
+    { };
+
+  template<>
+    struct __is_fast_hash<hash<long double>> : public std::false_type
+    { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _FUNCTIONAL_HASH_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/gslice.h b/gcc-4.9/libstdc++-v3/include/bits/gslice.h
new file mode 100644
index 0000000..8e8ff2f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/gslice.h
@@ -0,0 +1,185 @@
+// The template and inlines for the -*- C++ -*- gslice class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/gslice.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _GSLICE_H
+#define _GSLICE_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup numeric_arrays
+   * @{
+   */
+
+  /**
+   *  @brief  Class defining multi-dimensional subset of an array.
+   *
+   *  The slice class represents a multi-dimensional subset of an array,
+   *  specified by three parameter sets: start offset, size array, and stride
+   *  array.  The start offset is the index of the first element of the array
+   *  that is part of the subset.  The size and stride array describe each
+   *  dimension of the slice.  Size is the number of elements in that
+   *  dimension, and stride is the distance in the array between successive
+   *  elements in that dimension.  Each dimension's size and stride is taken
+   *  to begin at an array element described by the previous dimension.  The
+   *  size array and stride array must be the same size.
+   *
+   *  For example, if you have offset==3, stride[0]==11, size[1]==3,
+   *  stride[1]==3, then slice[0,0]==array[3], slice[0,1]==array[6],
+   *  slice[0,2]==array[9], slice[1,0]==array[14], slice[1,1]==array[17],
+   *  slice[1,2]==array[20].
+   */
+  class gslice
+  {
+  public:
+    ///  Construct an empty slice.
+    gslice();
+
+    /**
+     *  @brief  Construct a slice.
+     *
+     *  Constructs a slice with as many dimensions as the length of the @a l
+     *  and @a s arrays.
+     *
+     *  @param  __o  Offset in array of first element.
+     *  @param  __l  Array of dimension lengths.
+     *  @param  __s  Array of dimension strides between array elements.
+     */
+    gslice(size_t __o, const valarray<size_t>& __l, 
+	   const valarray<size_t>& __s);
+
+    // XXX: the IS says the copy-ctor and copy-assignment operators are
+    //      synthesized by the compiler but they are just unsuitable
+    //      for a ref-counted semantic
+    ///  Copy constructor.
+    gslice(const gslice&);
+
+    ///  Destructor.
+    ~gslice();
+
+    // XXX: See the note above.
+    ///  Assignment operator.
+    gslice& operator=(const gslice&);
+
+    ///  Return array offset of first slice element.
+    size_t           start() const;
+
+    ///  Return array of sizes of slice dimensions.
+    valarray<size_t> size() const;
+    
+    ///  Return array of array strides for each dimension.
+    valarray<size_t> stride() const;
+
+  private:
+    struct _Indexer
+    {
+      size_t _M_count;
+      size_t _M_start;
+      valarray<size_t> _M_size;
+      valarray<size_t> _M_stride;
+      valarray<size_t> _M_index; // Linear array of referenced indices
+
+      _Indexer()
+      : _M_count(1), _M_start(0), _M_size(), _M_stride(), _M_index() {}
+
+      _Indexer(size_t, const valarray<size_t>&,
+	       const valarray<size_t>&);
+
+      void
+      _M_increment_use()
+      { ++_M_count; }
+      
+      size_t
+      _M_decrement_use()
+      { return --_M_count; }
+    };
+
+    _Indexer* _M_index;
+
+    template<typename _Tp> friend class valarray;
+  };
+
+  inline size_t
+  gslice::start() const
+  { return _M_index ? _M_index->_M_start : 0; }
+
+  inline valarray<size_t>
+  gslice::size() const
+  { return _M_index ? _M_index->_M_size : valarray<size_t>(); }
+
+  inline valarray<size_t>
+  gslice::stride() const
+  { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 543. valarray slice default constructor
+  inline
+  gslice::gslice()
+  : _M_index(new gslice::_Indexer()) {}
+
+  inline
+  gslice::gslice(size_t __o, const valarray<size_t>& __l,
+		 const valarray<size_t>& __s)
+  : _M_index(new gslice::_Indexer(__o, __l, __s)) {}
+
+  inline
+  gslice::gslice(const gslice& __g)
+  : _M_index(__g._M_index)
+  { if (_M_index) _M_index->_M_increment_use(); }
+
+  inline
+  gslice::~gslice()
+  {
+    if (_M_index && _M_index->_M_decrement_use() == 0)
+      delete _M_index;
+  }
+
+  inline gslice&
+  gslice::operator=(const gslice& __g)
+  {
+    if (__g._M_index)
+      __g._M_index->_M_increment_use();
+    if (_M_index && _M_index->_M_decrement_use() == 0)
+      delete _M_index;
+    _M_index = __g._M_index;
+    return *this;
+  }
+
+  // @} group numeric_arrays
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GSLICE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/gslice_array.h b/gcc-4.9/libstdc++-v3/include/bits/gslice_array.h
new file mode 100644
index 0000000..f46b9df
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/gslice_array.h
@@ -0,0 +1,218 @@
+// The template and inlines for the -*- C++ -*- gslice_array class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/gslice_array.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _GSLICE_ARRAY_H
+#define _GSLICE_ARRAY_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup numeric_arrays
+   * @{
+   */
+
+  /**
+   *  @brief  Reference to multi-dimensional subset of an array.
+   *
+   *  A gslice_array is a reference to the actual elements of an array
+   *  specified by a gslice.  The way to get a gslice_array is to call
+   *  operator[](gslice) on a valarray.  The returned gslice_array then
+   *  permits carrying operations out on the referenced subset of elements in
+   *  the original valarray.  For example, operator+=(valarray) will add
+   *  values to the subset of elements in the underlying valarray this
+   *  gslice_array refers to.
+   *
+   *  @param  Tp  Element type.
+   */
+  template<typename _Tp>
+    class gslice_array
+    {
+    public:
+      typedef _Tp value_type;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 253. valarray helper functions are almost entirely useless
+
+      ///  Copy constructor.  Both slices refer to the same underlying array.
+      gslice_array(const gslice_array&);
+
+      ///  Assignment operator.  Assigns slice elements to corresponding
+      ///  elements of @a a.
+      gslice_array& operator=(const gslice_array&);
+
+      ///  Assign slice elements to corresponding elements of @a v.
+      void operator=(const valarray<_Tp>&) const;
+      ///  Multiply slice elements by corresponding elements of @a v.
+      void operator*=(const valarray<_Tp>&) const;
+      ///  Divide slice elements by corresponding elements of @a v.
+      void operator/=(const valarray<_Tp>&) const;
+      ///  Modulo slice elements by corresponding elements of @a v.
+      void operator%=(const valarray<_Tp>&) const;
+      ///  Add corresponding elements of @a v to slice elements.
+      void operator+=(const valarray<_Tp>&) const;
+      ///  Subtract corresponding elements of @a v from slice elements.
+      void operator-=(const valarray<_Tp>&) const;
+      ///  Logical xor slice elements with corresponding elements of @a v.
+      void operator^=(const valarray<_Tp>&) const;
+      ///  Logical and slice elements with corresponding elements of @a v.
+      void operator&=(const valarray<_Tp>&) const;
+      ///  Logical or slice elements with corresponding elements of @a v.
+      void operator|=(const valarray<_Tp>&) const;
+      ///  Left shift slice elements by corresponding elements of @a v.
+      void operator<<=(const valarray<_Tp>&) const;
+      ///  Right shift slice elements by corresponding elements of @a v.
+      void operator>>=(const valarray<_Tp>&) const;
+      ///  Assign all slice elements to @a t.
+      void operator=(const _Tp&) const;
+
+      template<class _Dom>
+        void operator=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator*=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator/=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator%=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator+=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator-=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator^=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator&=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator|=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator<<=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+        void operator>>=(const _Expr<_Dom, _Tp>&) const;
+
+    private:
+      _Array<_Tp>    _M_array;
+      const valarray<size_t>& _M_index;
+
+      friend class valarray<_Tp>;
+
+      gslice_array(_Array<_Tp>, const valarray<size_t>&);
+
+      // not implemented
+      gslice_array();
+    };
+
+  template<typename _Tp>
+    inline
+    gslice_array<_Tp>::gslice_array(_Array<_Tp> __a,
+				    const valarray<size_t>& __i)
+    : _M_array(__a), _M_index(__i) {}
+
+  template<typename _Tp>
+    inline
+    gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a)
+    : _M_array(__a._M_array), _M_index(__a._M_index) {}
+
+  template<typename _Tp>
+    inline gslice_array<_Tp>&
+    gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a)
+    {
+      std::__valarray_copy(_Array<_Tp>(__a._M_array),
+			   _Array<size_t>(__a._M_index), _M_index.size(),
+			   _M_array, _Array<size_t>(_M_index));
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline void
+    gslice_array<_Tp>::operator=(const _Tp& __t) const
+    {
+      std::__valarray_fill(_M_array, _Array<size_t>(_M_index),
+			   _M_index.size(), __t);
+    }
+
+  template<typename _Tp>
+    inline void
+    gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
+    {
+      std::__valarray_copy(_Array<_Tp>(__v), __v.size(),
+			   _M_array, _Array<size_t>(_M_index));
+    }
+
+  template<typename _Tp>
+    template<class _Dom>
+      inline void
+      gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
+      {
+	std::__valarray_copy (__e, _M_index.size(), _M_array,
+			      _Array<size_t>(_M_index));
+      }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)				\
+  template<typename _Tp>						\
+    inline void								\
+    gslice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const	\
+    {									\
+      _Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index),	\
+			       _Array<_Tp>(__v), __v.size());		\
+    }									\
+									\
+  template<typename _Tp>                                                \
+    template<class _Dom>				                \
+      inline void							\
+      gslice_array<_Tp>::operator _Op##= (const _Expr<_Dom, _Tp>& __e) const\
+      {									\
+	_Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index), __e,\
+				 _M_index.size());			\
+      }
+
+_DEFINE_VALARRAY_OPERATOR(*, __multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, __divides)
+_DEFINE_VALARRAY_OPERATOR(%, __modulus)
+_DEFINE_VALARRAY_OPERATOR(+, __plus)
+_DEFINE_VALARRAY_OPERATOR(-, __minus)
+_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
+_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
+_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
+_DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR
+
+  // @} group numeric_arrays
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GSLICE_ARRAY_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/hashtable.h b/gcc-4.9/libstdc++-v3/include/bits/hashtable.h
new file mode 100644
index 0000000..22e17d2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/hashtable.h
@@ -0,0 +1,2072 @@
+// hashtable.h header -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/hashtable.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{unordered_map, unordered_set}
+ */
+
+#ifndef _HASHTABLE_H
+#define _HASHTABLE_H 1
+
+#pragma GCC system_header
+
+#include <bits/hashtable_policy.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Tp, typename _Hash>
+    using __cache_default
+      =  __not_<__and_<// Do not cache for fast hasher.
+		       __is_fast_hash<_Hash>,
+		       // Mandatory to have erase not throwing.
+		       __detail::__is_noexcept_hash<_Tp, _Hash>>>;
+
+  /**
+   *  Primary class template _Hashtable.
+   *
+   *  @ingroup hashtable-detail
+   *
+   *  @tparam _Value  CopyConstructible type.
+   *
+   *  @tparam _Key    CopyConstructible type.
+   *
+   *  @tparam _Alloc  An allocator type
+   *  ([lib.allocator.requirements]) whose _Alloc::value_type is
+   *  _Value.  As a conforming extension, we allow for
+   *  _Alloc::value_type != _Value.
+   *
+   *  @tparam _ExtractKey  Function object that takes an object of type
+   *  _Value and returns a value of type _Key.
+   *
+   *  @tparam _Equal  Function object that takes two objects of type k
+   *  and returns a bool-like value that is true if the two objects
+   *  are considered equal.
+   *
+   *  @tparam _H1  The hash function. A unary function object with
+   *  argument type _Key and result type size_t. Return values should
+   *  be distributed over the entire range [0, numeric_limits<size_t>:::max()].
+   *
+   *  @tparam _H2  The range-hashing function (in the terminology of
+   *  Tavori and Dreizin).  A binary function object whose argument
+   *  types and result type are all size_t.  Given arguments r and N,
+   *  the return value is in the range [0, N).
+   *
+   *  @tparam _Hash  The ranged hash function (Tavori and Dreizin). A
+   *  binary function whose argument types are _Key and size_t and
+   *  whose result type is size_t.  Given arguments k and N, the
+   *  return value is in the range [0, N).  Default: hash(k, N) =
+   *  h2(h1(k), N).  If _Hash is anything other than the default, _H1
+   *  and _H2 are ignored.
+   *
+   *  @tparam _RehashPolicy  Policy class with three members, all of
+   *  which govern the bucket count. _M_next_bkt(n) returns a bucket
+   *  count no smaller than n.  _M_bkt_for_elements(n) returns a
+   *  bucket count appropriate for an element count of n.
+   *  _M_need_rehash(n_bkt, n_elt, n_ins) determines whether, if the
+   *  current bucket count is n_bkt and the current element count is
+   *  n_elt, we need to increase the bucket count.  If so, returns
+   *  make_pair(true, n), where n is the new bucket count.  If not,
+   *  returns make_pair(false, <anything>)
+   *
+   *  @tparam _Traits  Compile-time class with three boolean
+   *  std::integral_constant members:  __cache_hash_code, __constant_iterators,
+   *   __unique_keys.
+   *
+   *  Each _Hashtable data structure has:
+   *
+   *  - _Bucket[]       _M_buckets
+   *  - _Hash_node_base _M_before_begin
+   *  - size_type       _M_bucket_count
+   *  - size_type       _M_element_count
+   *
+   *  with _Bucket being _Hash_node* and _Hash_node containing:
+   *
+   *  - _Hash_node*   _M_next
+   *  - Tp            _M_value
+   *  - size_t        _M_hash_code if cache_hash_code is true
+   *
+   *  In terms of Standard containers the hashtable is like the aggregation of:
+   *
+   *  - std::forward_list<_Node> containing the elements
+   *  - std::vector<std::forward_list<_Node>::iterator> representing the buckets
+   *
+   *  The non-empty buckets contain the node before the first node in the
+   *  bucket. This design makes it possible to implement something like a
+   *  std::forward_list::insert_after on container insertion and
+   *  std::forward_list::erase_after on container erase
+   *  calls. _M_before_begin is equivalent to
+   *  std::forward_list::before_begin. Empty buckets contain
+   *  nullptr.  Note that one of the non-empty buckets contains
+   *  &_M_before_begin which is not a dereferenceable node so the
+   *  node pointer in a bucket shall never be dereferenced, only its
+   *  next node can be.
+   *
+   *  Walking through a bucket's nodes requires a check on the hash code to
+   *  see if each node is still in the bucket. Such a design assumes a
+   *  quite efficient hash functor and is one of the reasons it is
+   *  highly advisable to set __cache_hash_code to true.
+   *
+   *  The container iterators are simply built from nodes. This way
+   *  incrementing the iterator is perfectly efficient independent of
+   *  how many empty buckets there are in the container.
+   *
+   *  On insert we compute the element's hash code and use it to find the
+   *  bucket index. If the element must be inserted in an empty bucket
+   *  we add it at the beginning of the singly linked list and make the
+   *  bucket point to _M_before_begin. The bucket that used to point to
+   *  _M_before_begin, if any, is updated to point to its new before
+   *  begin node.
+   *
+   *  On erase, the simple iterator design requires using the hash
+   *  functor to get the index of the bucket to update. For this
+   *  reason, when __cache_hash_code is set to false the hash functor must
+   *  not throw and this is enforced by a static assertion.
+   *
+   *  Functionality is implemented by decomposition into base classes,
+   *  where the derived _Hashtable class is used in _Map_base,
+   *  _Insert, _Rehash_base, and _Equality base classes to access the
+   *  "this" pointer. _Hashtable_base is used in the base classes as a
+   *  non-recursive, fully-completed-type so that detailed nested type
+   *  information, such as iterator type and node type, can be
+   *  used. This is similar to the "Curiously Recurring Template
+   *  Pattern" (CRTP) technique, but uses a reconstructed, not
+   *  explicitly passed, template pattern.
+   *
+   *  Base class templates are: 
+   *    - __detail::_Hashtable_base
+   *    - __detail::_Map_base
+   *    - __detail::_Insert
+   *    - __detail::_Rehash_base
+   *    - __detail::_Equality
+   */
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    class _Hashtable
+    : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
+				       _H1, _H2, _Hash, _Traits>,
+      public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+				 _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			       _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+				    _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+				 _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      private __detail::_Hashtable_alloc<
+	typename __alloctr_rebind<_Alloc,
+	  __detail::_Hash_node<_Value,
+			       _Traits::__hash_cached::value> >::__type>
+    {
+      using __traits_type = _Traits;
+      using __hash_cached = typename __traits_type::__hash_cached;
+      using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
+      using __node_alloc_type =
+	typename __alloctr_rebind<_Alloc, __node_type>::__type;
+
+      using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;
+
+      using __value_alloc_traits =
+	typename __hashtable_alloc::__value_alloc_traits;
+      using __node_alloc_traits =
+	typename __hashtable_alloc::__node_alloc_traits;
+      using __node_base = typename __hashtable_alloc::__node_base;
+      using __bucket_type = typename __hashtable_alloc::__bucket_type;
+
+    public:
+      typedef _Key						key_type;
+      typedef _Value						value_type;
+      typedef _Alloc						allocator_type;
+      typedef _Equal						key_equal;
+
+      // mapped_type, if present, comes from _Map_base.
+      // hasher, if present, comes from _Hash_code_base/_Hashtable_base.
+      typedef typename __value_alloc_traits::pointer		pointer;
+      typedef typename __value_alloc_traits::const_pointer	const_pointer;
+      typedef value_type&					reference;
+      typedef const value_type&					const_reference;
+
+    private:
+      using __rehash_type = _RehashPolicy;
+      using __rehash_state = typename __rehash_type::_State;
+
+      using __constant_iterators = typename __traits_type::__constant_iterators;
+      using __unique_keys = typename __traits_type::__unique_keys;
+
+      using __key_extract = typename std::conditional<
+					     __constant_iterators::value,
+				       	     __detail::_Identity,
+					     __detail::_Select1st>::type;
+
+      using __hashtable_base = __detail::
+			       _Hashtable_base<_Key, _Value, _ExtractKey,
+					      _Equal, _H1, _H2, _Hash, _Traits>;
+
+      using __hash_code_base =  typename __hashtable_base::__hash_code_base;
+      using __hash_code =  typename __hashtable_base::__hash_code;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+
+      using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
+					     _Equal, _H1, _H2, _Hash,
+					     _RehashPolicy, _Traits>;
+
+      using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
+						   _ExtractKey, _Equal,
+						   _H1, _H2, _Hash,
+						   _RehashPolicy, _Traits>;
+
+      using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey,
+					    _Equal, _H1, _H2, _Hash,
+					    _RehashPolicy, _Traits>;
+
+      using __reuse_or_alloc_node_type =
+	__detail::_ReuseOrAllocNode<__node_alloc_type>;
+
+      // Metaprogramming for picking apart hash caching.
+      template<typename _Cond>
+	using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>;
+
+      template<typename _Cond>
+	using __if_hash_not_cached = __or_<__hash_cached, _Cond>;
+
+      // Compile-time diagnostics.
+
+      // _Hash_code_base has everything protected, so use this derived type to
+      // access it.
+      struct __hash_code_base_access : __hash_code_base
+      { using __hash_code_base::_M_bucket_index; };
+
+      // Getting a bucket index from a node shall not throw because it is used
+      // in methods (erase, swap...) that shall not throw.
+      static_assert(noexcept(declval<const __hash_code_base_access&>()
+			     ._M_bucket_index((const __node_type*)nullptr,
+					      (std::size_t)0)),
+		    "Cache the hash code or qualify your functors involved"
+		    " in hash code and bucket index computation with noexcept");
+
+      // Following two static assertions are necessary to guarantee
+      // that local_iterator will be default constructible.
+
+      // When hash codes are cached local iterator inherits from H2 functor
+      // which must then be default constructible.
+      static_assert(__if_hash_cached<is_default_constructible<_H2>>::value,
+		    "Functor used to map hash code to bucket index"
+		    " must be default constructible");
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+	       typename _ExtractKeya, typename _Equala,
+	       typename _H1a, typename _H2a, typename _Hasha,
+	       typename _RehashPolicya, typename _Traitsa,
+	       bool _Unique_keysa>
+	friend struct __detail::_Map_base;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+	       typename _ExtractKeya, typename _Equala,
+	       typename _H1a, typename _H2a, typename _Hasha,
+	       typename _RehashPolicya, typename _Traitsa>
+	friend struct __detail::_Insert_base;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+	       typename _ExtractKeya, typename _Equala,
+	       typename _H1a, typename _H2a, typename _Hasha,
+	       typename _RehashPolicya, typename _Traitsa,
+	       bool _Constant_iteratorsa, bool _Unique_keysa>
+	friend struct __detail::_Insert;
+
+    public:
+      using size_type = typename __hashtable_base::size_type;
+      using difference_type = typename __hashtable_base::difference_type;
+
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator = typename __hashtable_base::const_iterator;
+
+      using local_iterator = typename __hashtable_base::local_iterator;
+      using const_local_iterator = typename __hashtable_base::
+				   const_local_iterator;
+
+    private:
+      __bucket_type*		_M_buckets;
+      size_type			_M_bucket_count;
+      __node_base		_M_before_begin;
+      size_type			_M_element_count;
+      _RehashPolicy		_M_rehash_policy;
+
+      __hashtable_alloc&
+      _M_base_alloc() { return *this; }
+
+      using __hashtable_alloc::_M_deallocate_buckets;
+
+      void
+      _M_deallocate_buckets()
+      { this->_M_deallocate_buckets(_M_buckets, _M_bucket_count); }
+
+      // Gets bucket begin, deals with the fact that non-empty buckets contain
+      // their before begin node.
+      __node_type*
+      _M_bucket_begin(size_type __bkt) const;
+
+      __node_type*
+      _M_begin() const
+      { return static_cast<__node_type*>(_M_before_begin._M_nxt); }
+
+      template<typename _NodeGenerator>
+	void
+	_M_assign(const _Hashtable&, const _NodeGenerator&);
+
+      void
+      _M_move_assign(_Hashtable&&, std::true_type);
+
+      void
+      _M_move_assign(_Hashtable&&, std::false_type);
+
+      void
+      _M_reset() noexcept;
+
+    public:
+      // Constructor, destructor, assignment, swap
+      _Hashtable(size_type __bucket_hint,
+		 const _H1&, const _H2&, const _Hash&,
+		 const _Equal&, const _ExtractKey&,
+		 const allocator_type&);
+
+      template<typename _InputIterator>
+	_Hashtable(_InputIterator __first, _InputIterator __last,
+		   size_type __bucket_hint,
+		   const _H1&, const _H2&, const _Hash&,
+		   const _Equal&, const _ExtractKey&,
+		   const allocator_type&);
+
+      _Hashtable(const _Hashtable&);
+
+      _Hashtable(_Hashtable&&) noexcept;
+
+      _Hashtable(const _Hashtable&, const allocator_type&);
+
+      _Hashtable(_Hashtable&&, const allocator_type&);
+
+      // Use delegating constructors.
+      explicit
+      _Hashtable(const allocator_type& __a)
+      : _Hashtable(10, _H1(), _H2(), _Hash(), key_equal(),
+		   __key_extract(), __a)
+      { }
+
+      explicit
+      _Hashtable(size_type __n = 10,
+		 const _H1& __hf = _H1(),
+		 const key_equal& __eql = key_equal(),
+		 const allocator_type& __a = allocator_type())
+      : _Hashtable(__n, __hf, _H2(), _Hash(), __eql,
+		   __key_extract(), __a)
+      { }
+
+      template<typename _InputIterator>
+	_Hashtable(_InputIterator __f, _InputIterator __l,
+		   size_type __n = 0,
+		   const _H1& __hf = _H1(),
+		   const key_equal& __eql = key_equal(),
+		   const allocator_type& __a = allocator_type())
+	: _Hashtable(__f, __l, __n, __hf, _H2(), _Hash(), __eql,
+		     __key_extract(), __a)
+	{ }
+
+      _Hashtable(initializer_list<value_type> __l,
+		 size_type __n = 0,
+		 const _H1& __hf = _H1(),
+		 const key_equal& __eql = key_equal(),
+		 const allocator_type& __a = allocator_type())
+      : _Hashtable(__l.begin(), __l.end(), __n, __hf, _H2(), _Hash(), __eql,
+		   __key_extract(), __a)
+      { }
+
+      _Hashtable&
+      operator=(const _Hashtable& __ht);
+
+      _Hashtable&
+      operator=(_Hashtable&& __ht)
+      noexcept(__node_alloc_traits::_S_nothrow_move())
+      {
+        constexpr bool __move_storage =
+          __node_alloc_traits::_S_propagate_on_move_assign()
+          || __node_alloc_traits::_S_always_equal();
+        _M_move_assign(std::move(__ht),
+                       integral_constant<bool, __move_storage>());
+	return *this;
+      }
+
+      _Hashtable&
+      operator=(initializer_list<value_type> __l)
+      {
+	__reuse_or_alloc_node_type __roan(_M_begin(), *this);
+	_M_before_begin._M_nxt = nullptr;
+	clear();
+	this->_M_insert_range(__l.begin(), __l.end(), __roan);
+	return *this;
+      }
+
+      ~_Hashtable() noexcept;
+
+      void
+      swap(_Hashtable&)
+      noexcept(__node_alloc_traits::_S_nothrow_swap());
+
+      // Basic container operations
+      iterator
+      begin() noexcept
+      { return iterator(_M_begin()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_begin()); }
+
+      iterator
+      end() noexcept
+      { return iterator(nullptr); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(nullptr); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_M_begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(nullptr); }
+
+      size_type
+      size() const noexcept
+      { return _M_element_count; }
+
+      bool
+      empty() const noexcept
+      { return size() == 0; }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(this->_M_node_allocator()); }
+
+      size_type
+      max_size() const noexcept
+      { return __node_alloc_traits::max_size(this->_M_node_allocator()); }
+
+      // Observers
+      key_equal
+      key_eq() const
+      { return this->_M_eq(); }
+
+      // hash_function, if present, comes from _Hash_code_base.
+
+      // Bucket operations
+      size_type
+      bucket_count() const noexcept
+      { return _M_bucket_count; }
+
+      size_type
+      max_bucket_count() const noexcept
+      { return max_size(); }
+
+      size_type
+      bucket_size(size_type __n) const
+      { return std::distance(begin(__n), end(__n)); }
+
+      size_type
+      bucket(const key_type& __k) const
+      { return _M_bucket_index(__k, this->_M_hash_code(__k)); }
+
+      local_iterator
+      begin(size_type __n)
+      {
+	return local_iterator(*this, _M_bucket_begin(__n),
+			      __n, _M_bucket_count);
+      }
+
+      local_iterator
+      end(size_type __n)
+      { return local_iterator(*this, nullptr, __n, _M_bucket_count); }
+
+      const_local_iterator
+      begin(size_type __n) const
+      {
+	return const_local_iterator(*this, _M_bucket_begin(__n),
+				    __n, _M_bucket_count);
+      }
+
+      const_local_iterator
+      end(size_type __n) const
+      { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); }
+
+      // DR 691.
+      const_local_iterator
+      cbegin(size_type __n) const
+      {
+	return const_local_iterator(*this, _M_bucket_begin(__n),
+				    __n, _M_bucket_count);
+      }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); }
+
+      float
+      load_factor() const noexcept
+      {
+	return static_cast<float>(size()) / static_cast<float>(bucket_count());
+      }
+
+      // max_load_factor, if present, comes from _Rehash_base.
+
+      // Generalization of max_load_factor.  Extension, not found in
+      // TR1.  Only useful if _RehashPolicy is something other than
+      // the default.
+      const _RehashPolicy&
+      __rehash_policy() const
+      { return _M_rehash_policy; }
+
+      void
+      __rehash_policy(const _RehashPolicy&);
+
+      // Lookup.
+      iterator
+      find(const key_type& __k);
+
+      const_iterator
+      find(const key_type& __k) const;
+
+      size_type
+      count(const key_type& __k) const;
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __k);
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+
+    protected:
+      // Bucket index computation helpers.
+      size_type
+      _M_bucket_index(__node_type* __n) const noexcept
+      { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }
+
+      size_type
+      _M_bucket_index(const key_type& __k, __hash_code __c) const
+      { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); }
+
+      // Find and insert helper functions and types
+      // Find the node before the one matching the criteria.
+      __node_base*
+      _M_find_before_node(size_type, const key_type&, __hash_code) const;
+
+      __node_type*
+      _M_find_node(size_type __bkt, const key_type& __key,
+		   __hash_code __c) const
+      {
+	__node_base* __before_n = _M_find_before_node(__bkt, __key, __c);
+	if (__before_n)
+	  return static_cast<__node_type*>(__before_n->_M_nxt);
+	return nullptr;
+      }
+
+      // Insert a node at the beginning of a bucket.
+      void
+      _M_insert_bucket_begin(size_type, __node_type*);
+
+      // Remove the bucket first node
+      void
+      _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n,
+			     size_type __next_bkt);
+
+      // Get the node before __n in the bucket __bkt
+      __node_base*
+      _M_get_previous_node(size_type __bkt, __node_base* __n);
+
+      // Insert node with hash code __code, in bucket bkt if no rehash (assumes
+      // no element with its key already present). Take ownership of the node,
+      // deallocate it on exception.
+      iterator
+      _M_insert_unique_node(size_type __bkt, __hash_code __code,
+			    __node_type* __n);
+
+      // Insert node with hash code __code. Take ownership of the node,
+      // deallocate it on exception.
+      iterator
+      _M_insert_multi_node(__node_type* __hint,
+			   __hash_code __code, __node_type* __n);
+
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	_M_emplace(std::true_type, _Args&&... __args);
+
+      template<typename... _Args>
+	iterator
+	_M_emplace(std::false_type __uk, _Args&&... __args)
+	{ return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); }
+
+      // Emplace with hint, useless when keys are unique.
+      template<typename... _Args>
+	iterator
+	_M_emplace(const_iterator, std::true_type __uk, _Args&&... __args)
+	{ return _M_emplace(__uk, std::forward<_Args>(__args)...).first; }
+
+      template<typename... _Args>
+	iterator
+	_M_emplace(const_iterator, std::false_type, _Args&&... __args);
+
+      template<typename _Arg, typename _NodeGenerator>
+	std::pair<iterator, bool>
+	_M_insert(_Arg&&, const _NodeGenerator&, std::true_type);
+
+      template<typename _Arg, typename _NodeGenerator>
+	iterator
+	_M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
+		  std::false_type __uk)
+	{
+	  return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen,
+			   __uk);
+	}
+
+      // Insert with hint, not used when keys are unique.
+      template<typename _Arg, typename _NodeGenerator>
+	iterator
+	_M_insert(const_iterator, _Arg&& __arg, const _NodeGenerator& __node_gen,
+		  std::true_type __uk)
+	{
+	  return
+	    _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first;
+	}
+
+      // Insert with hint when keys are not unique.
+      template<typename _Arg, typename _NodeGenerator>
+	iterator
+	_M_insert(const_iterator, _Arg&&, const _NodeGenerator&, std::false_type);
+
+      size_type
+      _M_erase(std::true_type, const key_type&);
+
+      size_type
+      _M_erase(std::false_type, const key_type&);
+
+      iterator
+      _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n);
+
+    public:
+      // Emplace
+      template<typename... _Args>
+	__ireturn_type
+	emplace(_Args&&... __args)
+	{ return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); }
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __hint, _Args&&... __args)
+	{
+	  return _M_emplace(__hint, __unique_keys(),
+			    std::forward<_Args>(__args)...);
+	}
+
+      // Insert member functions via inheritance.
+
+      // Erase
+      iterator
+      erase(const_iterator);
+
+      // LWG 2059.
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+
+      size_type
+      erase(const key_type& __k)
+      {
+	if (__builtin_expect(_M_bucket_count == 0, false))
+	  return 0;
+	return _M_erase(__unique_keys(), __k);
+      }
+
+      iterator
+      erase(const_iterator, const_iterator);
+
+      void
+      clear() noexcept;
+
+      // Set number of buckets to be appropriate for container of n element.
+      void rehash(size_type __n);
+
+      // DR 1189.
+      // reserve, if present, comes from _Rehash_base.
+
+    private:
+      // Helper rehash method used when keys are unique.
+      void _M_rehash_aux(size_type __n, std::true_type);
+
+      // Helper rehash method used when keys can be non-unique.
+      void _M_rehash_aux(size_type __n, std::false_type);
+
+      // Unconditionally change size of bucket array to n, restore
+      // hash policy state to __state on exception.
+      void _M_rehash(size_type __n, const __rehash_state& __state);
+    };
+
+
+  // Definitions of class template _Hashtable's out-of-line member functions.
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+			_Equal, _H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::__node_type*
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_bucket_begin(size_type __bkt) const
+    {
+      __node_base* __n = _M_buckets[__bkt];
+      return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(size_type __bucket_hint,
+	       const _H1& __h1, const _H2& __h2, const _Hash& __h,
+	       const _Equal& __eq, const _ExtractKey& __exk,
+	       const allocator_type& __a)
+    : __hashtable_base(__exk, __h1, __h2, __h, __eq),
+      __map_base(),
+      __rehash_base(),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_element_count(0),
+      _M_rehash_policy()
+    {
+      _M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint);
+      _M_buckets = this->_M_allocate_buckets(_M_bucket_count);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    template<typename _InputIterator>
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _Hashtable(_InputIterator __f, _InputIterator __l,
+		 size_type __bucket_hint,
+		 const _H1& __h1, const _H2& __h2, const _Hash& __h,
+		 const _Equal& __eq, const _ExtractKey& __exk,
+		 const allocator_type& __a)
+      : __hashtable_base(__exk, __h1, __h2, __h, __eq),
+	__map_base(),
+	__rehash_base(),
+	__hashtable_alloc(__node_alloc_type(__a)),
+	_M_element_count(0),
+	_M_rehash_policy()
+      {
+	auto __nb_elems = __detail::__distance_fw(__f, __l);
+	_M_bucket_count =
+	  _M_rehash_policy._M_next_bkt(
+	    std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
+		     __bucket_hint));
+
+	_M_buckets = this->_M_allocate_buckets(_M_bucket_count);
+	__try
+	  {
+	    for (; __f != __l; ++__f)
+	      this->insert(*__f);
+	  }
+	__catch(...)
+	  {
+	    clear();
+	    _M_deallocate_buckets();
+	    __throw_exception_again;
+	  }
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>&
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::operator=(
+		const _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+				 _H1, _H2, _Hash, _RehashPolicy, _Traits>& __ht)
+      {
+	if (&__ht == this)
+	  return *this;
+
+	if (__node_alloc_traits::_S_propagate_on_copy_assign())
+	  {
+	    auto& __this_alloc = this->_M_node_allocator();
+	    auto& __that_alloc = __ht._M_node_allocator();
+	    if (!__node_alloc_traits::_S_always_equal()
+		&& __this_alloc != __that_alloc)
+	      {
+		// Replacement allocator cannot free existing storage.
+		this->_M_deallocate_nodes(_M_begin());
+		if (__builtin_expect(_M_bucket_count != 0, true))
+		  _M_deallocate_buckets();
+		_M_reset();
+		std::__alloc_on_copy(__this_alloc, __that_alloc);
+		__hashtable_base::operator=(__ht);
+		_M_bucket_count = __ht._M_bucket_count;
+		_M_element_count = __ht._M_element_count;
+		_M_rehash_policy = __ht._M_rehash_policy;
+		__try
+		  {
+		    _M_assign(__ht,
+			      [this](const __node_type* __n)
+			      { return this->_M_allocate_node(__n->_M_v()); });
+		  }
+		__catch(...)
+		  {
+		    // _M_assign took care of deallocating all memory. Now we
+		    // must make sure this instance remains in a usable state.
+		    _M_reset();
+		    __throw_exception_again;
+		  }
+		return *this;
+	      }
+	    std::__alloc_on_copy(__this_alloc, __that_alloc);
+	  }
+
+	// Reuse allocated buckets and nodes.
+	__bucket_type* __former_buckets = nullptr;
+	std::size_t __former_bucket_count = _M_bucket_count;
+	const __rehash_state& __former_state = _M_rehash_policy._M_state();
+	
+	if (_M_bucket_count != __ht._M_bucket_count)
+	  {
+	    __former_buckets = _M_buckets;
+	    _M_buckets = this->_M_allocate_buckets(__ht._M_bucket_count);
+	    _M_bucket_count = __ht._M_bucket_count;
+	  }
+	else
+	  __builtin_memset(_M_buckets, 0,
+			   _M_bucket_count * sizeof(__bucket_type));
+
+	__try
+	  {
+	    __hashtable_base::operator=(__ht);
+	    _M_element_count = __ht._M_element_count;
+	    _M_rehash_policy = __ht._M_rehash_policy;
+	    __reuse_or_alloc_node_type __roan(_M_begin(), *this);
+	    _M_before_begin._M_nxt = nullptr;
+	    _M_assign(__ht, 
+		      [&__roan](const __node_type* __n)
+		      { return __roan(__n->_M_v()); });
+	    if (__former_buckets)
+	      this->_M_deallocate_buckets(__former_buckets,
+					  __former_bucket_count);
+	  }
+	__catch(...)
+	  {
+	    if (__former_buckets)
+	      {
+		// Restore previous buckets.
+		_M_deallocate_buckets();
+		_M_rehash_policy._M_reset(__former_state);
+		_M_buckets = __former_buckets;
+		_M_bucket_count = __former_bucket_count;
+	      }
+	    __builtin_memset(_M_buckets, 0,
+			     _M_bucket_count * sizeof(__bucket_type));
+	    __throw_exception_again;
+	  }
+	return *this;
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    template<typename _NodeGenerator>
+      void
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_assign(const _Hashtable& __ht, const _NodeGenerator& __node_gen)
+      {
+	__bucket_type* __buckets = nullptr;
+	if (!_M_buckets)
+	  _M_buckets = __buckets = this->_M_allocate_buckets(_M_bucket_count);
+
+	__try
+	  {
+	    if (!__ht._M_before_begin._M_nxt)
+	      return;
+
+	    // First deal with the special first node pointed to by
+	    // _M_before_begin.
+	    __node_type* __ht_n = __ht._M_begin();
+	    __node_type* __this_n = __node_gen(__ht_n);
+	    this->_M_copy_code(__this_n, __ht_n);
+	    _M_before_begin._M_nxt = __this_n;
+	    _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin;
+
+	    // Then deal with other nodes.
+	    __node_base* __prev_n = __this_n;
+	    for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
+	      {
+		__this_n = __node_gen(__ht_n);
+		__prev_n->_M_nxt = __this_n;
+		this->_M_copy_code(__this_n, __ht_n);
+		size_type __bkt = _M_bucket_index(__this_n);
+		if (!_M_buckets[__bkt])
+		  _M_buckets[__bkt] = __prev_n;
+		__prev_n = __this_n;
+	      }
+	  }
+	__catch(...)
+	  {
+	    clear();
+	    if (__buckets)
+	      _M_deallocate_buckets();
+	    __throw_exception_again;
+	  }
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_reset() noexcept
+    {
+      _M_rehash_policy._M_reset();
+      _M_bucket_count = 0;
+      _M_buckets = nullptr;
+      _M_before_begin._M_nxt = nullptr;
+      _M_element_count = 0;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, std::true_type)
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      if (__builtin_expect(_M_bucket_count != 0, true))
+	_M_deallocate_buckets();
+
+      __hashtable_base::operator=(std::move(__ht));
+      _M_rehash_policy = __ht._M_rehash_policy;
+      _M_buckets = __ht._M_buckets;
+      _M_bucket_count = __ht._M_bucket_count;
+      _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+      _M_element_count = __ht._M_element_count;
+      std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator());
+
+      // Fix buckets containing the _M_before_begin pointers that can't be
+      // moved.
+      if (_M_begin())
+	_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      __ht._M_reset();
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, std::false_type)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+	_M_move_assign(std::move(__ht), std::true_type());
+      else
+	{
+	  // Can't move memory, move elements then.
+	  __bucket_type* __former_buckets = nullptr;
+	  size_type __former_bucket_count = _M_bucket_count;
+	  const __rehash_state& __former_state = _M_rehash_policy._M_state();
+
+	  if (_M_bucket_count != __ht._M_bucket_count)
+	    {
+	      __former_buckets = _M_buckets;
+	      _M_buckets = this->_M_allocate_buckets(__ht._M_bucket_count);
+	      _M_bucket_count = __ht._M_bucket_count;
+	    }
+	  else
+	    __builtin_memset(_M_buckets, 0,
+			     _M_bucket_count * sizeof(__bucket_type));
+
+	  __try
+	    {
+	      __hashtable_base::operator=(std::move(__ht));
+	      _M_element_count = __ht._M_element_count;
+	      _M_rehash_policy = __ht._M_rehash_policy;
+	      __reuse_or_alloc_node_type __roan(_M_begin(), *this);
+	      _M_before_begin._M_nxt = nullptr;
+	      _M_assign(__ht,
+			[&__roan](__node_type* __n)
+			{ return __roan(std::move_if_noexcept(__n->_M_v())); });
+	      __ht.clear();
+	    }
+	  __catch(...)
+	    {
+	      if (__former_buckets)
+		{
+		  _M_deallocate_buckets();
+		  _M_rehash_policy._M_reset(__former_state);
+		  _M_buckets = __former_buckets;
+		  _M_bucket_count = __former_bucket_count;
+		}
+	      __builtin_memset(_M_buckets, 0,
+			       _M_bucket_count * sizeof(__bucket_type));
+	      __throw_exception_again;
+	    }
+	}
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(
+	__node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),
+      _M_buckets(),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      _M_assign(__ht,
+		[this](const __node_type* __n)
+		{ return this->_M_allocate_node(__n->_M_v()); });
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht) noexcept
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(std::move(__ht._M_base_alloc())),
+      _M_buckets(__ht._M_buckets),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_before_begin(__ht._M_before_begin._M_nxt),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      // Update, if necessary, bucket pointing to before begin that hasn't
+      // moved.
+      if (_M_begin())
+	_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      __ht._M_reset();
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      _M_assign(__ht,
+		[this](const __node_type* __n)
+		{ return this->_M_allocate_node(__n->_M_v()); });
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+	{
+	  _M_buckets = __ht._M_buckets;
+	  _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+	  // Update, if necessary, bucket pointing to before begin that hasn't
+	  // moved.
+	  if (_M_begin())
+	    _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+	  __ht._M_reset();
+	}
+      else
+	{
+	  _M_assign(__ht,
+		    [this](__node_type* __n)
+		    {
+		      return this->_M_allocate_node(
+					std::move_if_noexcept(__n->_M_v()));
+		    });
+	  __ht.clear();
+	}
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    ~_Hashtable() noexcept
+    {
+      clear();
+      if (_M_buckets)
+	_M_deallocate_buckets();
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    swap(_Hashtable& __x)
+    noexcept(__node_alloc_traits::_S_nothrow_swap())
+    {
+      // The only base class with member variables is hash_code_base.
+      // We define _Hash_code_base::_M_swap because different
+      // specializations have different members.
+      this->_M_swap(__x);
+
+      std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator());
+      std::swap(_M_rehash_policy, __x._M_rehash_policy);
+      std::swap(_M_buckets, __x._M_buckets);
+      std::swap(_M_bucket_count, __x._M_bucket_count);
+      std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);
+      std::swap(_M_element_count, __x._M_element_count);
+
+      // Fix buckets containing the _M_before_begin pointers that can't be
+      // swapped.
+      if (_M_begin())
+	_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      if (__x._M_begin())
+	__x._M_buckets[__x._M_bucket_index(__x._M_begin())]
+	  = &__x._M_before_begin;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    __rehash_policy(const _RehashPolicy& __pol)
+    {
+      size_type __n_bkt = __pol._M_bkt_for_elements(_M_element_count);
+      __n_bkt = __pol._M_next_bkt(__n_bkt);
+      if (__n_bkt != _M_bucket_count)
+	_M_rehash(__n_bkt, _M_rehash_policy._M_state());
+      _M_rehash_policy = __pol;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::iterator
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k)
+    {
+      if (__builtin_expect(_M_bucket_count == 0, false))
+	return end();
+
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+      return __p ? iterator(__p) : end();
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::const_iterator
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k) const
+    {
+      if (__builtin_expect(_M_bucket_count == 0, false))
+	return end();
+      
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+      return __p ? const_iterator(__p) : end();
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::size_type
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    count(const key_type& __k) const
+    {
+      if (__builtin_expect(_M_bucket_count == 0, false))
+	return 0;
+
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_bucket_begin(__n);
+      if (!__p)
+	return 0;
+
+      std::size_t __result = 0;
+      for (;; __p = __p->_M_next())
+	{
+	  if (this->_M_equals(__k, __code, __p))
+	    ++__result;
+	  else if (__result)
+	    // All equivalent values are next to each other, if we
+	    // found a non-equivalent value after an equivalent one it
+	    // means that we won't find any more equivalent values.
+	    break;
+	  if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n)
+	    break;
+	}
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    std::pair<typename _Hashtable<_Key, _Value, _Alloc,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  _Traits>::iterator,
+	      typename _Hashtable<_Key, _Value, _Alloc,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  _Traits>::iterator>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k)
+    {
+      if (__builtin_expect(_M_bucket_count == 0, false))
+	return std::make_pair(end(), end());
+
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+
+      if (__p)
+	{
+	  __node_type* __p1 = __p->_M_next();
+	  while (__p1 && _M_bucket_index(__p1) == __n
+		 && this->_M_equals(__k, __code, __p1))
+	    __p1 = __p1->_M_next();
+
+	  return std::make_pair(iterator(__p), iterator(__p1));
+	}
+      else
+	return std::make_pair(end(), end());
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    std::pair<typename _Hashtable<_Key, _Value, _Alloc,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  _Traits>::const_iterator,
+	      typename _Hashtable<_Key, _Value, _Alloc,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  _Traits>::const_iterator>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k) const
+    {
+      if (__builtin_expect(_M_bucket_count == 0, false))
+	return std::make_pair(end(), end());
+	
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+
+      if (__p)
+	{
+	  __node_type* __p1 = __p->_M_next();
+	  while (__p1 && _M_bucket_index(__p1) == __n
+		 && this->_M_equals(__k, __code, __p1))
+	    __p1 = __p1->_M_next();
+
+	  return std::make_pair(const_iterator(__p), const_iterator(__p1));
+	}
+      else
+	return std::make_pair(end(), end());
+    }
+
+  // Find the node whose key compares equal to k in the bucket n.
+  // Return nullptr if no node is found.
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+			_Equal, _H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::__node_base*
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_find_before_node(size_type __n, const key_type& __k,
+			__hash_code __code) const
+    {
+      __node_base* __prev_p = _M_buckets[__n];
+      if (!__prev_p)
+	return nullptr;
+
+      for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);;
+	   __p = __p->_M_next())
+	{
+	  if (this->_M_equals(__k, __code, __p))
+	    return __prev_p;
+
+	  if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n)
+	    break;
+	  __prev_p = __p;
+	}
+      return nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_bucket_begin(size_type __bkt, __node_type* __node)
+    {
+      if (_M_buckets[__bkt])
+	{
+	  // Bucket is not empty, we just need to insert the new node
+	  // after the bucket before begin.
+	  __node->_M_nxt = _M_buckets[__bkt]->_M_nxt;
+	  _M_buckets[__bkt]->_M_nxt = __node;
+	}
+      else
+	{
+	  // The bucket is empty, the new node is inserted at the
+	  // beginning of the singly-linked list and the bucket will
+	  // contain _M_before_begin pointer.
+	  __node->_M_nxt = _M_before_begin._M_nxt;
+	  _M_before_begin._M_nxt = __node;
+	  if (__node->_M_nxt)
+	    // We must update former begin bucket that is pointing to
+	    // _M_before_begin.
+	    _M_buckets[_M_bucket_index(__node->_M_next())] = __node;
+	  _M_buckets[__bkt] = &_M_before_begin;
+	}
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_remove_bucket_begin(size_type __bkt, __node_type* __next,
+			   size_type __next_bkt)
+    {
+      if (!__next || __next_bkt != __bkt)
+	{
+	  // Bucket is now empty
+	  // First update next bucket if any
+	  if (__next)
+	    _M_buckets[__next_bkt] = _M_buckets[__bkt];
+
+	  // Second update before begin node if necessary
+	  if (&_M_before_begin == _M_buckets[__bkt])
+	    _M_before_begin._M_nxt = __next;
+	  _M_buckets[__bkt] = nullptr;
+	}
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+			_Equal, _H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::__node_base*
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_get_previous_node(size_type __bkt, __node_base* __n)
+    {
+      __node_base* __prev_n = _M_buckets[__bkt];
+      while (__prev_n->_M_nxt != __n)
+	__prev_n = __prev_n->_M_nxt;
+      return __prev_n;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    template<typename... _Args>
+      std::pair<typename _Hashtable<_Key, _Value, _Alloc,
+				    _ExtractKey, _Equal, _H1,
+				    _H2, _Hash, _RehashPolicy,
+				    _Traits>::iterator, bool>
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(std::true_type, _Args&&... __args)
+      {
+	// First build the node to get access to the hash code
+	__node_type* __node = this->_M_allocate_node(std::forward<_Args>(__args)...);
+	const key_type& __k = this->_M_extract()(__node->_M_v());
+	__hash_code __code;
+	__try
+	  {
+	    __code = this->_M_hash_code(__k);
+	  }
+	__catch(...)
+	  {
+	    this->_M_deallocate_node(__node);
+	    __throw_exception_again;
+	  }
+
+	size_type __bkt = _M_bucket_index(__k, __code);
+	if (__node_type* __p = _M_find_node(__bkt, __k, __code))
+	  {
+	    // There is already an equivalent node, no insertion
+	    this->_M_deallocate_node(__node);
+	    return std::make_pair(iterator(__p), false);
+	  }
+
+	// Insert the node
+	return std::make_pair(_M_insert_unique_node(__bkt, __code, __node),
+			      true);
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    template<typename... _Args>
+      typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			  _H1, _H2, _Hash, _RehashPolicy,
+			  _Traits>::iterator
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(const_iterator __hint, std::false_type, _Args&&... __args)
+      {
+	// First build the node to get its hash code.
+	__node_type* __node =
+	  this->_M_allocate_node(std::forward<_Args>(__args)...);
+
+	__hash_code __code;
+	__try
+	  {
+	    __code = this->_M_hash_code(this->_M_extract()(__node->_M_v()));
+	  }
+	__catch(...)
+	  {
+	    this->_M_deallocate_node(__node);
+	    __throw_exception_again;
+	  }
+
+	return _M_insert_multi_node(__hint._M_cur, __code, __node);
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::iterator
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_unique_node(size_type __bkt, __hash_code __code,
+			  __node_type* __node)
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+	= _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);
+
+      __try
+	{
+	  if (__do_rehash.first)
+	    {
+	      _M_rehash(__do_rehash.second, __saved_state);
+	      __bkt = _M_bucket_index(this->_M_extract()(__node->_M_v()), __code);
+	    }
+
+	  this->_M_store_code(__node, __code);
+
+	  // Always insert at the beginning of the bucket.
+	  _M_insert_bucket_begin(__bkt, __node);
+	  ++_M_element_count;
+	  return iterator(__node);
+	}
+      __catch(...)
+	{
+	  this->_M_deallocate_node(__node);
+	  __throw_exception_again;
+	}
+    }
+
+  // Insert node, in bucket bkt if no rehash (assumes no element with its key
+  // already present). Take ownership of the node, deallocate it on exception.
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::iterator
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_multi_node(__node_type* __hint, __hash_code __code,
+			 __node_type* __node)
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+	= _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);
+
+      __try
+	{
+	  if (__do_rehash.first)
+	    _M_rehash(__do_rehash.second, __saved_state);
+
+	  this->_M_store_code(__node, __code);
+	  const key_type& __k = this->_M_extract()(__node->_M_v());
+	  size_type __bkt = _M_bucket_index(__k, __code);
+
+	  // Find the node before an equivalent one or use hint if it exists and
+	  // if it is equivalent.
+	  __node_base* __prev
+	    = __builtin_expect(__hint != nullptr, false)
+	      && this->_M_equals(__k, __code, __hint)
+		? __hint
+		: _M_find_before_node(__bkt, __k, __code);
+	  if (__prev)
+	    {
+	      // Insert after the node before the equivalent one.
+	      __node->_M_nxt = __prev->_M_nxt;
+	      __prev->_M_nxt = __node;
+	      if (__builtin_expect(__prev == __hint, false))
+	      	// hint might be the last bucket node, in this case we need to
+	      	// update next bucket.
+	      	if (__node->_M_nxt
+	      	    && !this->_M_equals(__k, __code, __node->_M_next()))
+	      	  {
+	      	    size_type __next_bkt = _M_bucket_index(__node->_M_next());
+	      	    if (__next_bkt != __bkt)
+	      	      _M_buckets[__next_bkt] = __node;
+	      	  }
+	    }
+	  else
+	    // The inserted node has no equivalent in the
+	    // hashtable. We must insert the new node at the
+	    // beginning of the bucket to preserve equivalent
+	    // elements' relative positions.
+	    _M_insert_bucket_begin(__bkt, __node);
+	  ++_M_element_count;
+	  return iterator(__node);
+	}
+      __catch(...)
+	{
+	  this->_M_deallocate_node(__node);
+	  __throw_exception_again;
+	}
+    }
+
+  // Insert v if no element with its key is already present.
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      std::pair<typename _Hashtable<_Key, _Value, _Alloc,
+				    _ExtractKey, _Equal, _H1,
+				    _H2, _Hash, _RehashPolicy,
+				    _Traits>::iterator, bool>
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, std::true_type)
+      {
+	const key_type& __k = this->_M_extract()(__v);
+	__hash_code __code = this->_M_hash_code(__k);
+	size_type __bkt = _M_bucket_index(__k, __code);
+
+	__node_type* __n = _M_find_node(__bkt, __k, __code);
+	if (__n)
+	  return std::make_pair(iterator(__n), false);
+
+	__n = __node_gen(std::forward<_Arg>(__v));
+	return std::make_pair(_M_insert_unique_node(__bkt, __code, __n), true);
+      }
+
+  // Insert v unconditionally.
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			  _H1, _H2, _Hash, _RehashPolicy,
+			  _Traits>::iterator
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(const_iterator __hint, _Arg&& __v,
+		const _NodeGenerator& __node_gen,
+		std::false_type)
+      {
+	// First compute the hash code so that we don't do anything if it
+	// throws.
+	__hash_code __code = this->_M_hash_code(this->_M_extract()(__v));
+
+	// Second allocate new node so that we don't rehash if it throws.
+	__node_type* __node = __node_gen(std::forward<_Arg>(__v));
+
+	return _M_insert_multi_node(__hint._M_cur, __code, __node);
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::iterator
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __it)
+    {
+      __node_type* __n = __it._M_cur;
+      std::size_t __bkt = _M_bucket_index(__n);
+
+      // Look for previous node to unlink it from the erased one, this
+      // is why we need buckets to contain the before begin to make
+      // this search fast.
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      return _M_erase(__bkt, __prev_n, __n);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::iterator
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n)
+    {
+      if (__prev_n == _M_buckets[__bkt])
+	_M_remove_bucket_begin(__bkt, __n->_M_next(),
+	   __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
+      else if (__n->_M_nxt)
+	{
+	  size_type __next_bkt = _M_bucket_index(__n->_M_next());
+	  if (__next_bkt != __bkt)
+	    _M_buckets[__next_bkt] = __prev_n;
+	}
+
+      __prev_n->_M_nxt = __n->_M_nxt;
+      iterator __result(__n->_M_next());
+      this->_M_deallocate_node(__n);
+      --_M_element_count;
+
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::size_type
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(std::true_type, const key_type& __k)
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+
+      // Look for the node before the first matching node.
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+	return 0;
+
+      // We found a matching node, erase it.
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      _M_erase(__bkt, __prev_n, __n);
+      return 1;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::size_type
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(std::false_type, const key_type& __k)
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+
+      // Look for the node before the first matching node.
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+	return 0;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 526. Is it undefined if a function in the standard changes
+      // in parameters?
+      // We use one loop to find all matching nodes and another to deallocate
+      // them so that the key stays valid during the first loop. It might be
+      // invalidated indirectly when destroying nodes.
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      __node_type* __n_last = __n;
+      std::size_t __n_last_bkt = __bkt;
+      do
+	{
+	  __n_last = __n_last->_M_next();
+	  if (!__n_last)
+	    break;
+	  __n_last_bkt = _M_bucket_index(__n_last);
+	}
+      while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last));
+
+      // Deallocate nodes.
+      size_type __result = 0;
+      do
+	{
+	  __node_type* __p = __n->_M_next();
+	  this->_M_deallocate_node(__n);
+	  __n = __p;
+	  ++__result;
+	  --_M_element_count;
+	}
+      while (__n != __n_last);
+
+      if (__prev_n == _M_buckets[__bkt])
+	_M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
+      else if (__n_last && __n_last_bkt != __bkt)
+	_M_buckets[__n_last_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n_last;
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			_Traits>::iterator
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __first, const_iterator __last)
+    {
+      __node_type* __n = __first._M_cur;
+      __node_type* __last_n = __last._M_cur;
+      if (__n == __last_n)
+	return iterator(__n);
+
+      std::size_t __bkt = _M_bucket_index(__n);
+
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);
+      std::size_t __n_bkt = __bkt;
+      for (;;)
+	{
+	  do
+	    {
+	      __node_type* __tmp = __n;
+	      __n = __n->_M_next();
+	      this->_M_deallocate_node(__tmp);
+	      --_M_element_count;
+	      if (!__n)
+		break;
+	      __n_bkt = _M_bucket_index(__n);
+	    }
+	  while (__n != __last_n && __n_bkt == __bkt);
+	  if (__is_bucket_begin)
+	    _M_remove_bucket_begin(__bkt, __n, __n_bkt);
+	  if (__n == __last_n)
+	    break;
+	  __is_bucket_begin = true;
+	  __bkt = __n_bkt;
+	}
+
+      if (__n && (__n_bkt != __bkt || __is_bucket_begin))
+	_M_buckets[__n_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n;
+      return iterator(__n);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    clear() noexcept
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type));
+      _M_element_count = 0;
+      _M_before_begin._M_nxt = nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    rehash(size_type __n)
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::size_t __buckets
+	= std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),
+		   __n);
+      __buckets = _M_rehash_policy._M_next_bkt(__buckets);
+
+      if (__buckets != _M_bucket_count)
+	_M_rehash(__buckets, __saved_state);
+      else
+	// No rehash, restore previous state to keep a consistent state.
+	_M_rehash_policy._M_reset(__saved_state);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash(size_type __n, const __rehash_state& __state)
+    {
+      __try
+	{
+	  _M_rehash_aux(__n, __unique_keys());
+	}
+      __catch(...)
+	{
+	  // A failure here means that buckets allocation failed.  We only
+	  // have to restore hash policy previous state.
+	  _M_rehash_policy._M_reset(__state);
+	  __throw_exception_again;
+	}
+    }
+
+  // Rehash when there is no equivalent elements.
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __n, std::true_type)
+    {
+      __bucket_type* __new_buckets = this->_M_allocate_buckets(__n);
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      while (__p)
+	{
+	  __node_type* __next = __p->_M_next();
+	  std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n);
+	  if (!__new_buckets[__bkt])
+	    {
+	      __p->_M_nxt = _M_before_begin._M_nxt;
+	      _M_before_begin._M_nxt = __p;
+	      __new_buckets[__bkt] = &_M_before_begin;
+	      if (__p->_M_nxt)
+		__new_buckets[__bbegin_bkt] = __p;
+	      __bbegin_bkt = __bkt;
+	    }
+	  else
+	    {
+	      __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+	      __new_buckets[__bkt]->_M_nxt = __p;
+	    }
+	  __p = __next;
+	}
+
+      if (__builtin_expect(_M_bucket_count != 0, true))
+	_M_deallocate_buckets();
+      _M_bucket_count = __n;
+      _M_buckets = __new_buckets;
+    }
+
+  // Rehash when there can be equivalent elements, preserve their relative
+  // order.
+  template<typename _Key, typename _Value,
+	   typename _Alloc, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __n, std::false_type)
+    {
+      __bucket_type* __new_buckets = this->_M_allocate_buckets(__n);
+
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      std::size_t __prev_bkt = 0;
+      __node_type* __prev_p = nullptr;
+      bool __check_bucket = false;
+
+      while (__p)
+	{
+	  __node_type* __next = __p->_M_next();
+	  std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n);
+
+	  if (__prev_p && __prev_bkt == __bkt)
+	    {
+	      // Previous insert was already in this bucket, we insert after
+	      // the previously inserted one to preserve equivalent elements
+	      // relative order.
+	      __p->_M_nxt = __prev_p->_M_nxt;
+	      __prev_p->_M_nxt = __p;
+
+	      // Inserting after a node in a bucket require to check that we
+	      // haven't change the bucket last node, in this case next
+	      // bucket containing its before begin node must be updated. We
+	      // schedule a check as soon as we move out of the sequence of
+	      // equivalent nodes to limit the number of checks.
+	      __check_bucket = true;
+	    }
+	  else
+	    {
+	      if (__check_bucket)
+		{
+		  // Check if we shall update the next bucket because of
+		  // insertions into __prev_bkt bucket.
+		  if (__prev_p->_M_nxt)
+		    {
+		      std::size_t __next_bkt
+			= __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
+							    __n);
+		      if (__next_bkt != __prev_bkt)
+			__new_buckets[__next_bkt] = __prev_p;
+		    }
+		  __check_bucket = false;
+		}
+
+	      if (!__new_buckets[__bkt])
+		{
+		  __p->_M_nxt = _M_before_begin._M_nxt;
+		  _M_before_begin._M_nxt = __p;
+		  __new_buckets[__bkt] = &_M_before_begin;
+		  if (__p->_M_nxt)
+		    __new_buckets[__bbegin_bkt] = __p;
+		  __bbegin_bkt = __bkt;
+		}
+	      else
+		{
+		  __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+		  __new_buckets[__bkt]->_M_nxt = __p;
+		}
+	    }
+	  __prev_p = __p;
+	  __prev_bkt = __bkt;
+	  __p = __next;
+	}
+
+      if (__check_bucket && __prev_p->_M_nxt)
+	{
+	  std::size_t __next_bkt
+	    = __hash_code_base::_M_bucket_index(__prev_p->_M_next(), __n);
+	  if (__next_bkt != __prev_bkt)
+	    __new_buckets[__next_bkt] = __prev_p;
+	}
+
+      if (__builtin_expect(_M_bucket_count != 0, true))
+	_M_deallocate_buckets();
+      _M_bucket_count = __n;
+      _M_buckets = __new_buckets;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // _HASHTABLE_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/hashtable_policy.h b/gcc-4.9/libstdc++-v3/include/bits/hashtable_policy.h
new file mode 100644
index 0000000..ef15b0e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/hashtable_policy.h
@@ -0,0 +1,2020 @@
+// Internal policy header for unordered_set and unordered_map -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/hashtable_policy.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly.
+ *  @headername{unordered_map,unordered_set}
+ */
+
+#ifndef _HASHTABLE_POLICY_H
+#define _HASHTABLE_POLICY_H 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    class _Hashtable;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @defgroup hashtable-detail Base and Implementation Classes
+   *  @ingroup unordered_associative_containers
+   *  @{
+   */
+  template<typename _Key, typename _Value,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _Traits>
+    struct _Hashtable_base;
+
+  // Helper function: return distance(first, last) for forward
+  // iterators, or 0 for input iterators.
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+		  std::input_iterator_tag)
+    { return 0; }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+		  std::forward_iterator_tag)
+    { return std::distance(__first, __last); }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last)
+    {
+      typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag;
+      return __distance_fw(__first, __last, _Tag());
+    }
+
+  // Helper type used to detect whether the hash functor is noexcept.
+  template <typename _Key, typename _Hash>
+    struct __is_noexcept_hash : std::integral_constant<bool,
+	noexcept(declval<const _Hash&>()(declval<const _Key&>()))>
+    { };
+
+  struct _Identity
+  {
+    template<typename _Tp>
+      _Tp&&
+      operator()(_Tp&& __x) const
+      { return std::forward<_Tp>(__x); }
+  };
+
+  struct _Select1st
+  {
+    template<typename _Tp>
+      auto
+      operator()(_Tp&& __x) const
+      -> decltype(std::get<0>(std::forward<_Tp>(__x)))
+      { return std::get<0>(std::forward<_Tp>(__x)); }
+  };
+
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc;
+
+  // Functor recycling a pool of nodes and using allocation once the pool is
+  // empty.
+  template<typename _NodeAlloc>
+    struct _ReuseOrAllocNode
+    {
+    private:
+      using __node_alloc_type = _NodeAlloc;
+      using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
+      using __value_alloc_type = typename __hashtable_alloc::__value_alloc_type;
+      using __value_alloc_traits =
+	typename __hashtable_alloc::__value_alloc_traits;
+      using __node_alloc_traits =
+	typename __hashtable_alloc::__node_alloc_traits;
+      using __node_type = typename __hashtable_alloc::__node_type;
+
+    public:
+      _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h)
+	: _M_nodes(__nodes), _M_h(__h) { }
+      _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;
+
+      ~_ReuseOrAllocNode()
+      { _M_h._M_deallocate_nodes(_M_nodes); }
+
+      template<typename _Arg>
+	__node_type*
+	operator()(_Arg&& __arg) const
+	{
+	  if (_M_nodes)
+	    {
+	      __node_type* __node = _M_nodes;
+	      _M_nodes = _M_nodes->_M_next();
+	      __node->_M_nxt = nullptr;
+	      __value_alloc_type __a(_M_h._M_node_allocator());
+	      __value_alloc_traits::destroy(__a, __node->_M_valptr());
+	      __try
+		{
+		  __value_alloc_traits::construct(__a, __node->_M_valptr(),
+						  std::forward<_Arg>(__arg));
+		}
+	      __catch(...)
+		{
+		  __node->~__node_type();
+		  __node_alloc_traits::deallocate(_M_h._M_node_allocator(),
+						  __node, 1);
+		  __throw_exception_again;
+		}
+	      return __node;
+	    }
+	  return _M_h._M_allocate_node(std::forward<_Arg>(__arg));
+	}
+
+    private:
+      mutable __node_type* _M_nodes;
+      __hashtable_alloc& _M_h;
+    };
+
+  // Functor similar to the previous one but without any pool of nodes to
+  // recycle.
+  template<typename _NodeAlloc>
+    struct _AllocNode
+    {
+    private:
+      using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;
+      using __node_type = typename __hashtable_alloc::__node_type;
+
+    public:
+      _AllocNode(__hashtable_alloc& __h)
+	: _M_h(__h) { }
+
+      template<typename _Arg>
+	__node_type*
+	operator()(_Arg&& __arg) const
+	{ return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); }
+
+    private:
+      __hashtable_alloc& _M_h;
+    };
+
+  // Auxiliary types used for all instantiations of _Hashtable nodes
+  // and iterators.
+
+  /**
+   *  struct _Hashtable_traits
+   *
+   *  Important traits for hash tables.
+   *
+   *  @tparam _Cache_hash_code  Boolean value. True if the value of
+   *  the hash function is stored along with the value. This is a
+   *  time-space tradeoff.  Storing it may improve lookup speed by
+   *  reducing the number of times we need to call the _Equal
+   *  function.
+   *
+   *  @tparam _Constant_iterators  Boolean value. True if iterator and
+   *  const_iterator are both constant iterator types. This is true
+   *  for unordered_set and unordered_multiset, false for
+   *  unordered_map and unordered_multimap.
+   *
+   *  @tparam _Unique_keys  Boolean value. True if the return value
+   *  of _Hashtable::count(k) is always at most one, false if it may
+   *  be an arbitrary number. This is true for unordered_set and
+   *  unordered_map, false for unordered_multiset and
+   *  unordered_multimap.
+   */
+  template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys>
+    struct _Hashtable_traits
+    {
+      template<bool _Cond>
+	using __bool_constant = integral_constant<bool, _Cond>;
+
+      using __hash_cached = __bool_constant<_Cache_hash_code>;
+      using __constant_iterators = __bool_constant<_Constant_iterators>;
+      using __unique_keys = __bool_constant<_Unique_keys>;
+    };
+
+  /**
+   *  struct _Hash_node_base
+   *
+   *  Nodes, used to wrap elements stored in the hash table.  A policy
+   *  template parameter of class template _Hashtable controls whether
+   *  nodes also store a hash code. In some cases (e.g. strings) this
+   *  may be a performance win.
+   */
+  struct _Hash_node_base
+  {
+    _Hash_node_base* _M_nxt;
+
+    _Hash_node_base() noexcept : _M_nxt() { }
+
+    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
+  };
+
+  /**
+   *  struct _Hash_node_value_base
+   *
+   *  Node type with the value to store.
+   */
+  template<typename _Value>
+    struct _Hash_node_value_base : _Hash_node_base
+    {
+      typedef _Value value_type;
+
+      __gnu_cxx::__aligned_buffer<_Value> _M_storage;
+
+      _Value*
+      _M_valptr() noexcept
+      { return _M_storage._M_ptr(); }
+
+      const _Value*
+      _M_valptr() const noexcept
+      { return _M_storage._M_ptr(); }
+
+      _Value&
+      _M_v() noexcept
+      { return *_M_valptr(); }
+
+      const _Value&
+      _M_v() const noexcept
+      { return *_M_valptr(); }
+    };
+
+  /**
+   *  Primary template struct _Hash_node.
+   */
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Hash_node;
+
+  /**
+   *  Specialization for nodes with caches, struct _Hash_node.
+   *
+   *  Base class is __detail::_Hash_node_value_base.
+   */
+  template<typename _Value>
+    struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value>
+    {
+      std::size_t  _M_hash_code;
+
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+
+  /**
+   *  Specialization for nodes without caches, struct _Hash_node.
+   *
+   *  Base class is __detail::_Hash_node_value_base.
+   */
+  template<typename _Value>
+    struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
+    {
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+
+  /// Base class for node iterators.
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Node_iterator_base
+    {
+      using __node_type = _Hash_node<_Value, _Cache_hash_code>;
+
+      __node_type*  _M_cur;
+
+      _Node_iterator_base(__node_type* __p) noexcept
+      : _M_cur(__p) { }
+
+      void
+      _M_incr() noexcept
+      { _M_cur = _M_cur->_M_next(); }
+    };
+
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+	       const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
+    noexcept
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+	       const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
+    noexcept
+    { return __x._M_cur != __y._M_cur; }
+
+  /// Node iterators, used to iterate through all the hashtable.
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+
+    public:
+      typedef _Value					value_type;
+      typedef std::ptrdiff_t				difference_type;
+      typedef std::forward_iterator_tag			iterator_category;
+
+      using pointer = typename std::conditional<__constant_iterators,
+						const _Value*, _Value*>::type;
+
+      using reference = typename std::conditional<__constant_iterators,
+						  const _Value&, _Value&>::type;
+
+      _Node_iterator() noexcept
+      : __base_type(0) { }
+
+      explicit
+      _Node_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+
+      _Node_iterator&
+      operator++() noexcept
+      {
+	this->_M_incr();
+	return *this;
+      }
+
+      _Node_iterator
+      operator++(int) noexcept
+      {
+	_Node_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+  /// Node const_iterators, used to iterate through all the hashtable.
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_const_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+
+    public:
+      typedef _Value					value_type;
+      typedef std::ptrdiff_t				difference_type;
+      typedef std::forward_iterator_tag			iterator_category;
+
+      typedef const _Value*				pointer;
+      typedef const _Value&				reference;
+
+      _Node_const_iterator() noexcept
+      : __base_type(0) { }
+
+      explicit
+      _Node_const_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+
+      _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
+			   __cache>& __x) noexcept
+      : __base_type(__x._M_cur) { }
+
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+
+      _Node_const_iterator&
+      operator++() noexcept
+      {
+	this->_M_incr();
+	return *this;
+      }
+
+      _Node_const_iterator
+      operator++(int) noexcept
+      {
+	_Node_const_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+  // Many of class template _Hashtable's template parameters are policy
+  // classes.  These are defaults for the policies.
+
+  /// Default range hashing function: use division to fold a large number
+  /// into the range [0, N).
+  struct _Mod_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+
+    result_type
+    operator()(first_argument_type __num,
+	       second_argument_type __den) const noexcept
+    { return __num % __den; }
+  };
+
+  /// Default ranged hash function H.  In principle it should be a
+  /// function object composed from objects of type H1 and H2 such that
+  /// h(k, N) = h2(h1(k), N), but that would mean making extra copies of
+  /// h1 and h2.  So instead we'll just use a tag to tell class template
+  /// hashtable to do that composition.
+  struct _Default_ranged_hash { };
+
+  /// Default value for rehash policy.  Bucket size is (usually) the
+  /// smallest prime that keeps the load factor small enough.
+  struct _Prime_rehash_policy
+  {
+    _Prime_rehash_policy(float __z = 1.0)
+    : _M_max_load_factor(__z), _M_next_resize(0) { }
+
+    float
+    max_load_factor() const noexcept
+    { return _M_max_load_factor; }
+
+    // Return a bucket size no smaller than n.
+    std::size_t
+    _M_next_bkt(std::size_t __n) const;
+
+    // Return a bucket count appropriate for n elements
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const
+    { return __builtin_ceil(__n / (long double)_M_max_load_factor); }
+
+    // __n_bkt is current bucket count, __n_elt is current element count,
+    // and __n_ins is number of elements to be inserted.  Do we need to
+    // increase bucket count?  If so, return make_pair(true, n), where n
+    // is the new bucket count.  If not, return make_pair(false, 0).
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+		   std::size_t __n_ins) const;
+
+    typedef std::size_t _State;
+
+    _State
+    _M_state() const
+    { return _M_next_resize; }
+
+    void
+    _M_reset() noexcept
+    { _M_next_resize = 0; }
+
+    void
+    _M_reset(_State __state)
+    { _M_next_resize = __state; }
+
+    enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 };
+
+    static const std::size_t _S_growth_factor = 2;
+
+    float		_M_max_load_factor;
+    mutable std::size_t	_M_next_resize;
+  };
+
+  // Base classes for std::_Hashtable.  We define these base classes
+  // because in some cases we want to do different things depending on
+  // the value of a policy class.  In some cases the policy class
+  // affects which member functions and nested typedefs are defined;
+  // we handle that by specializing base class templates.  Several of
+  // the base class templates need to access other members of class
+  // template _Hashtable, so we use a variant of the "Curiously
+  // Recurring Template Pattern" (CRTP) technique.
+
+  /**
+   *  Primary class template _Map_base.
+   *
+   *  If the hashtable has a value type of the form pair<T1, T2> and a
+   *  key extraction policy (_ExtractKey) that returns the first part
+   *  of the pair, the hashtable gets a mapped_type typedef.  If it
+   *  satisfies those criteria and also has unique keys, then it also
+   *  gets an operator[].
+   */
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits,
+	   bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Map_base { };
+
+  /// Partial specialization, __unique_keys set to false.
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+		     _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    {
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+    };
+
+  /// Partial specialization, __unique_keys set to true.
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+		     _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+    private:
+      using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair,
+							 _Select1st,
+							_Equal, _H1, _H2, _Hash,
+							  _Traits>;
+
+      using __hashtable = _Hashtable<_Key, _Pair, _Alloc,
+				     _Select1st, _Equal,
+				     _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      using __hash_code = typename __hashtable_base::__hash_code;
+      using __node_type = typename __hashtable_base::__node_type;
+
+    public:
+      using key_type = typename __hashtable_base::key_type;
+      using iterator = typename __hashtable_base::iterator;
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+
+      mapped_type&
+      operator[](const key_type& __k);
+
+      mapped_type&
+      operator[](key_type&& __k);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 761. unordered_map needs an at() member function.
+      mapped_type&
+      at(const key_type& __k);
+
+      const mapped_type&
+      at(const key_type& __k) const;
+    };
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+		       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+		       ::mapped_type&
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+	      _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](const key_type& __k)
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+
+      if (!__p)
+	{
+	  __p = __h->_M_allocate_node(std::piecewise_construct,
+				      std::tuple<const key_type&>(__k),
+				      std::tuple<>());
+	  return __h->_M_insert_unique_node(__n, __code, __p)->second;
+	}
+
+      return __p->_M_v().second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+		       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+		       ::mapped_type&
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+	      _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](key_type&& __k)
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+
+      if (!__p)
+	{
+	  __p = __h->_M_allocate_node(std::piecewise_construct,
+				      std::forward_as_tuple(std::move(__k)),
+				      std::tuple<>());
+	  return __h->_M_insert_unique_node(__n, __code, __p)->second;
+	}
+
+      return __p->_M_v().second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+		       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+		       ::mapped_type&
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+	      _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k)
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+
+      if (!__p)
+	__throw_out_of_range(__N("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    const typename _Map_base<_Key, _Pair, _Alloc, _Select1st,
+			     _Equal, _H1, _H2, _Hash, _RehashPolicy,
+			     _Traits, true>::mapped_type&
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+	      _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k) const
+    {
+      const __hashtable* __h = static_cast<const __hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+
+      if (!__p)
+	__throw_out_of_range(__N("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+
+  /**
+   *  Primary class template _Insert_base.
+   *
+   *  insert member functions appropriate to all _Hashtables.
+   */
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Insert_base
+    {
+    protected:
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+				     _Equal, _H1, _H2, _Hash,
+				     _RehashPolicy, _Traits>;
+
+      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
+					       _Equal, _H1, _H2, _Hash,
+					       _Traits>;
+
+      using value_type = typename __hashtable_base::value_type;
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator =  typename __hashtable_base::const_iterator;
+      using size_type = typename __hashtable_base::size_type;
+
+      using __unique_keys = typename __hashtable_base::__unique_keys;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>;
+      using __node_alloc_type =
+	typename __alloctr_rebind<_Alloc, __node_type>::__type;
+      using __node_gen_type = _AllocNode<__node_alloc_type>;
+
+      __hashtable&
+      _M_conjure_hashtable()
+      { return *(static_cast<__hashtable*>(this)); }
+
+      template<typename _InputIterator, typename _NodeGetter>
+	void
+	_M_insert_range(_InputIterator __first, _InputIterator __last,
+			const _NodeGetter&);
+
+    public:
+      __ireturn_type
+      insert(const value_type& __v)
+      {
+	__hashtable& __h = _M_conjure_hashtable();
+	__node_gen_type __node_gen(__h);
+	return __h._M_insert(__v, __node_gen, __unique_keys());
+      }
+
+      iterator
+      insert(const_iterator __hint, const value_type& __v)
+      {
+	__hashtable& __h = _M_conjure_hashtable();
+	__node_gen_type __node_gen(__h);	
+	return __h._M_insert(__hint, __v, __node_gen, __unique_keys());
+      }
+
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{
+	  __hashtable& __h = _M_conjure_hashtable();
+	  __node_gen_type __node_gen(__h);
+	  return _M_insert_range(__first, __last, __node_gen);
+	}
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    template<typename _InputIterator, typename _NodeGetter>
+      void
+      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+		    _RehashPolicy, _Traits>::
+      _M_insert_range(_InputIterator __first, _InputIterator __last,
+		      const _NodeGetter& __node_gen)
+      {
+	using __rehash_type = typename __hashtable::__rehash_type;
+	using __rehash_state = typename __hashtable::__rehash_state;
+	using pair_type = std::pair<bool, std::size_t>;
+
+	size_type __n_elt = __detail::__distance_fw(__first, __last);
+
+	__hashtable& __h = _M_conjure_hashtable();
+	__rehash_type& __rehash = __h._M_rehash_policy;
+	const __rehash_state& __saved_state = __rehash._M_state();
+	pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count,
+							__h._M_element_count,
+							__n_elt);
+
+	if (__do_rehash.first)
+	  __h._M_rehash(__do_rehash.second, __saved_state);
+
+	for (; __first != __last; ++__first)
+	  __h._M_insert(*__first, __node_gen, __unique_keys());
+      }
+
+  /**
+   *  Primary class template _Insert.
+   *
+   *  Select insert member functions appropriate to _Hashtable policy choices.
+   */
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits,
+	   bool _Constant_iterators = _Traits::__constant_iterators::value,
+	   bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Insert;
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+		   _RehashPolicy, _Traits, true, true>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			   _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+					_Equal, _H1, _H2, _Hash,
+					_RehashPolicy, _Traits>;
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator =  typename __base_type::const_iterator;
+
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __hashtable = typename __base_type::__hashtable;
+      using __node_gen_type = typename __base_type::__node_gen_type;
+
+      using __base_type::insert;
+
+      std::pair<iterator, bool>
+      insert(value_type&& __v)
+      {
+	__hashtable& __h = this->_M_conjure_hashtable();
+	__node_gen_type __node_gen(__h);
+	return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
+      }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __v)
+      {
+	__hashtable& __h = this->_M_conjure_hashtable();
+	__node_gen_type __node_gen(__h);
+	return __h._M_insert(__hint, std::move(__v), __node_gen,
+			     __unique_keys());
+      }
+    };
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+		   _RehashPolicy, _Traits, true, false>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			   _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+					_Equal, _H1, _H2, _Hash,
+					_RehashPolicy, _Traits>;
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator =  typename __base_type::const_iterator;
+
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __hashtable = typename __base_type::__hashtable;
+      using __node_gen_type = typename __base_type::__node_gen_type;
+
+      using __base_type::insert;
+
+      iterator
+      insert(value_type&& __v)
+      {
+	__hashtable& __h = this->_M_conjure_hashtable();
+	__node_gen_type __node_gen(__h);
+	return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
+      }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __v)
+      {
+	__hashtable& __h = this->_M_conjure_hashtable();
+	__node_gen_type __node_gen(__h);
+	return __h._M_insert(__hint, std::move(__v), __node_gen,
+			     __unique_keys());
+      }
+    };
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits, bool _Unique_keys>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+		   _RehashPolicy, _Traits, false, _Unique_keys>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			   _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+				       _Equal, _H1, _H2, _Hash,
+				       _RehashPolicy, _Traits>;
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator =  typename __base_type::const_iterator;
+
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __hashtable = typename __base_type::__hashtable;
+      using __ireturn_type = typename __base_type::__ireturn_type;
+
+      using __base_type::insert;
+
+      template<typename _Pair>
+	using __is_cons = std::is_constructible<value_type, _Pair&&>;
+
+      template<typename _Pair>
+	using _IFcons = std::enable_if<__is_cons<_Pair>::value>;
+
+      template<typename _Pair>
+	using _IFconsp = typename _IFcons<_Pair>::type;
+
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+	__ireturn_type
+	insert(_Pair&& __v)
+	{
+	  __hashtable& __h = this->_M_conjure_hashtable();
+	  return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v));
+	}
+
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+	iterator
+	insert(const_iterator __hint, _Pair&& __v)
+	{
+	  __hashtable& __h = this->_M_conjure_hashtable();
+	  return __h._M_emplace(__hint, __unique_keys(),
+				std::forward<_Pair>(__v));
+	}
+   };
+
+  /**
+   *  Primary class template  _Rehash_base.
+   *
+   *  Give hashtable the max_load_factor functions and reserve iff the
+   *  rehash policy is _Prime_rehash_policy.
+  */
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Rehash_base;
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _Traits>
+    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _Prime_rehash_policy, _Traits>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+				     _Equal, _H1, _H2, _Hash,
+				     _Prime_rehash_policy, _Traits>;
+
+      float
+      max_load_factor() const noexcept
+      {
+	const __hashtable* __this = static_cast<const __hashtable*>(this);
+	return __this->__rehash_policy().max_load_factor();
+      }
+
+      void
+      max_load_factor(float __z)
+      {
+	__hashtable* __this = static_cast<__hashtable*>(this);
+	__this->__rehash_policy(_Prime_rehash_policy(__z));
+      }
+
+      void
+      reserve(std::size_t __n)
+      {
+	__hashtable* __this = static_cast<__hashtable*>(this);
+	__this->rehash(__builtin_ceil(__n / max_load_factor()));
+      }
+    };
+
+  /**
+   *  Primary class template _Hashtable_ebo_helper.
+   *
+   *  Helper class using EBO when it is not forbidden (the type is not
+   *  final) and when it is worth it (the type is empty.)
+   */
+  template<int _Nm, typename _Tp,
+	   bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+    struct _Hashtable_ebo_helper;
+
+  /// Specialization using EBO.
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, true>
+    : private _Tp
+    {
+      _Hashtable_ebo_helper() = default;
+
+      template<typename _OtherTp>
+	_Hashtable_ebo_helper(_OtherTp&& __tp)
+	  : _Tp(std::forward<_OtherTp>(__tp))
+	{ }
+
+      static const _Tp&
+      _S_cget(const _Hashtable_ebo_helper& __eboh)
+      { return static_cast<const _Tp&>(__eboh); }
+
+      static _Tp&
+      _S_get(_Hashtable_ebo_helper& __eboh)
+      { return static_cast<_Tp&>(__eboh); }
+    };
+
+  /// Specialization not using EBO.
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, false>
+    {
+      _Hashtable_ebo_helper() = default;
+
+      template<typename _OtherTp>
+	_Hashtable_ebo_helper(_OtherTp&& __tp)
+	  : _M_tp(std::forward<_OtherTp>(__tp))
+	{ }
+
+      static const _Tp&
+      _S_cget(const _Hashtable_ebo_helper& __eboh)
+      { return __eboh._M_tp; }
+
+      static _Tp&
+      _S_get(_Hashtable_ebo_helper& __eboh)
+      { return __eboh._M_tp; }
+
+    private:
+      _Tp _M_tp;
+    };
+
+  /**
+   *  Primary class template _Local_iterator_base.
+   *
+   *  Base class for local iterators, used to iterate within a bucket
+   *  but not between buckets.
+   */
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash,
+	   bool __cache_hash_code>
+    struct _Local_iterator_base;
+
+  /**
+   *  Primary class template _Hash_code_base.
+   *
+   *  Encapsulates two policy issues that aren't quite orthogonal.
+   *   (1) the difference between using a ranged hash function and using
+   *       the combination of a hash function and a range-hashing function.
+   *       In the former case we don't have such things as hash codes, so
+   *       we have a dummy type as placeholder.
+   *   (2) Whether or not we cache hash codes.  Caching hash codes is
+   *       meaningless if we have a ranged hash function.
+   *
+   *  We also put the key extraction objects here, for convenience.
+   *  Each specialization derives from one or more of the template
+   *  parameters to benefit from Ebo. This is important as this type
+   *  is inherited in some cases by the _Local_iterator_base type used
+   *  to implement local_iterator and const_local_iterator. As with
+   *  any iterator type we prefer to make it as small as possible.
+   *
+   *  Primary template is unused except as a hook for specializations.
+   */
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash,
+	   bool __cache_hash_code>
+    struct _Hash_code_base;
+
+  /// Specialization: ranged hash function, no caching hash codes.  H1
+  /// and H2 are provided but ignored.  We define a dummy hash code type.
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _Hash>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;
+
+    protected:
+      typedef void* 					__hash_code;
+      typedef _Hash_node<_Value, false>			__node_type;
+
+      // We need the default constructor for the local iterators.
+      _Hash_code_base() = default;
+
+      _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&,
+		      const _Hash& __h)
+      : __ebo_extract_key(__ex), __ebo_hash(__h) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __key) const
+      { return 0; }
+
+      std::size_t
+      _M_bucket_index(const _Key& __k, __hash_code, std::size_t __n) const
+      { return _M_ranged_hash()(__k, __n); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __n) const
+	noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>(),
+						   (std::size_t)0)) )
+      { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __n); }
+
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+	std::swap(_M_extract(), __x._M_extract());
+	std::swap(_M_ranged_hash(), __x._M_ranged_hash());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
+
+      _ExtractKey&
+      _M_extract() { return __ebo_extract_key::_S_get(*this); }
+
+      const _Hash&
+      _M_ranged_hash() const { return __ebo_hash::_S_cget(*this); }
+
+      _Hash&
+      _M_ranged_hash() { return __ebo_hash::_S_get(*this); }
+    };
+
+  // No specialization for ranged hash function while caching hash codes.
+  // That combination is meaningless, and trying to do it is an error.
+
+  /// Specialization: ranged hash function, cache hash codes.  This
+  /// combination is meaningless, so we provide only a declaration
+  /// and no definition.
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>;
+
+  /// Specialization: hash function and range-hashing function, no
+  /// caching of hash codes.
+  /// Provides typedef and accessor required by C++ 11.
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+			   _Default_ranged_hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+
+      // Gives the local iterator implementation access to _M_bucket_index().
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+					 _Default_ranged_hash, false>;
+
+    public:
+      typedef _H1 					hasher;
+
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+
+    protected:
+      typedef std::size_t 				__hash_code;
+      typedef _Hash_node<_Value, false>			__node_type;
+
+      // We need the default constructor for the local iterators.
+      _Hash_code_base() = default;
+
+      _Hash_code_base(const _ExtractKey& __ex,
+		      const _H1& __h1, const _H2& __h2,
+		      const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      { return _M_h1()(__k); }
+
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c, std::size_t __n) const
+      { return _M_h2()(__c, __n); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __n) const
+	noexcept( noexcept(declval<const _H1&>()(declval<const _Key&>()))
+		  && noexcept(declval<const _H2&>()((__hash_code)0,
+						    (std::size_t)0)) )
+      { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __n); }
+
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+	std::swap(_M_extract(), __x._M_extract());
+	std::swap(_M_h1(), __x._M_h1());
+	std::swap(_M_h2(), __x._M_h2());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
+
+      _ExtractKey&
+      _M_extract() { return __ebo_extract_key::_S_get(*this); }
+
+      const _H1&
+      _M_h1() const { return __ebo_h1::_S_cget(*this); }
+
+      _H1&
+      _M_h1() { return __ebo_h1::_S_get(*this); }
+
+      const _H2&
+      _M_h2() const { return __ebo_h2::_S_cget(*this); }
+
+      _H2&
+      _M_h2() { return __ebo_h2::_S_get(*this); }
+    };
+
+  /// Specialization: hash function and range-hashing function,
+  /// caching hash codes.  H is provided but ignored.  Provides
+  /// typedef and accessor required by C++ 11.
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+			   _Default_ranged_hash, true>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+      // Gives the local iterator implementation access to _M_h2().
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+					 _Default_ranged_hash, true>;
+
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+
+    public:
+      typedef _H1 					hasher;
+
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+
+    protected:
+      typedef std::size_t 				__hash_code;
+      typedef _Hash_node<_Value, true>			__node_type;
+
+      _Hash_code_base(const _ExtractKey& __ex,
+		      const _H1& __h1, const _H2& __h2,
+		      const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      { return _M_h1()(__k); }
+
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c,
+		      std::size_t __n) const
+      { return _M_h2()(__c, __n); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __n) const
+	noexcept( noexcept(declval<const _H2&>()((__hash_code)0,
+						 (std::size_t)0)) )
+      { return _M_h2()(__p->_M_hash_code, __n); }
+
+      void
+      _M_store_code(__node_type* __n, __hash_code __c) const
+      { __n->_M_hash_code = __c; }
+
+      void
+      _M_copy_code(__node_type* __to, const __node_type* __from) const
+      { __to->_M_hash_code = __from->_M_hash_code; }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+	std::swap(_M_extract(), __x._M_extract());
+	std::swap(_M_h1(), __x._M_h1());
+	std::swap(_M_h2(), __x._M_h2());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
+
+      _ExtractKey&
+      _M_extract() { return __ebo_extract_key::_S_get(*this); }
+
+      const _H1&
+      _M_h1() const { return __ebo_h1::_S_cget(*this); }
+
+      _H1&
+      _M_h1() { return __ebo_h1::_S_get(*this); }
+
+      const _H2&
+      _M_h2() const { return __ebo_h2::_S_cget(*this); }
+
+      _H2&
+      _M_h2() { return __ebo_h2::_S_get(*this); }
+    };
+
+  /**
+   *  Primary class template _Equal_helper.
+   *
+   */
+  template <typename _Key, typename _Value, typename _ExtractKey,
+	    typename _Equal, typename _HashCodeType,
+	    bool __cache_hash_code>
+  struct _Equal_helper;
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _Equal, typename _HashCodeType>
+  struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, true>
+  {
+    static bool
+    _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
+	      const _Key& __k, _HashCodeType __c, _Hash_node<_Value, true>* __n)
+    { return __c == __n->_M_hash_code && __eq(__k, __extract(__n->_M_v())); }
+  };
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _Equal, typename _HashCodeType>
+  struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, false>
+  {
+    static bool
+    _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
+	      const _Key& __k, _HashCodeType, _Hash_node<_Value, false>* __n)
+    { return __eq(__k, __extract(__n->_M_v())); }
+  };
+
+
+  /// Partial specialization used when nodes contain a cached hash code.
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+				_H1, _H2, _Hash, true>
+    : private _Hashtable_ebo_helper<0, _H2>
+    {
+    protected:
+      using __base_type = _Hashtable_ebo_helper<0, _H2>;
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+					       _H1, _H2, _Hash, true>;
+
+      _Local_iterator_base() = default;
+      _Local_iterator_base(const __hash_code_base& __base,
+			   _Hash_node<_Value, true>* __p,
+			   std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base._M_h2()),
+	_M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }
+
+      void
+      _M_incr()
+      {
+	_M_cur = _M_cur->_M_next();
+	if (_M_cur)
+	  {
+	    std::size_t __bkt
+	      = __base_type::_S_get(*this)(_M_cur->_M_hash_code,
+					   _M_bucket_count);
+	    if (__bkt != _M_bucket)
+	      _M_cur = nullptr;
+	  }
+      }
+
+      _Hash_node<_Value, true>*  _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }  // for equality ops
+
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }  // for debug mode
+    };
+
+  // Uninitialized storage for a _Hash_code_base.
+  // This type is DefaultConstructible and Assignable even if the
+  // _Hash_code_base type isn't, so that _Local_iterator_base<..., false>
+  // can be DefaultConstructible and Assignable.
+  template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value>
+    struct _Hash_code_storage
+    {
+      __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+
+      _Tp*
+      _M_h() { return _M_storage._M_ptr(); }
+
+      const _Tp*
+      _M_h() const { return _M_storage._M_ptr(); }
+    };
+
+  // Empty partial specialization for empty _Hash_code_base types.
+  template<typename _Tp>
+    struct _Hash_code_storage<_Tp, true>
+    {
+      static_assert( std::is_empty<_Tp>::value, "Type must be empty" );
+
+      // As _Tp is an empty type there will be no bytes written/read through
+      // the cast pointer, so no strict-aliasing violation.
+      _Tp*
+      _M_h() { return reinterpret_cast<_Tp*>(this); }
+
+      const _Tp*
+      _M_h() const { return reinterpret_cast<const _Tp*>(this); }
+    };
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash>
+    using __hash_code_for_local_iter
+      = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey,
+					   _H1, _H2, _Hash, false>>;
+
+  // Partial specialization used when hash codes are not cached
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+				_H1, _H2, _Hash, false>
+    : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash>
+    {
+    protected:
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+					       _H1, _H2, _Hash, false>;
+
+      _Local_iterator_base() : _M_bucket_count(-1) { }
+
+      _Local_iterator_base(const __hash_code_base& __base,
+			   _Hash_node<_Value, false>* __p,
+			   std::size_t __bkt, std::size_t __bkt_count)
+      : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
+      { _M_init(__base); }
+
+      ~_Local_iterator_base()
+      {
+	if (_M_bucket_count != -1)
+	  _M_destroy();
+      }
+
+      _Local_iterator_base(const _Local_iterator_base& __iter)
+      : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket),
+        _M_bucket_count(__iter._M_bucket_count)
+      {
+	if (_M_bucket_count != -1)
+	  _M_init(*__iter._M_h());
+      }
+
+      _Local_iterator_base&
+      operator=(const _Local_iterator_base& __iter)
+      {
+	if (_M_bucket_count != -1)
+	  _M_destroy();
+	_M_cur = __iter._M_cur;
+	_M_bucket = __iter._M_bucket;
+	_M_bucket_count = __iter._M_bucket_count;
+	if (_M_bucket_count != -1)
+	  _M_init(*__iter._M_h());
+	return *this;
+      }
+
+      void
+      _M_incr()
+      {
+	_M_cur = _M_cur->_M_next();
+	if (_M_cur)
+	  {
+	    std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur,
+							      _M_bucket_count);
+	    if (__bkt != _M_bucket)
+	      _M_cur = nullptr;
+	  }
+      }
+
+      _Hash_node<_Value, false>*  _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+
+      void
+      _M_init(const __hash_code_base& __base)
+      { ::new(this->_M_h()) __hash_code_base(__base); }
+
+      void
+      _M_destroy() { this->_M_h()->~__hash_code_base(); }
+
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }  // for equality ops and debug mode
+
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }  // for debug mode
+    };
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+					  _H1, _H2, _Hash, __cache>& __x,
+	       const _Local_iterator_base<_Key, _Value, _ExtractKey,
+					  _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() == __y._M_curr(); }
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+					  _H1, _H2, _Hash, __cache>& __x,
+	       const _Local_iterator_base<_Key, _Value, _ExtractKey,
+					  _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() != __y._M_curr(); }
+
+  /// local iterators
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash,
+	   bool __constant_iterators, bool __cache>
+    struct _Local_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+				  _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+					       _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+    public:
+      typedef _Value					value_type;
+      typedef typename std::conditional<__constant_iterators,
+					const _Value*, _Value*>::type
+						       pointer;
+      typedef typename std::conditional<__constant_iterators,
+					const _Value&, _Value&>::type
+						       reference;
+      typedef std::ptrdiff_t				difference_type;
+      typedef std::forward_iterator_tag			iterator_category;
+
+      _Local_iterator() = default;
+
+      _Local_iterator(const __hash_code_base& __base,
+		      _Hash_node<_Value, __cache>* __p,
+		      std::size_t __bkt, std::size_t __bkt_count)
+	: __base_type(__base, __p, __bkt, __bkt_count)
+      { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+
+      _Local_iterator&
+      operator++()
+      {
+	this->_M_incr();
+	return *this;
+      }
+
+      _Local_iterator
+      operator++(int)
+      {
+	_Local_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+  /// local const_iterators
+  template<typename _Key, typename _Value, typename _ExtractKey,
+	   typename _H1, typename _H2, typename _Hash,
+	   bool __constant_iterators, bool __cache>
+    struct _Local_const_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+				  _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+					       _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+
+    public:
+      typedef _Value					value_type;
+      typedef const _Value*				pointer;
+      typedef const _Value&				reference;
+      typedef std::ptrdiff_t				difference_type;
+      typedef std::forward_iterator_tag			iterator_category;
+
+      _Local_const_iterator() = default;
+
+      _Local_const_iterator(const __hash_code_base& __base,
+			    _Hash_node<_Value, __cache>* __p,
+			    std::size_t __bkt, std::size_t __bkt_count)
+	: __base_type(__base, __p, __bkt, __bkt_count)
+      { }
+
+      _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
+						  _H1, _H2, _Hash,
+						  __constant_iterators,
+						  __cache>& __x)
+	: __base_type(__x)
+      { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+
+      _Local_const_iterator&
+      operator++()
+      {
+	this->_M_incr();
+	return *this;
+      }
+
+      _Local_const_iterator
+      operator++(int)
+      {
+	_Local_const_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+  /**
+   *  Primary class template _Hashtable_base.
+   *
+   *  Helper class adding management of _Equal functor to
+   *  _Hash_code_base type.
+   *
+   *  Base class templates are:
+   *    - __detail::_Hash_code_base
+   *    - __detail::_Hashtable_ebo_helper
+   */
+  template<typename _Key, typename _Value,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _Traits>
+  struct _Hashtable_base
+  : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+			   _Traits::__hash_cached::value>,
+    private _Hashtable_ebo_helper<0, _Equal>
+  {
+  public:
+    typedef _Key					key_type;
+    typedef _Value					value_type;
+    typedef _Equal					key_equal;
+    typedef std::size_t					size_type;
+    typedef std::ptrdiff_t				difference_type;
+
+    using __traits_type = _Traits;
+    using __hash_cached = typename __traits_type::__hash_cached;
+    using __constant_iterators = typename __traits_type::__constant_iterators;
+    using __unique_keys = typename __traits_type::__unique_keys;
+
+    using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+					     _H1, _H2, _Hash,
+					     __hash_cached::value>;
+
+    using __hash_code = typename __hash_code_base::__hash_code;
+    using __node_type = typename __hash_code_base::__node_type;
+
+    using iterator = __detail::_Node_iterator<value_type,
+					      __constant_iterators::value,
+					      __hash_cached::value>;
+
+    using const_iterator = __detail::_Node_const_iterator<value_type,
+						   __constant_iterators::value,
+						   __hash_cached::value>;
+
+    using local_iterator = __detail::_Local_iterator<key_type, value_type,
+						  _ExtractKey, _H1, _H2, _Hash,
+						  __constant_iterators::value,
+						     __hash_cached::value>;
+
+    using const_local_iterator = __detail::_Local_const_iterator<key_type,
+								 value_type,
+					_ExtractKey, _H1, _H2, _Hash,
+					__constant_iterators::value,
+					__hash_cached::value>;
+
+    using __ireturn_type = typename std::conditional<__unique_keys::value,
+						     std::pair<iterator, bool>,
+						     iterator>::type;
+  private:
+    using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>;
+    using _EqualHelper =  _Equal_helper<_Key, _Value, _ExtractKey, _Equal,
+					__hash_code, __hash_cached::value>;
+
+  protected:
+    _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2,
+		    const _Hash& __hash, const _Equal& __eq)
+    : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq)
+    { }
+
+    bool
+    _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const
+    {
+      return _EqualHelper::_S_equals(_M_eq(), this->_M_extract(),
+				     __k, __c, __n);
+    }
+
+    void
+    _M_swap(_Hashtable_base& __x)
+    {
+      __hash_code_base::_M_swap(__x);
+      std::swap(_M_eq(), __x._M_eq());
+    }
+
+    const _Equal&
+    _M_eq() const { return _EqualEBO::_S_cget(*this); }
+
+    _Equal&
+    _M_eq() { return _EqualEBO::_S_get(*this); }
+  };
+
+  /**
+   *  struct _Equality_base.
+   *
+   *  Common types and functions for class _Equality.
+   */
+  struct _Equality_base
+  {
+  protected:
+    template<typename _Uiterator>
+      static bool
+      _S_is_permutation(_Uiterator, _Uiterator, _Uiterator);
+  };
+
+  // See std::is_permutation in N3068.
+  template<typename _Uiterator>
+    bool
+    _Equality_base::
+    _S_is_permutation(_Uiterator __first1, _Uiterator __last1,
+		      _Uiterator __first2)
+    {
+      for (; __first1 != __last1; ++__first1, ++__first2)
+	if (!(*__first1 == *__first2))
+	  break;
+
+      if (__first1 == __last1)
+	return true;
+
+      _Uiterator __last2 = __first2;
+      std::advance(__last2, std::distance(__first1, __last1));
+
+      for (_Uiterator __it1 = __first1; __it1 != __last1; ++__it1)
+	{
+	  _Uiterator __tmp =  __first1;
+	  while (__tmp != __it1 && !bool(*__tmp == *__it1))
+	    ++__tmp;
+
+	  // We've seen this one before.
+	  if (__tmp != __it1)
+	    continue;
+
+	  std::ptrdiff_t __n2 = 0;
+	  for (__tmp = __first2; __tmp != __last2; ++__tmp)
+	    if (*__tmp == *__it1)
+	      ++__n2;
+
+	  if (!__n2)
+	    return false;
+
+	  std::ptrdiff_t __n1 = 0;
+	  for (__tmp = __it1; __tmp != __last1; ++__tmp)
+	    if (*__tmp == *__it1)
+	      ++__n1;
+
+	  if (__n1 != __n2)
+	    return false;
+	}
+      return true;
+    }
+
+  /**
+   *  Primary class template  _Equality.
+   *
+   *  This is for implementing equality comparison for unordered
+   *  containers, per N3068, by John Lakos and Pablo Halpern.
+   *  Algorithmically, we follow closely the reference implementations
+   *  therein.
+   */
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits,
+	   bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Equality;
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		     _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+				     _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	      _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    _M_equal(const __hashtable& __other) const
+    {
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+
+      if (__this->size() != __other.size())
+	return false;
+
+      for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx)
+	{
+	  const auto __ity = __other.find(_ExtractKey()(*__itx));
+	  if (__ity == __other.end() || !bool(*__ity == *__itx))
+	    return false;
+	}
+      return true;
+    }
+
+  /// Specialization.
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+		     _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    : public _Equality_base
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+				     _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+	      _H1, _H2, _Hash, _RehashPolicy, _Traits, false>::
+    _M_equal(const __hashtable& __other) const
+    {
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+
+      if (__this->size() != __other.size())
+	return false;
+
+      for (auto __itx = __this->begin(); __itx != __this->end();)
+	{
+	  const auto __xrange = __this->equal_range(_ExtractKey()(*__itx));
+	  const auto __yrange = __other.equal_range(_ExtractKey()(*__itx));
+
+	  if (std::distance(__xrange.first, __xrange.second)
+	      != std::distance(__yrange.first, __yrange.second))
+	    return false;
+
+	  if (!_S_is_permutation(__xrange.first, __xrange.second,
+				 __yrange.first))
+	    return false;
+
+	  __itx = __xrange.second;
+	}
+      return true;
+    }
+
+  /**
+   * This type deals with all allocation and keeps an allocator instance through
+   * inheritance to benefit from EBO when possible.
+   */
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc>
+    {
+    private:
+      using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>;
+    public:
+      using __node_type = typename _NodeAlloc::value_type;
+      using __node_alloc_type = _NodeAlloc;
+      // Use __gnu_cxx to benefit from _S_always_equal and al.
+      using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;
+
+      using __value_type = typename __node_type::value_type;
+      using __value_alloc_type =
+	typename __alloctr_rebind<__node_alloc_type, __value_type>::__type;
+      using __value_alloc_traits = std::allocator_traits<__value_alloc_type>;
+
+      using __node_base = __detail::_Hash_node_base;
+      using __bucket_type = __node_base*;      
+      using __bucket_alloc_type =
+	typename __alloctr_rebind<__node_alloc_type, __bucket_type>::__type;
+      using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>;
+
+      _Hashtable_alloc(const _Hashtable_alloc&) = default;
+      _Hashtable_alloc(_Hashtable_alloc&&) = default;
+
+      template<typename _Alloc>
+	_Hashtable_alloc(_Alloc&& __a)
+	  : __ebo_node_alloc(std::forward<_Alloc>(__a))
+	{ }
+
+      __node_alloc_type&
+      _M_node_allocator()
+      { return __ebo_node_alloc::_S_get(*this); }
+
+      const __node_alloc_type&
+      _M_node_allocator() const
+      { return __ebo_node_alloc::_S_cget(*this); }
+
+      template<typename... _Args>
+	__node_type*
+	_M_allocate_node(_Args&&... __args);
+
+      void
+      _M_deallocate_node(__node_type* __n);
+
+      // Deallocate the linked list of nodes pointed to by __n
+      void
+      _M_deallocate_nodes(__node_type* __n);
+
+      __bucket_type*
+      _M_allocate_buckets(std::size_t __n);
+
+      void
+      _M_deallocate_buckets(__bucket_type*, std::size_t __n);
+    };
+
+  // Definitions of class template _Hashtable_alloc's out-of-line member
+  // functions.
+  template<typename _NodeAlloc>
+    template<typename... _Args>
+      typename _Hashtable_alloc<_NodeAlloc>::__node_type*
+      _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
+      {
+	auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1);
+	__node_type* __n = std::__addressof(*__nptr);
+	__try
+	  {
+	    __value_alloc_type __a(_M_node_allocator());
+	    ::new ((void*)__n) __node_type;
+	    __value_alloc_traits::construct(__a, __n->_M_valptr(),
+					    std::forward<_Args>(__args)...);
+	    return __n;
+	  }
+	__catch(...)
+	  {
+	    __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1);
+	    __throw_exception_again;
+	  }
+      }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n)
+    {
+      typedef typename __node_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
+      __value_alloc_type __a(_M_node_allocator());
+      __value_alloc_traits::destroy(__a, __n->_M_valptr());
+      __n->~__node_type();
+      __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n)
+    {
+      while (__n)
+	{
+	  __node_type* __tmp = __n;
+	  __n = __n->_M_next();
+	  _M_deallocate_node(__tmp);
+	}
+    }
+
+  template<typename _NodeAlloc>
+    typename _Hashtable_alloc<_NodeAlloc>::__bucket_type*
+    _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __n)
+    {
+      __bucket_alloc_type __alloc(_M_node_allocator());
+
+      auto __ptr = __bucket_alloc_traits::allocate(__alloc, __n);
+      __bucket_type* __p = std::__addressof(*__ptr);
+      __builtin_memset(__p, 0, __n * sizeof(__bucket_type));
+      return __p;
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts,
+							std::size_t __n)
+    {
+      typedef typename __bucket_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
+      __bucket_alloc_type __alloc(_M_node_allocator());
+      __bucket_alloc_traits::deallocate(__alloc, __ptr, __n);
+    }
+
+ //@} hashtable-detail
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace std
+
+#endif // _HASHTABLE_POLICY_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/indirect_array.h b/gcc-4.9/libstdc++-v3/include/bits/indirect_array.h
new file mode 100644
index 0000000..a9afe64
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/indirect_array.h
@@ -0,0 +1,212 @@
+// The template and inlines for the -*- C++ -*- indirect_array class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/indirect_array.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _INDIRECT_ARRAY_H
+#define _INDIRECT_ARRAY_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup numeric_arrays
+   * @{
+   */
+
+  /**
+   *  @brief  Reference to arbitrary subset of an array.
+   *
+   *  An indirect_array is a reference to the actual elements of an array
+   *  specified by an ordered array of indices.  The way to get an
+   *  indirect_array is to call operator[](valarray<size_t>) on a valarray.
+   *  The returned indirect_array then permits carrying operations out on the
+   *  referenced subset of elements in the original valarray.
+   *
+   *  For example, if an indirect_array is obtained using the array (4,2,0) as
+   *  an argument, and then assigned to an array containing (1,2,3), then the
+   *  underlying array will have array[0]==3, array[2]==2, and array[4]==1.
+   *
+   *  @param  Tp  Element type.
+   */
+  template <class _Tp>
+    class indirect_array
+    {
+    public:
+      typedef _Tp value_type;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 253. valarray helper functions are almost entirely useless
+
+      ///  Copy constructor.  Both slices refer to the same underlying array.
+      indirect_array(const indirect_array&);
+
+      ///  Assignment operator.  Assigns elements to corresponding elements
+      ///  of @a a.
+      indirect_array& operator=(const indirect_array&);
+
+      ///  Assign slice elements to corresponding elements of @a v.
+      void operator=(const valarray<_Tp>&) const;
+      ///  Multiply slice elements by corresponding elements of @a v.
+      void operator*=(const valarray<_Tp>&) const;
+      ///  Divide slice elements by corresponding elements of @a v.
+      void operator/=(const valarray<_Tp>&) const;
+      ///  Modulo slice elements by corresponding elements of @a v.
+      void operator%=(const valarray<_Tp>&) const;
+      ///  Add corresponding elements of @a v to slice elements.
+      void operator+=(const valarray<_Tp>&) const;
+      ///  Subtract corresponding elements of @a v from slice elements.
+      void operator-=(const valarray<_Tp>&) const;
+      ///  Logical xor slice elements with corresponding elements of @a v.
+      void operator^=(const valarray<_Tp>&) const;
+      ///  Logical and slice elements with corresponding elements of @a v.
+      void operator&=(const valarray<_Tp>&) const;
+      ///  Logical or slice elements with corresponding elements of @a v.
+      void operator|=(const valarray<_Tp>&) const;
+      ///  Left shift slice elements by corresponding elements of @a v.
+      void operator<<=(const valarray<_Tp>&) const;
+      ///  Right shift slice elements by corresponding elements of @a v.
+      void operator>>=(const valarray<_Tp>&) const;
+      ///  Assign all slice elements to @a t.
+      void operator= (const _Tp&) const;
+      //    ~indirect_array();
+
+      template<class _Dom>
+      void operator=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator*=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator/=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator%=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator+=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator-=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator^=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator&=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator|=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator<<=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+      void operator>>=(const _Expr<_Dom, _Tp>&) const;
+
+    private:
+      ///  Copy constructor.  Both slices refer to the same underlying array.
+      indirect_array(_Array<_Tp>, size_t, _Array<size_t>);
+
+      friend class valarray<_Tp>;
+      friend class gslice_array<_Tp>;
+
+      const size_t	 _M_sz;
+      const _Array<size_t> _M_index;
+      const _Array<_Tp>	 _M_array;
+
+      // not implemented
+      indirect_array();
+    };
+
+  template<typename _Tp>
+    inline
+    indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
+    : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {}
+
+  template<typename _Tp>
+    inline
+    indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
+					_Array<size_t> __i)
+    : _M_sz(__s), _M_index(__i), _M_array(__a) {}
+
+  template<typename _Tp>
+    inline indirect_array<_Tp>&
+    indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
+    {
+      std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array,
+			   _M_index);
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline void
+    indirect_array<_Tp>::operator=(const _Tp& __t) const
+    { std::__valarray_fill(_M_array, _M_index, _M_sz, __t); }
+
+  template<typename _Tp>
+    inline void
+    indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
+    { std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }
+
+  template<typename _Tp>
+    template<class _Dom>
+      inline void
+      indirect_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
+      { std::__valarray_copy(__e, _M_sz, _M_array, _M_index); }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)				\
+  template<typename _Tp>						\
+    inline void								\
+    indirect_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const\
+    {									\
+      _Array_augmented_##_Name(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); \
+    }									\
+									\
+  template<typename _Tp>                                                \
+    template<class _Dom>				                \
+      inline void							\
+      indirect_array<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) const\
+      {									\
+	_Array_augmented_##_Name(_M_array, _M_index, __e, _M_sz);	\
+      }
+
+_DEFINE_VALARRAY_OPERATOR(*, __multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, __divides)
+_DEFINE_VALARRAY_OPERATOR(%, __modulus)
+_DEFINE_VALARRAY_OPERATOR(+, __plus)
+_DEFINE_VALARRAY_OPERATOR(-, __minus)
+_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
+_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
+_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
+_DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR
+
+  // @} group numeric_arrays
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _INDIRECT_ARRAY_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/ios_base.h b/gcc-4.9/libstdc++-v3/include/bits/ios_base.h
new file mode 100644
index 0000000..ae856de
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/ios_base.h
@@ -0,0 +1,975 @@
+// Iostreams base classes -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/ios_base.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ios}
+ */
+
+//
+// ISO C++ 14882: 27.4  Iostreams base classes
+//
+
+#ifndef _IOS_BASE_H
+#define _IOS_BASE_H 1
+
+#pragma GCC system_header
+
+#include <ext/atomicity.h>
+#include <bits/localefwd.h>
+#include <bits/locale_classes.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // The following definitions of bitmask types are enums, not ints,
+  // as permitted (but not required) in the standard, in order to provide
+  // better type safety in iostream calls.  A side effect is that
+  // expressions involving them are no longer compile-time constants.
+  enum _Ios_Fmtflags 
+    { 
+      _S_boolalpha 	= 1L << 0,
+      _S_dec 		= 1L << 1,
+      _S_fixed 		= 1L << 2,
+      _S_hex 		= 1L << 3,
+      _S_internal 	= 1L << 4,
+      _S_left 		= 1L << 5,
+      _S_oct 		= 1L << 6,
+      _S_right 		= 1L << 7,
+      _S_scientific 	= 1L << 8,
+      _S_showbase 	= 1L << 9,
+      _S_showpoint 	= 1L << 10,
+      _S_showpos 	= 1L << 11,
+      _S_skipws 	= 1L << 12,
+      _S_unitbuf 	= 1L << 13,
+      _S_uppercase 	= 1L << 14,
+      _S_adjustfield 	= _S_left | _S_right | _S_internal,
+      _S_basefield 	= _S_dec | _S_oct | _S_hex,
+      _S_floatfield 	= _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16 
+    };
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
+  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
+  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
+  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
+  operator~(_Ios_Fmtflags __a)
+  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
+
+  inline const _Ios_Fmtflags&
+  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Fmtflags&
+  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Fmtflags&
+  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Openmode 
+    { 
+      _S_app 		= 1L << 0,
+      _S_ate 		= 1L << 1,
+      _S_bin 		= 1L << 2,
+      _S_in 		= 1L << 3,
+      _S_out 		= 1L << 4,
+      _S_trunc 		= 1L << 5,
+      _S_ios_openmode_end = 1L << 16 
+    };
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Openmode
+  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Openmode
+  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Openmode
+  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Openmode
+  operator~(_Ios_Openmode __a)
+  { return _Ios_Openmode(~static_cast<int>(__a)); }
+
+  inline const _Ios_Openmode&
+  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Openmode&
+  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Openmode&
+  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Iostate
+    { 
+      _S_goodbit 		= 0,
+      _S_badbit 		= 1L << 0,
+      _S_eofbit 		= 1L << 1,
+      _S_failbit		= 1L << 2,
+      _S_ios_iostate_end = 1L << 16 
+    };
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Iostate
+  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Iostate
+  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Iostate
+  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline _GLIBCXX_CONSTEXPR _Ios_Iostate
+  operator~(_Ios_Iostate __a)
+  { return _Ios_Iostate(~static_cast<int>(__a)); }
+
+  inline const _Ios_Iostate&
+  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Iostate&
+  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a & __b; }
+
+  inline const  _Ios_Iostate&
+  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Seekdir 
+    { 
+      _S_beg = 0,
+      _S_cur = _GLIBCXX_STDIO_SEEK_CUR,
+      _S_end = _GLIBCXX_STDIO_SEEK_END,
+      _S_ios_seekdir_end = 1L << 16 
+    };
+
+  // 27.4.2  Class ios_base
+  /**
+   *  @brief  The base of the I/O class hierarchy.
+   *  @ingroup io
+   *
+   *  This class defines everything that can be defined about I/O that does
+   *  not depend on the type of characters being input or output.  Most
+   *  people will only see @c ios_base when they need to specify the full
+   *  name of the various I/O flags (e.g., the openmodes).
+  */
+  class ios_base
+  {
+  public:
+
+    /** 
+     *  @brief These are thrown to indicate problems with io.
+     *  @ingroup exceptions
+     *
+     *  27.4.2.1.1  Class ios_base::failure
+     */
+    class failure : public exception
+    {
+    public:
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 48.  Use of non-existent exception constructor
+      explicit
+      failure(const string& __str) throw();
+
+      // This declaration is not useless:
+      // http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Vague-Linkage.html
+      virtual
+      ~failure() throw();
+
+      virtual const char*
+      what() const throw();
+
+    private:
+      string _M_msg;
+    };
+
+    // 27.4.2.1.2  Type ios_base::fmtflags
+    /**
+     *  @brief This is a bitmask type.
+     *
+     *  @c @a _Ios_Fmtflags is implementation-defined, but it is valid to
+     *  perform bitwise operations on these values and expect the Right
+     *  Thing to happen.  Defined objects of type fmtflags are:
+     *  - boolalpha
+     *  - dec
+     *  - fixed
+     *  - hex
+     *  - internal
+     *  - left
+     *  - oct
+     *  - right
+     *  - scientific
+     *  - showbase
+     *  - showpoint
+     *  - showpos
+     *  - skipws
+     *  - unitbuf
+     *  - uppercase
+     *  - adjustfield
+     *  - basefield
+     *  - floatfield
+    */
+    typedef _Ios_Fmtflags fmtflags;
+
+    /// Insert/extract @c bool in alphabetic rather than numeric format.
+    static const fmtflags boolalpha =   _S_boolalpha;
+
+    /// Converts integer input or generates integer output in decimal base.
+    static const fmtflags dec =         _S_dec;
+
+    /// Generate floating-point output in fixed-point notation.
+    static const fmtflags fixed =       _S_fixed;
+
+    /// Converts integer input or generates integer output in hexadecimal base.
+    static const fmtflags hex =         _S_hex;
+
+    /// Adds fill characters at a designated internal point in certain
+    /// generated output, or identical to @c right if no such point is
+    /// designated.
+    static const fmtflags internal =    _S_internal;
+
+    /// Adds fill characters on the right (final positions) of certain
+    /// generated output.  (I.e., the thing you print is flush left.)
+    static const fmtflags left =        _S_left;
+
+    /// Converts integer input or generates integer output in octal base.
+    static const fmtflags oct =         _S_oct;
+
+    /// Adds fill characters on the left (initial positions) of certain
+    /// generated output.  (I.e., the thing you print is flush right.)
+    static const fmtflags right =       _S_right;
+
+    /// Generates floating-point output in scientific notation.
+    static const fmtflags scientific =  _S_scientific;
+
+    /// Generates a prefix indicating the numeric base of generated integer
+    /// output.
+    static const fmtflags showbase =    _S_showbase;
+
+    /// Generates a decimal-point character unconditionally in generated
+    /// floating-point output.
+    static const fmtflags showpoint =   _S_showpoint;
+
+    /// Generates a + sign in non-negative generated numeric output.
+    static const fmtflags showpos =     _S_showpos;
+
+    /// Skips leading white space before certain input operations.
+    static const fmtflags skipws =      _S_skipws;
+
+    /// Flushes output after each output operation.
+    static const fmtflags unitbuf =     _S_unitbuf;
+
+    /// Replaces certain lowercase letters with their uppercase equivalents
+    /// in generated output.
+    static const fmtflags uppercase =   _S_uppercase;
+
+    /// A mask of left|right|internal.  Useful for the 2-arg form of @c setf.
+    static const fmtflags adjustfield = _S_adjustfield;
+
+    /// A mask of dec|oct|hex.  Useful for the 2-arg form of @c setf.
+    static const fmtflags basefield =   _S_basefield;
+
+    /// A mask of scientific|fixed.  Useful for the 2-arg form of @c setf.
+    static const fmtflags floatfield =  _S_floatfield;
+
+    // 27.4.2.1.3  Type ios_base::iostate
+    /**
+     *  @brief This is a bitmask type.
+     *
+     *  @c @a _Ios_Iostate is implementation-defined, but it is valid to
+     *  perform bitwise operations on these values and expect the Right
+     *  Thing to happen.  Defined objects of type iostate are:
+     *  - badbit
+     *  - eofbit
+     *  - failbit
+     *  - goodbit
+    */
+    typedef _Ios_Iostate iostate;
+
+    /// Indicates a loss of integrity in an input or output sequence (such
+    /// as an irrecoverable read error from a file).
+    static const iostate badbit =	_S_badbit;
+
+    /// Indicates that an input operation reached the end of an input sequence.
+    static const iostate eofbit =	_S_eofbit;
+
+    /// Indicates that an input operation failed to read the expected
+    /// characters, or that an output operation failed to generate the
+    /// desired characters.
+    static const iostate failbit =	_S_failbit;
+
+    /// Indicates all is well.
+    static const iostate goodbit =	_S_goodbit;
+
+    // 27.4.2.1.4  Type ios_base::openmode
+    /**
+     *  @brief This is a bitmask type.
+     *
+     *  @c @a _Ios_Openmode is implementation-defined, but it is valid to
+     *  perform bitwise operations on these values and expect the Right
+     *  Thing to happen.  Defined objects of type openmode are:
+     *  - app
+     *  - ate
+     *  - binary
+     *  - in
+     *  - out
+     *  - trunc
+    */
+    typedef _Ios_Openmode openmode;
+
+    /// Seek to end before each write.
+    static const openmode app =		_S_app;
+
+    /// Open and seek to end immediately after opening.
+    static const openmode ate =		_S_ate;
+
+    /// Perform input and output in binary mode (as opposed to text mode).
+    /// This is probably not what you think it is; see
+    /// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch27s02.html
+    static const openmode binary =	_S_bin;
+
+    /// Open for input.  Default for @c ifstream and fstream.
+    static const openmode in =		_S_in;
+
+    /// Open for output.  Default for @c ofstream and fstream.
+    static const openmode out =		_S_out;
+
+    /// Open for input.  Default for @c ofstream.
+    static const openmode trunc =	_S_trunc;
+
+    // 27.4.2.1.5  Type ios_base::seekdir
+    /**
+     *  @brief This is an enumerated type.
+     *
+     *  @c @a _Ios_Seekdir is implementation-defined.  Defined values
+     *  of type seekdir are:
+     *  - beg
+     *  - cur, equivalent to @c SEEK_CUR in the C standard library.
+     *  - end, equivalent to @c SEEK_END in the C standard library.
+    */
+    typedef _Ios_Seekdir seekdir;
+
+    /// Request a seek relative to the beginning of the stream.
+    static const seekdir beg =		_S_beg;
+
+    /// Request a seek relative to the current position within the sequence.
+    static const seekdir cur =		_S_cur;
+
+    /// Request a seek relative to the current end of the sequence.
+    static const seekdir end =		_S_end;
+
+    // Annex D.6
+    typedef int io_state;
+    typedef int open_mode;
+    typedef int seek_dir;
+
+    typedef std::streampos streampos;
+    typedef std::streamoff streamoff;
+
+    // Callbacks;
+    /**
+     *  @brief  The set of events that may be passed to an event callback.
+     *
+     *  erase_event is used during ~ios() and copyfmt().  imbue_event is used
+     *  during imbue().  copyfmt_event is used during copyfmt().
+    */
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+
+    /**
+     *  @brief  The type of an event callback function.
+     *  @param  __e  One of the members of the event enum.
+     *  @param  __b  Reference to the ios_base object.
+     *  @param  __i  The integer provided when the callback was registered.
+     *
+     *  Event callbacks are user defined functions that get called during
+     *  several ios_base and basic_ios functions, specifically imbue(),
+     *  copyfmt(), and ~ios().
+    */
+    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
+
+    /**
+     *  @brief  Add the callback __fn with parameter __index.
+     *  @param  __fn  The function to add.
+     *  @param  __index  The integer to pass to the function when invoked.
+     *
+     *  Registers a function as an event callback with an integer parameter to
+     *  be passed to the function when invoked.  Multiple copies of the
+     *  function are allowed.  If there are multiple callbacks, they are
+     *  invoked in the order they were registered.
+    */
+    void
+    register_callback(event_callback __fn, int __index);
+
+  protected:
+    streamsize		_M_precision;
+    streamsize		_M_width;
+    fmtflags		_M_flags;
+    iostate		_M_exception;
+    iostate		_M_streambuf_state;
+
+    // 27.4.2.6  Members for callbacks
+    // 27.4.2.6  ios_base callbacks
+    struct _Callback_list
+    {
+      // Data Members
+      _Callback_list*		_M_next;
+      ios_base::event_callback	_M_fn;
+      int			_M_index;
+      _Atomic_word		_M_refcount;  // 0 means one reference.
+
+      _Callback_list(ios_base::event_callback __fn, int __index,
+		     _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+      // 0 => OK to delete.
+      int
+      _M_remove_reference() 
+      {
+        // Be race-detector-friendly.  For more info see bits/c++config.
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
+        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
+        if (__res == 0)
+          {
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
+          }
+        return __res;
+      }
+    };
+
+     _Callback_list*	_M_callbacks;
+
+    void
+    _M_call_callbacks(event __ev) throw();
+
+    void
+    _M_dispose_callbacks(void) throw();
+
+    // 27.4.2.5  Members for iword/pword storage
+    struct _Words
+    {
+      void*	_M_pword;
+      long	_M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+
+    // Only for failed iword/pword calls.
+    _Words		_M_word_zero;
+
+    // Guaranteed storage.
+    // The first 5 iword and pword slots are reserved for internal use.
+    enum { _S_local_word_size = 8 };
+    _Words		_M_local_word[_S_local_word_size];
+
+    // Allocated storage.
+    int			_M_word_size;
+    _Words*		_M_word;
+
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+
+    // Members for locale and locale caching.
+    locale		_M_ios_locale;
+
+    void
+    _M_init() throw();
+
+  public:
+
+    // 27.4.2.1.6  Class ios_base::Init
+    // Used to initialize standard streams. In theory, g++ could use
+    // -finit-priority to order this stuff correctly without going
+    // through these machinations.
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+
+    private:
+      static _Atomic_word	_S_refcount;
+      static bool		_S_synced_with_stdio;
+    };
+
+    // [27.4.2.2] fmtflags state functions
+    /**
+     *  @brief  Access to format flags.
+     *  @return  The format control flags for both input and output.
+    */
+    fmtflags
+    flags() const
+    { return _M_flags; }
+
+    /**
+     *  @brief  Setting new format flags all at once.
+     *  @param  __fmtfl  The new flags to set.
+     *  @return  The previous format control flags.
+     *
+     *  This function overwrites all the format flags with @a __fmtfl.
+    */
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+
+    /**
+     *  @brief  Setting new format flags.
+     *  @param  __fmtfl  Additional flags to set.
+     *  @return  The previous format control flags.
+     *
+     *  This function sets additional flags in format control.  Flags that
+     *  were previously set remain set.
+    */
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+
+    /**
+     *  @brief  Setting new format flags.
+     *  @param  __fmtfl  Additional flags to set.
+     *  @param  __mask  The flags mask for @a fmtfl.
+     *  @return  The previous format control flags.
+     *
+     *  This function clears @a mask in the format flags, then sets
+     *  @a fmtfl @c & @a mask.  An example mask is @c ios_base::adjustfield.
+    */
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+
+    /**
+     *  @brief  Clearing format flags.
+     *  @param  __mask  The flags to unset.
+     *
+     *  This function clears @a __mask in the format flags.
+    */
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+
+    /**
+     *  @brief  Flags access.
+     *  @return  The precision to generate on certain output operations.
+     *
+     *  Be careful if you try to give a definition of @a precision here; see
+     *  DR 189.
+    */
+    streamsize
+    precision() const
+    { return _M_precision; }
+
+    /**
+     *  @brief  Changing flags.
+     *  @param  __prec  The new precision value.
+     *  @return  The previous value of precision().
+    */
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+
+    /**
+     *  @brief  Flags access.
+     *  @return  The minimum field width to generate on output operations.
+     *
+     *  <em>Minimum field width</em> refers to the number of characters.
+    */
+    streamsize
+    width() const
+    { return _M_width; }
+
+    /**
+     *  @brief  Changing flags.
+     *  @param  __wide  The new width value.
+     *  @return  The previous value of width().
+    */
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+
+    // [27.4.2.4] ios_base static members
+    /**
+     *  @brief  Interaction with the standard C I/O objects.
+     *  @param  __sync  Whether to synchronize or not.
+     *  @return  True if the standard streams were previously synchronized.
+     *
+     *  The synchronization referred to is @e only that between the standard
+     *  C facilities (e.g., stdout) and the standard C++ objects (e.g.,
+     *  cout).  User-declared streams are unaffected.  See
+     *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch28s02.html
+    */
+    static bool
+    sync_with_stdio(bool __sync = true);
+
+    // [27.4.2.3] ios_base locale functions
+    /**
+     *  @brief  Setting a new locale.
+     *  @param  __loc  The new locale.
+     *  @return  The previous locale.
+     *
+     *  Sets the new locale for this stream, and then invokes each callback
+     *  with imbue_event.
+    */
+    locale
+    imbue(const locale& __loc) throw();
+
+    /**
+     *  @brief  Locale access
+     *  @return  A copy of the current locale.
+     *
+     *  If @c imbue(loc) has previously been called, then this function
+     *  returns @c loc.  Otherwise, it returns a copy of @c std::locale(),
+     *  the global C++ locale.
+    */
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+
+    /**
+     *  @brief  Locale access
+     *  @return  A reference to the current locale.
+     *
+     *  Like getloc above, but returns a reference instead of
+     *  generating a copy.
+    */
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+
+    // [27.4.2.5] ios_base storage functions
+    /**
+     *  @brief  Access to unique indices.
+     *  @return  An integer different from all previous calls.
+     *
+     *  This function returns a unique integer every time it is called.  It
+     *  can be used for any purpose, but is primarily intended to be a unique
+     *  index for the iword and pword functions.  The expectation is that an
+     *  application calls xalloc in order to obtain an index in the iword and
+     *  pword arrays that can be used without fear of conflict.
+     *
+     *  The implementation maintains a static variable that is incremented and
+     *  returned on each invocation.  xalloc is guaranteed to return an index
+     *  that is safe to use in the iword and pword arrays.
+    */
+    static int
+    xalloc() throw();
+
+    /**
+     *  @brief  Access to integer array.
+     *  @param  __ix  Index into the array.
+     *  @return  A reference to an integer associated with the index.
+     *
+     *  The iword function provides access to an array of integers that can be
+     *  used for any purpose.  The array grows as required to hold the
+     *  supplied index.  All integers in the array are initialized to 0.
+     *
+     *  The implementation reserves several indices.  You should use xalloc to
+     *  obtain an index that is safe to use.  Also note that since the array
+     *  can grow dynamically, it is not safe to hold onto the reference.
+    */
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+			? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+
+    /**
+     *  @brief  Access to void pointer array.
+     *  @param  __ix  Index into the array.
+     *  @return  A reference to a void* associated with the index.
+     *
+     *  The pword function provides access to an array of pointers that can be
+     *  used for any purpose.  The array grows as required to hold the
+     *  supplied index.  All pointers in the array are initialized to 0.
+     *
+     *  The implementation reserves several indices.  You should use xalloc to
+     *  obtain an index that is safe to use.  Also note that since the array
+     *  can grow dynamically, it is not safe to hold onto the reference.
+    */
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+			? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+
+    // Destructor
+    /**
+     *  Invokes each callback with erase_event.  Destroys local storage.
+     *
+     *  Note that the ios_base object for the standard streams never gets
+     *  destroyed.  As a result, any callbacks registered with the standard
+     *  streams will not get invoked with erase_event (unless copyfmt is
+     *  used).
+    */
+    virtual ~ios_base();
+
+  protected:
+    ios_base() throw ();
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 50.  Copy constructor and assignment operator of ios_base
+  private:
+    ios_base(const ios_base&);
+
+    ios_base&
+    operator=(const ios_base&);
+  };
+
+  // [27.4.5.1] fmtflags manipulators
+  /// Calls base.setf(ios_base::boolalpha).
+  inline ios_base&
+  boolalpha(ios_base& __base)
+  {
+    __base.setf(ios_base::boolalpha);
+    return __base;
+  }
+
+  /// Calls base.unsetf(ios_base::boolalpha).
+  inline ios_base&
+  noboolalpha(ios_base& __base)
+  {
+    __base.unsetf(ios_base::boolalpha);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::showbase).
+  inline ios_base&
+  showbase(ios_base& __base)
+  {
+    __base.setf(ios_base::showbase);
+    return __base;
+  }
+
+  /// Calls base.unsetf(ios_base::showbase).
+  inline ios_base&
+  noshowbase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showbase);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::showpoint).
+  inline ios_base&
+  showpoint(ios_base& __base)
+  {
+    __base.setf(ios_base::showpoint);
+    return __base;
+  }
+
+  /// Calls base.unsetf(ios_base::showpoint).
+  inline ios_base&
+  noshowpoint(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpoint);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::showpos).
+  inline ios_base&
+  showpos(ios_base& __base)
+  {
+    __base.setf(ios_base::showpos);
+    return __base;
+  }
+
+  /// Calls base.unsetf(ios_base::showpos).
+  inline ios_base&
+  noshowpos(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpos);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::skipws).
+  inline ios_base&
+  skipws(ios_base& __base)
+  {
+    __base.setf(ios_base::skipws);
+    return __base;
+  }
+
+  /// Calls base.unsetf(ios_base::skipws).
+  inline ios_base&
+  noskipws(ios_base& __base)
+  {
+    __base.unsetf(ios_base::skipws);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::uppercase).
+  inline ios_base&
+  uppercase(ios_base& __base)
+  {
+    __base.setf(ios_base::uppercase);
+    return __base;
+  }
+
+  /// Calls base.unsetf(ios_base::uppercase).
+  inline ios_base&
+  nouppercase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::uppercase);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::unitbuf).
+  inline ios_base&
+  unitbuf(ios_base& __base)
+  {
+     __base.setf(ios_base::unitbuf);
+     return __base;
+  }
+
+  /// Calls base.unsetf(ios_base::unitbuf).
+  inline ios_base&
+  nounitbuf(ios_base& __base)
+  {
+     __base.unsetf(ios_base::unitbuf);
+     return __base;
+  }
+
+  // [27.4.5.2] adjustfield manipulators
+  /// Calls base.setf(ios_base::internal, ios_base::adjustfield).
+  inline ios_base&
+  internal(ios_base& __base)
+  {
+     __base.setf(ios_base::internal, ios_base::adjustfield);
+     return __base;
+  }
+
+  /// Calls base.setf(ios_base::left, ios_base::adjustfield).
+  inline ios_base&
+  left(ios_base& __base)
+  {
+    __base.setf(ios_base::left, ios_base::adjustfield);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::right, ios_base::adjustfield).
+  inline ios_base&
+  right(ios_base& __base)
+  {
+    __base.setf(ios_base::right, ios_base::adjustfield);
+    return __base;
+  }
+
+  // [27.4.5.3] basefield manipulators
+  /// Calls base.setf(ios_base::dec, ios_base::basefield).
+  inline ios_base&
+  dec(ios_base& __base)
+  {
+    __base.setf(ios_base::dec, ios_base::basefield);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::hex, ios_base::basefield).
+  inline ios_base&
+  hex(ios_base& __base)
+  {
+    __base.setf(ios_base::hex, ios_base::basefield);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::oct, ios_base::basefield).
+  inline ios_base&
+  oct(ios_base& __base)
+  {
+    __base.setf(ios_base::oct, ios_base::basefield);
+    return __base;
+  }
+
+  // [27.4.5.4] floatfield manipulators
+  /// Calls base.setf(ios_base::fixed, ios_base::floatfield).
+  inline ios_base&
+  fixed(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed, ios_base::floatfield);
+    return __base;
+  }
+
+  /// Calls base.setf(ios_base::scientific, ios_base::floatfield).
+  inline ios_base&
+  scientific(ios_base& __base)
+  {
+    __base.setf(ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _IOS_BASE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/istream.tcc b/gcc-4.9/libstdc++-v3/include/bits/istream.tcc
new file mode 100644
index 0000000..f50d7b3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/istream.tcc
@@ -0,0 +1,1092 @@
+// istream classes -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/istream.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{istream}
+ */
+
+//
+// ISO C++ 14882: 27.6.1  Input streams
+//
+
+#ifndef _ISTREAM_TCC
+#define _ISTREAM_TCC 1
+
+#pragma GCC system_header
+
+#include <bits/cxxabi_forced.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>::sentry::
+    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      if (__in.good())
+	{
+	  if (__in.tie())
+	    __in.tie()->flush();
+	  if (!__noskip && bool(__in.flags() & ios_base::skipws))
+	    {
+	      const __int_type __eof = traits_type::eof();
+	      __streambuf_type* __sb = __in.rdbuf();
+	      __int_type __c = __sb->sgetc();
+
+	      const __ctype_type& __ct = __check_facet(__in._M_ctype);
+	      while (!traits_type::eq_int_type(__c, __eof)
+		     && __ct.is(ctype_base::space, 
+				traits_type::to_char_type(__c)))
+		__c = __sb->snextc();
+
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 195. Should basic_istream::sentry's constructor ever
+	      // set eofbit?
+	      if (traits_type::eq_int_type(__c, __eof))
+		__err |= ios_base::eofbit;
+	    }
+	}
+
+      if (__in.good() && __err == ios_base::goodbit)
+	_M_ok = true;
+      else
+	{
+	  __err |= ios_base::failbit;
+	  __in.setstate(__err);
+	}
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_istream<_CharT, _Traits>&
+      basic_istream<_CharT, _Traits>::
+      _M_extract(_ValueT& __v)
+      {
+	sentry __cerb(*this, false);
+	if (__cerb)
+	  {
+	    ios_base::iostate __err = ios_base::goodbit;
+	    __try
+	      {
+		const __num_get_type& __ng = __check_facet(this->_M_num_get);
+		__ng.get(*this, 0, *this, __err, __v);
+	      }
+	    __catch(__cxxabiv1::__forced_unwind&)
+	      {
+		this->_M_setstate(ios_base::badbit);
+		__throw_exception_again;
+	      }
+	    __catch(...)
+	      { this->_M_setstate(ios_base::badbit); }
+	    if (__err)
+	      this->setstate(__err);
+	  }
+	return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(short& __n)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 118. basic_istream uses nonexistent num_get member functions.
+      sentry __cerb(*this, false);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      long __l;
+	      const __num_get_type& __ng = __check_facet(this->_M_num_get);
+	      __ng.get(*this, 0, *this, __err, __l);
+
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 696. istream::operator>>(int&) broken.
+	      if (__l < __gnu_cxx::__numeric_traits<short>::__min)
+		{
+		  __err |= ios_base::failbit;
+		  __n = __gnu_cxx::__numeric_traits<short>::__min;
+		}
+	      else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
+		{
+		  __err |= ios_base::failbit;
+		  __n = __gnu_cxx::__numeric_traits<short>::__max;
+		}
+	      else
+		__n = short(__l);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(int& __n)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 118. basic_istream uses nonexistent num_get member functions.
+      sentry __cerb(*this, false);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      long __l;
+	      const __num_get_type& __ng = __check_facet(this->_M_num_get);
+	      __ng.get(*this, 0, *this, __err, __l);
+
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 696. istream::operator>>(int&) broken.
+	      if (__l < __gnu_cxx::__numeric_traits<int>::__min)
+		{
+		  __err |= ios_base::failbit;
+		  __n = __gnu_cxx::__numeric_traits<int>::__min;
+		}
+	      else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
+		{
+		  __err |= ios_base::failbit;	      
+		  __n = __gnu_cxx::__numeric_traits<int>::__max;
+		}
+	      else
+		__n = int(__l);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(__streambuf_type* __sbout)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, false);
+      if (__cerb && __sbout)
+	{
+	  __try
+	    {
+	      bool __ineof;
+	      if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
+		__err |= ios_base::failbit;
+	      if (__ineof)
+		__err |= ios_base::eofbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::failbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::failbit); }
+	}
+      else if (!__sbout)
+	__err |= ios_base::failbit;
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    get(void)
+    {
+      const int_type __eof = traits_type::eof();
+      int_type __c = __eof;
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      __c = this->rdbuf()->sbumpc();
+	      // 27.6.1.1 paragraph 3
+	      if (!traits_type::eq_int_type(__c, __eof))
+		_M_gcount = 1;
+	      else
+		__err |= ios_base::eofbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	}
+      if (!_M_gcount)
+	__err |= ios_base::failbit;
+      if (__err)
+	this->setstate(__err);
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type& __c)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      const int_type __cb = this->rdbuf()->sbumpc();
+	      // 27.6.1.1 paragraph 3
+	      if (!traits_type::eq_int_type(__cb, traits_type::eof()))
+		{
+		  _M_gcount = 1;
+		  __c = traits_type::to_char_type(__cb);
+		}
+	      else
+		__err |= ios_base::eofbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	}
+      if (!_M_gcount)
+	__err |= ios_base::failbit;
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      const int_type __idelim = traits_type::to_int_type(__delim);
+	      const int_type __eof = traits_type::eof();
+	      __streambuf_type* __sb = this->rdbuf();
+	      int_type __c = __sb->sgetc();
+
+	      while (_M_gcount + 1 < __n
+		     && !traits_type::eq_int_type(__c, __eof)
+		     && !traits_type::eq_int_type(__c, __idelim))
+		{
+		  *__s++ = traits_type::to_char_type(__c);
+		  ++_M_gcount;
+		  __c = __sb->snextc();
+		}
+	      if (traits_type::eq_int_type(__c, __eof))
+		__err |= ios_base::eofbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	}
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 243. get and getline when sentry reports failure.
+      if (__n > 0)
+	*__s = char_type();
+      if (!_M_gcount)
+	__err |= ios_base::failbit;
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(__streambuf_type& __sb, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      const int_type __idelim = traits_type::to_int_type(__delim);
+	      const int_type __eof = traits_type::eof();
+	      __streambuf_type* __this_sb = this->rdbuf();
+	      int_type __c = __this_sb->sgetc();
+	      char_type __c2 = traits_type::to_char_type(__c);
+
+	      while (!traits_type::eq_int_type(__c, __eof)
+		     && !traits_type::eq_int_type(__c, __idelim)
+		     && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
+		{
+		  ++_M_gcount;
+		  __c = __this_sb->snextc();
+		  __c2 = traits_type::to_char_type(__c);
+		}
+	      if (traits_type::eq_int_type(__c, __eof))
+		__err |= ios_base::eofbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	}
+      if (!_M_gcount)
+	__err |= ios_base::failbit;
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    getline(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+        {
+          __try
+            {
+              const int_type __idelim = traits_type::to_int_type(__delim);
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+              while (_M_gcount + 1 < __n
+                     && !traits_type::eq_int_type(__c, __eof)
+                     && !traits_type::eq_int_type(__c, __idelim))
+                {
+                  *__s++ = traits_type::to_char_type(__c);
+                  __c = __sb->snextc();
+                  ++_M_gcount;
+                }
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+              else
+                {
+                  if (traits_type::eq_int_type(__c, __idelim))
+                    {
+                      __sb->sbumpc();
+                      ++_M_gcount;
+                    }
+                  else
+                    __err |= ios_base::failbit;
+                }
+            }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+          __catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+        }
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 243. get and getline when sentry reports failure.
+      if (__n > 0)
+	*__s = char_type();
+      if (!_M_gcount)
+        __err |= ios_base::failbit;
+      if (__err)
+        this->setstate(__err);
+      return *this;
+    }
+
+  // We provide three overloads, since the first two are much simpler
+  // than the general case. Also, the latter two can thus adopt the
+  // same "batchy" strategy used by getline above.
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(void)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      const int_type __eof = traits_type::eof();
+	      __streambuf_type* __sb = this->rdbuf();
+
+	      if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
+		__err |= ios_base::eofbit;
+	      else
+		_M_gcount = 1;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          __try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+	      // N.B. On LFS-enabled platforms streamsize is still 32 bits
+	      // wide: if we want to implement the standard mandated behavior
+	      // for n == max() (see 27.6.1.3/24) we are at risk of signed
+	      // integer overflow: thus these contortions. Also note that,
+	      // by definition, when more than 2G chars are actually ignored,
+	      // _M_gcount (the return value of gcount, that is) cannot be
+	      // really correct, being unavoidably too small.
+	      bool __large_ignore = false;
+	      while (true)
+		{
+		  while (_M_gcount < __n
+			 && !traits_type::eq_int_type(__c, __eof))
+		    {
+		      ++_M_gcount;
+		      __c = __sb->snextc();
+		    }
+		  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+		      && !traits_type::eq_int_type(__c, __eof))
+		    {
+		      _M_gcount =
+			__gnu_cxx::__numeric_traits<streamsize>::__min;
+		      __large_ignore = true;
+		    }
+		  else
+		    break;
+		}
+
+	      if (__large_ignore)
+		_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+	      if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+            }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+          __catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n, int_type __delim)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          __try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+	      // See comment above.
+	      bool __large_ignore = false;
+	      while (true)
+		{
+		  while (_M_gcount < __n
+			 && !traits_type::eq_int_type(__c, __eof)
+			 && !traits_type::eq_int_type(__c, __delim))
+		    {
+		      ++_M_gcount;
+		      __c = __sb->snextc();
+		    }
+		  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+		      && !traits_type::eq_int_type(__c, __eof)
+		      && !traits_type::eq_int_type(__c, __delim))
+		    {
+		      _M_gcount =
+			__gnu_cxx::__numeric_traits<streamsize>::__min;
+		      __large_ignore = true;
+		    }
+		  else
+		    break;
+		}
+
+	      if (__large_ignore)
+		_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+	      else if (traits_type::eq_int_type(__c, __delim))
+		{
+		  if (_M_gcount
+		      < __gnu_cxx::__numeric_traits<streamsize>::__max)
+		    ++_M_gcount;
+		  __sb->sbumpc();
+		}
+            }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+          __catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    peek(void)
+    {
+      int_type __c = traits_type::eof();
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      __c = this->rdbuf()->sgetc();
+	      if (traits_type::eq_int_type(__c, traits_type::eof()))
+		__err |= ios_base::eofbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    read(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      _M_gcount = this->rdbuf()->sgetn(__s, __n);
+	      if (_M_gcount != __n)
+		__err |= (ios_base::eofbit | ios_base::failbit);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_istream<_CharT, _Traits>::
+    readsome(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      // Cannot compare int_type with streamsize generically.
+	      const streamsize __num = this->rdbuf()->in_avail();
+	      if (__num > 0)
+		_M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
+	      else if (__num == -1)
+		__err |= ios_base::eofbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return _M_gcount;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    putback(char_type __c)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 60. What is a formatted input function?
+      _M_gcount = 0;
+      // Clear eofbit per N3168.
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      const int_type __eof = traits_type::eof();
+	      __streambuf_type* __sb = this->rdbuf();
+	      if (!__sb
+		  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
+		__err |= ios_base::badbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    unget(void)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 60. What is a formatted input function?
+      _M_gcount = 0;
+      // Clear eofbit per N3168.
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      const int_type __eof = traits_type::eof();
+	      __streambuf_type* __sb = this->rdbuf();
+	      if (!__sb
+		  || traits_type::eq_int_type(__sb->sungetc(), __eof))
+		__err |= ios_base::badbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_istream<_CharT, _Traits>::
+    sync(void)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR60.  Do not change _M_gcount.
+      int __ret = -1;
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      __streambuf_type* __sb = this->rdbuf();
+	      if (__sb)
+		{
+		  if (__sb->pubsync() == -1)
+		    __err |= ios_base::badbit;
+		  else
+		    __ret = 0;
+		}
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::pos_type
+    basic_istream<_CharT, _Traits>::
+    tellg(void)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR60.  Do not change _M_gcount.
+      pos_type __ret = pos_type(-1);
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      if (!this->fail())
+		__ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
+						  ios_base::in);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(pos_type __pos)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR60.  Do not change _M_gcount.
+      // Clear eofbit per N3168.
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      if (!this->fail())
+		{
+		  // 136.  seekp, seekg setting wrong streams?
+		  const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+								 ios_base::in);
+		  
+		  // 129.  Need error indication from seekp() and seekg()
+		  if (__p == pos_type(off_type(-1)))
+		    __err |= ios_base::failbit;
+		}
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(off_type __off, ios_base::seekdir __dir)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR60.  Do not change _M_gcount.
+      // Clear eofbit per N3168.
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      if (!this->fail())
+		{
+		  // 136.  seekp, seekg setting wrong streams?
+		  const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+								 ios_base::in);
+	      
+		  // 129.  Need error indication from seekp() and seekg()
+		  if (__p == pos_type(off_type(-1)))
+		    __err |= ios_base::failbit;
+		}
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  // 27.6.1.2.3 Character extraction templates
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    {
+      typedef basic_istream<_CharT, _Traits>		__istream_type;
+      typedef typename __istream_type::int_type         __int_type;
+
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      const __int_type __cb = __in.rdbuf()->sbumpc();
+	      if (!_Traits::eq_int_type(__cb, _Traits::eof()))
+		__c = _Traits::to_char_type(__cb);
+	      else
+		__err |= (ios_base::eofbit | ios_base::failbit);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __in._M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __in._M_setstate(ios_base::badbit); }
+	  if (__err)
+	    __in.setstate(__err);
+	}
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    {
+      typedef basic_istream<_CharT, _Traits>		__istream_type;
+      typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
+      typedef typename _Traits::int_type		int_type;
+      typedef _CharT					char_type;
+      typedef ctype<_CharT>				__ctype_type;
+
+      streamsize __extracted = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      // Figure out how many characters to extract.
+	      streamsize __num = __in.width();
+	      if (__num <= 0)
+		__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+
+	      const int_type __eof = _Traits::eof();
+	      __streambuf_type* __sb = __in.rdbuf();
+	      int_type __c = __sb->sgetc();
+
+	      while (__extracted < __num - 1
+		     && !_Traits::eq_int_type(__c, __eof)
+		     && !__ct.is(ctype_base::space,
+				 _Traits::to_char_type(__c)))
+		{
+		  *__s++ = _Traits::to_char_type(__c);
+		  ++__extracted;
+		  __c = __sb->snextc();
+		}
+	      if (_Traits::eq_int_type(__c, __eof))
+		__err |= ios_base::eofbit;
+
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 68.  Extractors for char* should store null at end
+	      *__s = char_type();
+	      __in.width(0);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __in._M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __in._M_setstate(ios_base::badbit); }
+	}
+      if (!__extracted)
+	__err |= ios_base::failbit;
+      if (__err)
+	__in.setstate(__err);
+      return __in;
+    }
+
+  // 27.6.1.4 Standard basic_istream manipulators
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __in)
+    {
+      typedef basic_istream<_CharT, _Traits>		__istream_type;
+      typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
+      typedef typename __istream_type::int_type		__int_type;
+      typedef ctype<_CharT>				__ctype_type;
+
+      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __int_type __eof = _Traits::eof();
+      __streambuf_type* __sb = __in.rdbuf();
+      __int_type __c = __sb->sgetc();
+
+      while (!_Traits::eq_int_type(__c, __eof)
+	     && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
+	__c = __sb->snextc();
+
+       if (_Traits::eq_int_type(__c, __eof))
+	 __in.setstate(ios_base::eofbit);
+      return __in;
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class basic_istream<char>;
+  extern template istream& ws(istream&);
+  extern template istream& operator>>(istream&, char&);
+  extern template istream& operator>>(istream&, char*);
+  extern template istream& operator>>(istream&, unsigned char&);
+  extern template istream& operator>>(istream&, signed char&);
+  extern template istream& operator>>(istream&, unsigned char*);
+  extern template istream& operator>>(istream&, signed char*);
+
+  extern template istream& istream::_M_extract(unsigned short&);
+  extern template istream& istream::_M_extract(unsigned int&);  
+  extern template istream& istream::_M_extract(long&);
+  extern template istream& istream::_M_extract(unsigned long&);
+  extern template istream& istream::_M_extract(bool&);
+#ifdef _GLIBCXX_USE_LONG_LONG
+  extern template istream& istream::_M_extract(long long&);
+  extern template istream& istream::_M_extract(unsigned long long&);
+#endif
+  extern template istream& istream::_M_extract(float&);
+  extern template istream& istream::_M_extract(double&);
+  extern template istream& istream::_M_extract(long double&);
+  extern template istream& istream::_M_extract(void*&);
+
+  extern template class basic_iostream<char>;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_istream<wchar_t>;
+  extern template wistream& ws(wistream&);
+  extern template wistream& operator>>(wistream&, wchar_t&);
+  extern template wistream& operator>>(wistream&, wchar_t*);
+
+  extern template wistream& wistream::_M_extract(unsigned short&);
+  extern template wistream& wistream::_M_extract(unsigned int&);  
+  extern template wistream& wistream::_M_extract(long&);
+  extern template wistream& wistream::_M_extract(unsigned long&);
+  extern template wistream& wistream::_M_extract(bool&);
+#ifdef _GLIBCXX_USE_LONG_LONG
+  extern template wistream& wistream::_M_extract(long long&);
+  extern template wistream& wistream::_M_extract(unsigned long long&);
+#endif
+  extern template wistream& wistream::_M_extract(float&);
+  extern template wistream& wistream::_M_extract(double&);
+  extern template wistream& wistream::_M_extract(long double&);
+  extern template wistream& wistream::_M_extract(void*&);
+
+  extern template class basic_iostream<wchar_t>;
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/list.tcc b/gcc-4.9/libstdc++-v3/include/bits/list.tcc
new file mode 100644
index 0000000..42855a4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/list.tcc
@@ -0,0 +1,511 @@
+// List implementation (out of line) -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/list.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{list}
+ */
+
+#ifndef _LIST_TCC
+#define _LIST_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _List_base<_Tp, _Alloc>::
+    _M_clear() _GLIBCXX_NOEXCEPT
+    {
+      typedef _List_node<_Tp>  _Node;
+      _Node* __cur = static_cast<_Node*>(_M_impl._M_node._M_next);
+      while (__cur != &_M_impl._M_node)
+	{
+	  _Node* __tmp = __cur;
+	  __cur = static_cast<_Node*>(__cur->_M_next);
+#if __cplusplus >= 201103L
+	  _M_get_Node_allocator().destroy(__tmp);
+#else
+	  _M_get_Tp_allocator().destroy(std::__addressof(__tmp->_M_data));
+#endif
+	  _M_put_node(__tmp);
+	}
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename list<_Tp, _Alloc>::iterator
+      list<_Tp, _Alloc>::
+      emplace(const_iterator __position, _Args&&... __args)
+      {
+	_Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
+	__tmp->_M_hook(__position._M_const_cast()._M_node);
+	return iterator(__tmp);
+      }
+#endif
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+#if __cplusplus >= 201103L
+    insert(const_iterator __position, const value_type& __x)
+#else
+    insert(iterator __position, const value_type& __x)
+#endif
+    {
+      _Node* __tmp = _M_create_node(__x);
+      __tmp->_M_hook(__position._M_const_cast()._M_node);
+      return iterator(__tmp);
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+    insert(const_iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n)
+	{
+	  list __tmp(__n, __x, get_allocator());
+	  iterator __it = __tmp.begin();
+	  splice(__position, __tmp);
+	  return __it;
+	}
+      return __position._M_const_cast();
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator, typename>
+      typename list<_Tp, _Alloc>::iterator
+      list<_Tp, _Alloc>::
+      insert(const_iterator __position, _InputIterator __first,
+	     _InputIterator __last)
+      {
+	list __tmp(__first, __last, get_allocator());
+	if (!__tmp.empty())
+	  {
+	    iterator __it = __tmp.begin();
+	    splice(__position, __tmp);
+	    return __it;
+	  }
+	return __position._M_const_cast();
+      }
+#endif
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+#if __cplusplus >= 201103L
+    erase(const_iterator __position) noexcept
+#else
+    erase(iterator __position)
+#endif
+    {
+      iterator __ret = iterator(__position._M_node->_M_next);
+      _M_erase(__position._M_const_cast());
+      return __ret;
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      size_type __i = 0;
+      __try
+	{
+	  for (; __i < __n; ++__i)
+	    emplace_back();
+	}
+      __catch(...)
+	{
+	  for (; __i; --__i)
+	    pop_back();
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size)
+    {
+      iterator __i = begin();
+      size_type __len = 0;
+      for (; __i != end() && __len < __new_size; ++__i, ++__len)
+        ;
+      if (__len == __new_size)
+        erase(__i, end());
+      else                          // __i == end()
+	_M_default_append(__new_size - __len);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size, const value_type& __x)
+    {
+      iterator __i = begin();
+      size_type __len = 0;
+      for (; __i != end() && __len < __new_size; ++__i, ++__len)
+        ;
+      if (__len == __new_size)
+        erase(__i, end());
+      else                          // __i == end()
+        insert(end(), __new_size - __len, __x);
+    }
+#else
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size, value_type __x)
+    {
+      iterator __i = begin();
+      size_type __len = 0;
+      for (; __i != end() && __len < __new_size; ++__i, ++__len)
+        ;
+      if (__len == __new_size)
+        erase(__i, end());
+      else                          // __i == end()
+        insert(end(), __new_size - __len, __x);
+    }
+#endif
+
+  template<typename _Tp, typename _Alloc>
+    list<_Tp, _Alloc>&
+    list<_Tp, _Alloc>::
+    operator=(const list& __x)
+    {
+      if (this != &__x)
+	{
+	  iterator __first1 = begin();
+	  iterator __last1 = end();
+	  const_iterator __first2 = __x.begin();
+	  const_iterator __last2 = __x.end();
+	  for (; __first1 != __last1 && __first2 != __last2;
+	       ++__first1, ++__first2)
+	    *__first1 = *__first2;
+	  if (__first2 == __last2)
+	    erase(__first1, __last1);
+	  else
+	    insert(__last1, __first2, __last2);
+	}
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    _M_fill_assign(size_type __n, const value_type& __val)
+    {
+      iterator __i = begin();
+      for (; __i != end() && __n > 0; ++__i, --__n)
+        *__i = __val;
+      if (__n > 0)
+        insert(end(), __n, __val);
+      else
+        erase(__i, end());
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      list<_Tp, _Alloc>::
+      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
+			 __false_type)
+      {
+        iterator __first1 = begin();
+        iterator __last1 = end();
+        for (; __first1 != __last1 && __first2 != __last2;
+	     ++__first1, ++__first2)
+          *__first1 = *__first2;
+        if (__first2 == __last2)
+          erase(__first1, __last1);
+        else
+          insert(__last1, __first2, __last2);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    remove(const value_type& __value)
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      iterator __extra = __last;
+      while (__first != __last)
+	{
+	  iterator __next = __first;
+	  ++__next;
+	  if (*__first == __value)
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 526. Is it undefined if a function in the standard changes
+	      // in parameters?
+	      if (std::__addressof(*__first) != std::__addressof(__value))
+		_M_erase(__first);
+	      else
+		__extra = __first;
+	    }
+	  __first = __next;
+	}
+      if (__extra != __last)
+	_M_erase(__extra);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    unique()
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      if (__first == __last)
+	return;
+      iterator __next = __first;
+      while (++__next != __last)
+	{
+	  if (*__first == *__next)
+	    _M_erase(__next);
+	  else
+	    __first = __next;
+	  __next = __first;
+	}
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+#if __cplusplus >= 201103L
+    merge(list&& __x)
+#else
+    merge(list& __x)
+#endif
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 300. list::merge() specification incomplete
+      if (this != &__x)
+	{
+	  _M_check_equal_allocators(__x); 
+
+	  iterator __first1 = begin();
+	  iterator __last1 = end();
+	  iterator __first2 = __x.begin();
+	  iterator __last2 = __x.end();
+	  while (__first1 != __last1 && __first2 != __last2)
+	    if (*__first2 < *__first1)
+	      {
+		iterator __next = __first2;
+		_M_transfer(__first1, __first2, ++__next);
+		__first2 = __next;
+	      }
+	    else
+	      ++__first1;
+	  if (__first2 != __last2)
+	    _M_transfer(__last1, __first2, __last2);
+	}
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+#if __cplusplus >= 201103L
+      merge(list&& __x, _StrictWeakOrdering __comp)
+#else
+      merge(list& __x, _StrictWeakOrdering __comp)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 300. list::merge() specification incomplete
+	if (this != &__x)
+	  {
+	    _M_check_equal_allocators(__x);
+
+	    iterator __first1 = begin();
+	    iterator __last1 = end();
+	    iterator __first2 = __x.begin();
+	    iterator __last2 = __x.end();
+	    while (__first1 != __last1 && __first2 != __last2)
+	      if (__comp(*__first2, *__first1))
+		{
+		  iterator __next = __first2;
+		  _M_transfer(__first1, __first2, ++__next);
+		  __first2 = __next;
+		}
+	      else
+		++__first1;
+	    if (__first2 != __last2)
+	      _M_transfer(__last1, __first2, __last2);
+	  }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    sort()
+    {
+      // Do nothing if the list has length 0 or 1.
+      if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+	  && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+      {
+        list __carry;
+        list __tmp[64];
+        list * __fill = &__tmp[0];
+        list * __counter;
+
+        do
+	  {
+	    __carry.splice(__carry.begin(), *this, begin());
+
+	    for(__counter = &__tmp[0];
+		__counter != __fill && !__counter->empty();
+		++__counter)
+	      {
+		__counter->merge(__carry);
+		__carry.swap(*__counter);
+	      }
+	    __carry.swap(*__counter);
+	    if (__counter == __fill)
+	      ++__fill;
+	  }
+	while ( !empty() );
+
+        for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
+          __counter->merge(*(__counter - 1));
+        swap( *(__fill - 1) );
+      }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _Predicate>
+      void
+      list<_Tp, _Alloc>::
+      remove_if(_Predicate __pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        while (__first != __last)
+	  {
+	    iterator __next = __first;
+	    ++__next;
+	    if (__pred(*__first))
+	      _M_erase(__first);
+	    __first = __next;
+	  }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _BinaryPredicate>
+      void
+      list<_Tp, _Alloc>::
+      unique(_BinaryPredicate __binary_pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        if (__first == __last)
+	  return;
+        iterator __next = __first;
+        while (++__next != __last)
+	  {
+	    if (__binary_pred(*__first, *__next))
+	      _M_erase(__next);
+	    else
+	      __first = __next;
+	    __next = __first;
+	  }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+      sort(_StrictWeakOrdering __comp)
+      {
+	// Do nothing if the list has length 0 or 1.
+	if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+	    && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+	  {
+	    list __carry;
+	    list __tmp[64];
+	    list * __fill = &__tmp[0];
+	    list * __counter;
+
+	    do
+	      {
+		__carry.splice(__carry.begin(), *this, begin());
+
+		for(__counter = &__tmp[0];
+		    __counter != __fill && !__counter->empty();
+		    ++__counter)
+		  {
+		    __counter->merge(__carry, __comp);
+		    __carry.swap(*__counter);
+		  }
+		__carry.swap(*__counter);
+		if (__counter == __fill)
+		  ++__fill;
+	      }
+	    while ( !empty() );
+
+	    for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
+	      __counter->merge(*(__counter - 1), __comp);
+	    swap(*(__fill - 1));
+	  }
+      }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _LIST_TCC */
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/locale_classes.h b/gcc-4.9/libstdc++-v3/include/bits/locale_classes.h
new file mode 100644
index 0000000..6dd452a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/locale_classes.h
@@ -0,0 +1,789 @@
+// Locale support -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/locale_classes.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+//
+// ISO C++ 14882: 22.1  Locales
+//
+
+#ifndef _LOCALE_CLASSES_H
+#define _LOCALE_CLASSES_H 1
+
+#pragma GCC system_header
+
+#include <bits/localefwd.h>
+#include <string>
+#include <ext/atomicity.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 22.1.1 Class locale
+  /**
+   *  @brief  Container class for localization functionality.
+   *  @ingroup locales
+   *
+   *  The locale class is first a class wrapper for C library locales.  It is
+   *  also an extensible container for user-defined localization.  A locale is
+   *  a collection of facets that implement various localization features such
+   *  as money, time, and number printing.
+   *
+   *  Constructing C++ locales does not change the C library locale.
+   *
+   *  This library supports efficient construction and copying of locales
+   *  through a reference counting implementation of the locale class.
+  */
+  class locale
+  {
+  public:
+    // Types:
+    /// Definition of locale::category.
+    typedef int	category;
+
+    // Forward decls and friends:
+    class facet;
+    class id;
+    class _Impl;
+
+    friend class facet;
+    friend class _Impl;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+
+    //@{
+    /**
+     *  @brief  Category values.
+     *
+     *  The standard category values are none, ctype, numeric, collate, time,
+     *  monetary, and messages.  They form a bitmask that supports union and
+     *  intersection.  The category all is the union of these values.
+     *
+     *  NB: Order must match _S_facet_categories definition in locale.cc
+    */
+    static const category none		= 0;
+    static const category ctype		= 1L << 0;
+    static const category numeric	= 1L << 1;
+    static const category collate	= 1L << 2;
+    static const category time		= 1L << 3;
+    static const category monetary	= 1L << 4;
+    static const category messages	= 1L << 5;
+    static const category all		= (ctype | numeric | collate |
+					   time  | monetary | messages);
+    //@}
+
+    // Construct/copy/destroy:
+
+    /**
+     *  @brief  Default constructor.
+     *
+     *  Constructs a copy of the global locale.  If no locale has been
+     *  explicitly set, this is the C locale.
+    */
+    locale() throw();
+
+    /**
+     *  @brief  Copy constructor.
+     *
+     *  Constructs a copy of @a other.
+     *
+     *  @param  __other  The locale to copy.
+    */
+    locale(const locale& __other) throw();
+
+    /**
+     *  @brief  Named locale constructor.
+     *
+     *  Constructs a copy of the named C library locale.
+     *
+     *  @param  __s  Name of the locale to construct.
+     *  @throw  std::runtime_error if __s is null or an undefined locale.
+    */
+    explicit
+    locale(const char* __s);
+
+    /**
+     *  @brief  Construct locale with facets from another locale.
+     *
+     *  Constructs a copy of the locale @a base.  The facets specified by @a
+     *  cat are replaced with those from the locale named by @a s.  If base is
+     *  named, this locale instance will also be named.
+     *
+     *  @param  __base  The locale to copy.
+     *  @param  __s  Name of the locale to use facets from.
+     *  @param  __cat  Set of categories defining the facets to use from __s.
+     *  @throw  std::runtime_error if __s is null or an undefined locale.
+    */
+    locale(const locale& __base, const char* __s, category __cat);
+
+    /**
+     *  @brief  Construct locale with facets from another locale.
+     *
+     *  Constructs a copy of the locale @a base.  The facets specified by @a
+     *  cat are replaced with those from the locale @a add.  If @a base and @a
+     *  add are named, this locale instance will also be named.
+     *
+     *  @param  __base  The locale to copy.
+     *  @param  __add  The locale to use facets from.
+     *  @param  __cat  Set of categories defining the facets to use from add.
+    */
+    locale(const locale& __base, const locale& __add, category __cat);
+
+    /**
+     *  @brief  Construct locale with another facet.
+     *
+     *  Constructs a copy of the locale @a __other.  The facet @a __f
+     *  is added to @a __other, replacing an existing facet of type
+     *  Facet if there is one.  If @a __f is null, this locale is a
+     *  copy of @a __other.
+     *
+     *  @param  __other  The locale to copy.
+     *  @param  __f  The facet to add in.
+    */
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+
+    /// Locale destructor.
+    ~locale() throw();
+
+    /**
+     *  @brief  Assignment operator.
+     *
+     *  Set this locale to be a copy of @a other.
+     *
+     *  @param  __other  The locale to copy.
+     *  @return  A reference to this locale.
+    */
+    const locale&
+    operator=(const locale& __other) throw();
+
+    /**
+     *  @brief  Construct locale with another facet.
+     *
+     *  Constructs and returns a new copy of this locale.  Adds or replaces an
+     *  existing facet of type Facet from the locale @a other into the new
+     *  locale.
+     *
+     *  @tparam  _Facet  The facet type to copy from other
+     *  @param  __other  The locale to copy from.
+     *  @return  Newly constructed locale.
+     *  @throw  std::runtime_error if __other has no facet of type _Facet.
+    */
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+
+    // Locale operations:
+    /**
+     *  @brief  Return locale name.
+     *  @return  Locale name or "*" if unnamed.
+    */
+    string
+    name() const;
+
+    /**
+     *  @brief  Locale equality.
+     *
+     *  @param  __other  The locale to compare against.
+     *  @return  True if other and this refer to the same locale instance, are
+     *		 copies, or have the same name.  False otherwise.
+    */
+    bool
+    operator==(const locale& __other) const throw();
+
+    /**
+     *  @brief  Locale inequality.
+     *
+     *  @param  __other  The locale to compare against.
+     *  @return  ! (*this == __other)
+    */
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+
+    /**
+     *  @brief  Compare two strings according to collate.
+     *
+     *  Template operator to compare two strings using the compare function of
+     *  the collate facet in this locale.  One use is to provide the locale to
+     *  the sort function.  For example, a vector v of strings could be sorted
+     *  according to locale loc by doing:
+     *  @code
+     *  std::sort(v.begin(), v.end(), loc);
+     *  @endcode
+     *
+     *  @param  __s1  First string to compare.
+     *  @param  __s2  Second string to compare.
+     *  @return  True if collate<_Char> facet compares __s1 < __s2, else false.
+    */
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+		 const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+
+    // Global locale objects:
+    /**
+     *  @brief  Set global locale
+     *
+     *  This function sets the global locale to the argument and returns a
+     *  copy of the previous global locale.  If the argument has a name, it
+     *  will also call std::setlocale(LC_ALL, loc.name()).
+     *
+     *  @param  __loc  The new locale to make global.
+     *  @return  Copy of the old global locale.
+    */
+    static locale
+    global(const locale& __loc);
+
+    /**
+     *  @brief  Return reference to the C locale.
+    */
+    static const locale&
+    classic();
+
+  private:
+    // The (shared) implementation
+    _Impl*		_M_impl;
+
+    // The "C" reference locale
+    static _Impl*       _S_classic;
+
+    // Current global locale
+    static _Impl*	_S_global;
+
+    // Names of underlying locale categories.
+    // NB: locale::global() has to know how to modify all the
+    // underlying categories, not just the ones required by the C++
+    // standard.
+    static const char* const* const _S_categories;
+
+    // Number of standard categories. For C++, these categories are
+    // collate, ctype, monetary, numeric, time, and messages. These
+    // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
+    // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
+    // 1003.1-2001) specifies LC_MESSAGES.
+    // In addition to the standard categories, the underlying
+    // operating system is allowed to define extra LC_*
+    // macros. For GNU systems, the following are also valid:
+    // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
+    // and LC_IDENTIFICATION.
+    enum { _S_categories_size = 6 + _GLIBCXX_NUM_CATEGORIES };
+
+#ifdef __GTHREADS
+    static __gthread_once_t _S_once;
+#endif
+
+    explicit
+    locale(_Impl*) throw();
+
+    static void
+    _S_initialize();
+
+    static void
+    _S_initialize_once() throw();
+
+    static category
+    _S_normalize_category(category);
+
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+  };
+
+
+  // 22.1.1.1.2  Class locale::facet
+  /**
+   *  @brief  Localization functionality base class.
+   *  @ingroup locales
+   *
+   *  The facet class is the base class for a localization feature, such as
+   *  money, time, and number printing.  It provides common support for facets
+   *  and reference management.
+   *
+   *  Facets may not be copied or assigned.
+  */
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    mutable _Atomic_word		_M_refcount;
+
+    // Contains data from the underlying "C" library for the classic locale.
+    static __c_locale                   _S_c_locale;
+
+    // String literal for the name of the classic locale.
+    static const char			_S_c_name[2];
+
+#ifdef __GTHREADS
+    static __gthread_once_t		_S_once;
+#endif
+
+    static void
+    _S_initialize_once();
+
+  protected:
+    /**
+     *  @brief  Facet constructor.
+     *
+     *  This is the constructor provided by the standard.  If refs is 0, the
+     *  facet is destroyed when the last referencing locale is destroyed.
+     *  Otherwise the facet will never be destroyed.
+     *
+     *  @param __refs  The initial value for reference count.
+    */
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+
+    /// Facet destructor.
+    virtual
+    ~facet();
+
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+		       __c_locale __old = 0);
+
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+
+    // Returns data from the underlying "C" library data for the
+    // classic locale.
+    static __c_locale
+    _S_get_c_locale();
+
+    _GLIBCXX_CONST static const char*
+    _S_get_c_name() throw();
+
+  private:
+    void
+    _M_add_reference() const throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() const throw()
+    {
+      // Be race-detector-friendly.  For more info see bits/c++config.
+      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+	{
+          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
+	  __try
+	    { delete this; }
+	  __catch(...)
+	    { }
+	}
+    }
+
+    facet(const facet&);  // Not defined.
+
+    facet&
+    operator=(const facet&);  // Not defined.
+  };
+
+
+  // 22.1.1.1.3 Class locale::id
+  /**
+   *  @brief  Facet ID class.
+   *  @ingroup locales
+   *
+   *  The ID class provides facets with an index used to identify them.
+   *  Every facet class must define a public static member locale::id, or be
+   *  derived from a facet that provides this member, otherwise the facet
+   *  cannot be used in a locale.  The locale::id ensures that each class
+   *  type gets a unique identifier.
+  */
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    // NB: There is no accessor for _M_index because it may be used
+    // before the constructor is run; the effect of calling a member
+    // function (even an inline) would be undefined.
+    mutable size_t		_M_index;
+
+    // Last id number assigned.
+    static _Atomic_word		_S_refcount;
+
+    void
+    operator=(const id&);  // Not defined.
+
+    id(const id&);  // Not defined.
+
+  public:
+    // NB: This class is always a static data member, and thus can be
+    // counted on to be zero-initialized.
+    /// Constructor.
+    id() { }
+
+    size_t
+    _M_id() const throw();
+  };
+
+
+  // Implementation object for locale.
+  class locale::_Impl
+  {
+  public:
+    // Friends.
+    friend class locale;
+    friend class locale::facet;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+
+  private:
+    // Data Members.
+    _Atomic_word			_M_refcount;
+    const facet**			_M_facets;
+    size_t				_M_facets_size;
+    const facet**			_M_caches;
+    char**				_M_names;
+    static const locale::id* const	_S_id_ctype[];
+    static const locale::id* const	_S_id_numeric[];
+    static const locale::id* const	_S_id_collate[];
+    static const locale::id* const	_S_id_time[];
+    static const locale::id* const	_S_id_monetary[];
+    static const locale::id* const	_S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() throw()
+    {
+      // Be race-detector-friendly.  For more info see bits/c++config.
+      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+	{
+          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
+	  __try
+	    { delete this; }
+	  __catch(...)
+	    { }
+	}
+    }
+
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+
+   ~_Impl() throw();
+
+    _Impl(const _Impl&);  // Not defined.
+
+    void
+    operator=(const _Impl&);  // Not defined.
+
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+	// We must actually compare all the _M_names: can be all equal!
+	for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+	  __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+
+    void
+    _M_replace_categories(const _Impl*, category);
+
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+
+    void
+    _M_install_facet(const locale::id*, const facet*);
+
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+
+    void
+    _M_install_cache(const facet*, size_t);
+  };
+
+
+  /**
+   *  @brief  Facet for localized string comparison.
+   *
+   *  This facet encapsulates the code to compare strings in a localized
+   *  manner.
+   *
+   *  The collate template uses protected virtual functions to provide
+   *  the actual results.  The public accessors forward the call to
+   *  the virtual functions.  These virtual functions are hooks for
+   *  developers to implement the behavior they require from the
+   *  collate facet.
+  */
+  template<typename _CharT>
+    class collate : public locale::facet
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef basic_string<_CharT>	string_type;
+      //@}
+
+    protected:
+      // Underlying "C" library locale information saved from
+      // initialization, needed by collate_byname as well.
+      __c_locale			_M_c_locale_collate;
+
+    public:
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+
+      /**
+       *  @brief  Internal constructor. Not for general use.
+       *
+       *  This is a constructor for use by the library itself to set up new
+       *  locales.
+       *
+       *  @param __cloc  The C locale.
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+
+      /**
+       *  @brief  Compare two strings.
+       *
+       *  This function compares two strings and returns the result by calling
+       *  collate::do_compare().
+       *
+       *  @param __lo1  Start of string 1.
+       *  @param __hi1  End of string 1.
+       *  @param __lo2  Start of string 2.
+       *  @param __hi2  End of string 2.
+       *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
+      */
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+	      const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+
+      /**
+       *  @brief  Transform string to comparable form.
+       *
+       *  This function is a wrapper for strxfrm functionality.  It takes the
+       *  input string and returns a modified string that can be directly
+       *  compared to other transformed strings.  In the C locale, this
+       *  function just returns a copy of the input string.  In some other
+       *  locales, it may replace two chars with one, change a char for
+       *  another, etc.  It does so by returning collate::do_transform().
+       *
+       *  @param __lo  Start of string.
+       *  @param __hi  End of string.
+       *  @return  Transformed string_type.
+      */
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+
+      /**
+       *  @brief  Return hash of a string.
+       *
+       *  This function computes and returns a hash on the input string.  It
+       *  does so by returning collate::do_hash().
+       *
+       *  @param __lo  Start of string.
+       *  @param __hi  End of string.
+       *  @return  Hash value.
+      */
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+
+      // Used to abstract out _CharT bits in virtual member functions, below.
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+
+  protected:
+      /// Destructor.
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+
+      /**
+       *  @brief  Compare two strings.
+       *
+       *  This function is a hook for derived classes to change the value
+       *  returned.  @see compare().
+       *
+       *  @param __lo1  Start of string 1.
+       *  @param __hi1  End of string 1.
+       *  @param __lo2  Start of string 2.
+       *  @param __hi2  End of string 2.
+       *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
+      */
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+		 const _CharT* __lo2, const _CharT* __hi2) const;
+
+      /**
+       *  @brief  Transform string to comparable form.
+       *
+       *  This function is a hook for derived classes to change the value
+       *  returned.
+       *
+       *  @param __lo  Start.
+       *  @param __hi  End.
+       *  @return  transformed string.
+      */
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+
+      /**
+       *  @brief  Return hash of a string.
+       *
+       *  This function computes and returns a hash on the input string.  This
+       *  function is a hook for derived classes to change the value returned.
+       *
+       *  @param __lo  Start of string.
+       *  @param __hi  End of string.
+       *  @return  Hash value.
+      */
+      virtual long
+      do_hash(const _CharT* __lo, const _CharT* __hi) const;
+    };
+
+  template<typename _CharT>
+    locale::id collate<_CharT>::id;
+
+  // Specializations.
+  template<>
+    int
+    collate<char>::_M_compare(const char*, const char*) const throw();
+
+  template<>
+    size_t
+    collate<char>::_M_transform(char*, const char*, size_t) const throw();
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    int
+    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
+
+  template<>
+    size_t
+    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
+#endif
+
+  /// class collate_byname [22.2.4.2].
+  template<typename _CharT>
+    class collate_byname : public collate<_CharT>
+    {
+    public:
+      //@{
+      /// Public typedefs
+      typedef _CharT               char_type;
+      typedef basic_string<_CharT> string_type;
+      //@}
+
+      explicit
+      collate_byname(const char* __s, size_t __refs = 0)
+      : collate<_CharT>(__refs)
+      {
+	if (__builtin_strcmp(__s, "C") != 0
+	    && __builtin_strcmp(__s, "POSIX") != 0)
+	  {
+	    this->_S_destroy_c_locale(this->_M_c_locale_collate);
+	    this->_S_create_c_locale(this->_M_c_locale_collate, __s);
+	  }
+      }
+
+    protected:
+      virtual
+      ~collate_byname() { }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+# include <bits/locale_classes.tcc>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/locale_classes.tcc b/gcc-4.9/libstdc++-v3/include/bits/locale_classes.tcc
new file mode 100644
index 0000000..f0188ef
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/locale_classes.tcc
@@ -0,0 +1,298 @@
+// Locale support -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/locale_classes.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+//
+// ISO C++ 14882: 22.1  Locales
+//
+
+#ifndef _LOCALE_CLASSES_TCC
+#define _LOCALE_CLASSES_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Facet>
+    locale::
+    locale(const locale& __other, _Facet* __f)
+    {
+      _M_impl = new _Impl(*__other._M_impl, 1);
+
+      __try
+	{ _M_impl->_M_install_facet(&_Facet::id, __f); }
+      __catch(...)
+	{
+	  _M_impl->_M_remove_reference();
+	  __throw_exception_again;
+	}
+      delete [] _M_impl->_M_names[0];
+      _M_impl->_M_names[0] = 0;   // Unnamed.
+    }
+
+  template<typename _Facet>
+    locale
+    locale::
+    combine(const locale& __other) const
+    {
+      _Impl* __tmp = new _Impl(*_M_impl, 1);
+      __try
+	{
+	  __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
+	}
+      __catch(...)
+	{
+	  __tmp->_M_remove_reference();
+	  __throw_exception_again;
+	}
+      return locale(__tmp);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    bool
+    locale::
+    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
+	       const basic_string<_CharT, _Traits, _Alloc>& __s2) const
+    {
+      typedef std::collate<_CharT> __collate_type;
+      const __collate_type& __collate = use_facet<__collate_type>(*this);
+      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
+				__s2.data(), __s2.data() + __s2.length()) < 0);
+    }
+
+  /**
+   *  @brief  Test for the presence of a facet.
+   *  @ingroup locales
+   *
+   *  has_facet tests the locale argument for the presence of the facet type
+   *  provided as the template parameter.  Facets derived from the facet
+   *  parameter will also return true.
+   *
+   *  @tparam  _Facet  The facet type to test the presence of.
+   *  @param  __loc  The locale to test.
+   *  @return  true if @p __loc contains a facet of type _Facet, else false.
+  */
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw()
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      return (__i < __loc._M_impl->_M_facets_size
+#ifdef __GXX_RTTI
+	      && dynamic_cast<const _Facet*>(__facets[__i]));
+#else
+              && static_cast<const _Facet*>(__facets[__i]));
+#endif
+    }
+
+  /**
+   *  @brief  Return a facet.
+   *  @ingroup locales
+   *
+   *  use_facet looks for and returns a reference to a facet of type Facet
+   *  where Facet is the template parameter.  If has_facet(locale) is true,
+   *  there is a suitable facet to return.  It throws std::bad_cast if the
+   *  locale doesn't contain a facet of type Facet.
+   *
+   *  @tparam  _Facet  The facet type to access.
+   *  @param  __loc  The locale to use.
+   *  @return  Reference to facet of type Facet.
+   *  @throw  std::bad_cast if @p __loc doesn't contain a facet of type _Facet.
+  */
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc)
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
+        __throw_bad_cast();
+#ifdef __GXX_RTTI
+      return dynamic_cast<const _Facet&>(*__facets[__i]);
+#else
+      return static_cast<const _Facet&>(*__facets[__i]);
+#endif
+    }
+
+
+  // Generic version does nothing.
+  template<typename _CharT>
+    int
+    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
+    { return 0; }
+
+  // Generic version does nothing.
+  template<typename _CharT>
+    size_t
+    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
+    { return 0; }
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::
+    do_compare(const _CharT* __lo1, const _CharT* __hi1,
+	       const _CharT* __lo2, const _CharT* __hi2) const
+    {
+      // strcoll assumes zero-terminated strings so we make a copy
+      // and then put a zero at the end.
+      const string_type __one(__lo1, __hi1);
+      const string_type __two(__lo2, __hi2);
+
+      const _CharT* __p = __one.c_str();
+      const _CharT* __pend = __one.data() + __one.length();
+      const _CharT* __q = __two.c_str();
+      const _CharT* __qend = __two.data() + __two.length();
+
+      // strcoll stops when it sees a nul character so we break
+      // the strings into zero-terminated substrings and pass those
+      // to strcoll.
+      for (;;)
+	{
+	  const int __res = _M_compare(__p, __q);
+	  if (__res)
+	    return __res;
+
+	  __p += char_traits<_CharT>::length(__p);
+	  __q += char_traits<_CharT>::length(__q);
+	  if (__p == __pend && __q == __qend)
+	    return 0;
+	  else if (__p == __pend)
+	    return -1;
+	  else if (__q == __qend)
+	    return 1;
+
+	  __p++;
+	  __q++;
+	}
+    }
+
+  template<typename _CharT>
+    typename collate<_CharT>::string_type
+    collate<_CharT>::
+    do_transform(const _CharT* __lo, const _CharT* __hi) const
+    {
+      string_type __ret;
+
+      // strxfrm assumes zero-terminated strings so we make a copy
+      const string_type __str(__lo, __hi);
+
+      const _CharT* __p = __str.c_str();
+      const _CharT* __pend = __str.data() + __str.length();
+
+      size_t __len = (__hi - __lo) * 2;
+
+      _CharT* __c = new _CharT[__len];
+
+      __try
+	{
+	  // strxfrm stops when it sees a nul character so we break
+	  // the string into zero-terminated substrings and pass those
+	  // to strxfrm.
+	  for (;;)
+	    {
+	      // First try a buffer perhaps big enough.
+	      size_t __res = _M_transform(__c, __p, __len);
+	      // If the buffer was not large enough, try again with the
+	      // correct size.
+	      if (__res >= __len)
+		{
+		  __len = __res + 1;
+		  delete [] __c, __c = 0;
+		  __c = new _CharT[__len];
+		  __res = _M_transform(__c, __p, __len);
+		}
+
+	      __ret.append(__c, __res);
+	      __p += char_traits<_CharT>::length(__p);
+	      if (__p == __pend)
+		break;
+
+	      __p++;
+	      __ret.push_back(_CharT());
+	    }
+	}
+      __catch(...)
+	{
+	  delete [] __c;
+	  __throw_exception_again;
+	}
+
+      delete [] __c;
+
+      return __ret;
+    }
+
+  template<typename _CharT>
+    long
+    collate<_CharT>::
+    do_hash(const _CharT* __lo, const _CharT* __hi) const
+    {
+      unsigned long __val = 0;
+      for (; __lo < __hi; ++__lo)
+	__val =
+	  *__lo + ((__val << 7)
+		   | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
+				__digits - 7)));
+      return static_cast<long>(__val);
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class collate<char>;
+  extern template class collate_byname<char>;
+
+  extern template
+    const collate<char>&
+    use_facet<collate<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<char> >(const locale&);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class collate<wchar_t>;
+  extern template class collate_byname<wchar_t>;
+
+  extern template
+    const collate<wchar_t>&
+    use_facet<collate<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<wchar_t> >(const locale&);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/locale_facets.h b/gcc-4.9/libstdc++-v3/include/bits/locale_facets.h
new file mode 100644
index 0000000..453bbed
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/locale_facets.h
@@ -0,0 +1,2610 @@
+// Locale support -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/locale_facets.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+//
+// ISO C++ 14882: 22.1  Locales
+//
+
+#ifndef _LOCALE_FACETS_H
+#define _LOCALE_FACETS_H 1
+
+#pragma GCC system_header
+
+#include <cwctype>	// For wctype_t
+#include <cctype>
+#include <bits/ctype_base.h>
+#include <iosfwd>
+#include <bits/ios_base.h>  // For ios_base, ios_base::iostate
+#include <streambuf>
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+#include <ext/numeric_traits.h>
+#include <bits/streambuf_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // NB: Don't instantiate required wchar_t facets if no wchar_t support.
+#ifdef _GLIBCXX_USE_WCHAR_T
+# define  _GLIBCXX_NUM_FACETS 28
+#else
+# define  _GLIBCXX_NUM_FACETS 14
+#endif
+
+  // Convert string to numeric value of type _Tp and store results.
+  // NB: This is specialized for all required types, there is no
+  // generic definition.
+  template<typename _Tp>
+    void
+    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
+		   const __c_locale&) throw();
+
+  // Explicit specializations for required types.
+  template<>
+    void
+    __convert_to_v(const char*, float&, ios_base::iostate&,
+		   const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, double&, ios_base::iostate&,
+		   const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
+		   const __c_locale&) throw();
+
+  // NB: __pad is a struct, rather than a function, so it can be
+  // partially-specialized.
+  template<typename _CharT, typename _Traits>
+    struct __pad
+    {
+      static void
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+	     const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
+    };
+
+  // Used by both numeric and monetary facets.
+  // Inserts "group separator" characters into an array of characters.
+  // It's recursive, one iteration per group.  It moves the characters
+  // in the buffer this way: "xxxx12345" -> "12,345xxx".  Call this
+  // only with __gsize != 0.
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+		   const char* __gbeg, size_t __gsize,
+		   const _CharT* __first, const _CharT* __last);
+
+  // This template permits specializing facet output code for
+  // ostreambuf_iterator.  For ostreambuf_iterator, sputn is
+  // significantly more efficient than incrementing iterators.
+  template<typename _CharT>
+    inline
+    ostreambuf_iterator<_CharT>
+    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
+    {
+      __s._M_put(__ws, __len);
+      return __s;
+    }
+
+  // This is the unspecialized form of the template.
+  template<typename _CharT, typename _OutIter>
+    inline
+    _OutIter
+    __write(_OutIter __s, const _CharT* __ws, int __len)
+    {
+      for (int __j = 0; __j < __len; __j++, ++__s)
+	*__s = __ws[__j];
+      return __s;
+    }
+
+
+  // 22.2.1.1  Template class ctype
+  // Include host and configuration specific ctype enums for ctype_base.
+
+  /**
+   *  @brief  Common base for ctype facet
+   *
+   *  This template class provides implementations of the public functions
+   *  that forward to the protected virtual functions.
+   *
+   *  This template also provides abstract stubs for the protected virtual
+   *  functions.
+  */
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+      // Types:
+      /// Typedef for the template parameter
+      typedef _CharT char_type;
+
+      /**
+       *  @brief  Test char_type classification.
+       *
+       *  This function finds a mask M for @a __c and compares it to
+       *  mask @a __m.  It does so by returning the value of
+       *  ctype<char_type>::do_is().
+       *
+       *  @param __c  The char_type to compare the mask of.
+       *  @param __m  The mask to compare against.
+       *  @return  (M & __m) != 0.
+      */
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+
+      /**
+       *  @brief  Return a mask array.
+       *
+       *  This function finds the mask for each char_type in the range [lo,hi)
+       *  and successively writes it to vec.  vec must have as many elements
+       *  as the char array.  It does so by returning the value of
+       *  ctype<char_type>::do_is().
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __vec  Pointer to an array of mask storage.
+       *  @return  @a __hi.
+      */
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+
+      /**
+       *  @brief  Find char_type matching a mask
+       *
+       *  This function searches for and returns the first char_type c in
+       *  [lo,hi) for which is(m,c) is true.  It does so by returning
+       *  ctype<char_type>::do_scan_is().
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to matching char_type if found, else @a __hi.
+      */
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+
+      /**
+       *  @brief  Find char_type not matching a mask
+       *
+       *  This function searches for and returns the first char_type c in
+       *  [lo,hi) for which is(m,c) is false.  It does so by returning
+       *  ctype<char_type>::do_scan_not().
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to first char in range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to non-matching char if found, else @a __hi.
+      */
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+
+      /**
+       *  @brief  Convert to uppercase.
+       *
+       *  This function converts the argument to uppercase if possible.
+       *  If not possible (for example, '2'), returns the argument.  It does
+       *  so by returning ctype<char_type>::do_toupper().
+       *
+       *  @param __c  The char_type to convert.
+       *  @return  The uppercase char_type if convertible, else @a __c.
+      */
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+
+      /**
+       *  @brief  Convert array to uppercase.
+       *
+       *  This function converts each char_type in the range [lo,hi) to
+       *  uppercase if possible.  Other elements remain untouched.  It does so
+       *  by returning ctype<char_type>:: do_toupper(lo, hi).
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+
+      /**
+       *  @brief  Convert to lowercase.
+       *
+       *  This function converts the argument to lowercase if possible.  If
+       *  not possible (for example, '2'), returns the argument.  It does so
+       *  by returning ctype<char_type>::do_tolower(c).
+       *
+       *  @param __c  The char_type to convert.
+       *  @return  The lowercase char_type if convertible, else @a __c.
+      */
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+
+      /**
+       *  @brief  Convert array to lowercase.
+       *
+       *  This function converts each char_type in the range [__lo,__hi) to
+       *  lowercase if possible.  Other elements remain untouched.  It does so
+       *  by returning ctype<char_type>:: do_tolower(__lo, __hi).
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+
+      /**
+       *  @brief  Widen char to char_type
+       *
+       *  This function converts the char argument to char_type using the
+       *  simplest reasonable transformation.  It does so by returning
+       *  ctype<char_type>::do_widen(c).
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The converted char_type.
+      */
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+
+      /**
+       *  @brief  Widen array to char_type
+       *
+       *  This function converts each char in the input to char_type using the
+       *  simplest reasonable transformation.  It does so by returning
+       *  ctype<char_type>::do_widen(c).
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+
+      /**
+       *  @brief  Narrow char_type to char
+       *
+       *  This function converts the char_type to char using the simplest
+       *  reasonable transformation.  If the conversion fails, dfault is
+       *  returned instead.  It does so by returning
+       *  ctype<char_type>::do_narrow(__c).
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char_type to convert.
+       *  @param __dfault  Char to return if conversion fails.
+       *  @return  The converted char.
+      */
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+
+      /**
+       *  @brief  Narrow array to char array
+       *
+       *  This function converts each char_type in the input to char using the
+       *  simplest reasonable transformation and writes the results to the
+       *  destination array.  For any char_type in the input that cannot be
+       *  converted, @a dfault is used instead.  It does so by returning
+       *  ctype<char_type>::do_narrow(__lo, __hi, __dfault, __to).
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __dfault  Char to use if conversion fails.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+	      char __dfault, char* __to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+
+    protected:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+
+      virtual
+      ~__ctype_abstract_base() { }
+
+      /**
+       *  @brief  Test char_type classification.
+       *
+       *  This function finds a mask M for @a c and compares it to mask @a m.
+       *
+       *  do_is() is a hook for a derived facet to change the behavior of
+       *  classifying.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __c  The char_type to find the mask of.
+       *  @param __m  The mask to compare against.
+       *  @return  (M & __m) != 0.
+      */
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+
+      /**
+       *  @brief  Return a mask array.
+       *
+       *  This function finds the mask for each char_type in the range [lo,hi)
+       *  and successively writes it to vec.  vec must have as many elements
+       *  as the input.
+       *
+       *  do_is() is a hook for a derived facet to change the behavior of
+       *  classifying.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __vec  Pointer to an array of mask storage.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+	    mask* __vec) const = 0;
+
+      /**
+       *  @brief  Find char_type matching mask
+       *
+       *  This function searches for and returns the first char_type c in
+       *  [__lo,__hi) for which is(__m,c) is true.
+       *
+       *  do_scan_is() is a hook for a derived facet to change the behavior of
+       *  match searching.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to a matching char_type if found, else @a __hi.
+      */
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+		 const char_type* __hi) const = 0;
+
+      /**
+       *  @brief  Find char_type not matching mask
+       *
+       *  This function searches for and returns a pointer to the first
+       *  char_type c of [lo,hi) for which is(m,c) is false.
+       *
+       *  do_scan_is() is a hook for a derived facet to change the behavior of
+       *  match searching.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to a non-matching char_type if found, else @a __hi.
+      */
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+		  const char_type* __hi) const = 0;
+
+      /**
+       *  @brief  Convert to uppercase.
+       *
+       *  This virtual function converts the char_type argument to uppercase
+       *  if possible.  If not possible (for example, '2'), returns the
+       *  argument.
+       *
+       *  do_toupper() is a hook for a derived facet to change the behavior of
+       *  uppercasing.  do_toupper() must always return the same result for
+       *  the same input.
+       *
+       *  @param __c  The char_type to convert.
+       *  @return  The uppercase char_type if convertible, else @a __c.
+      */
+      virtual char_type
+      do_toupper(char_type __c) const = 0;
+
+      /**
+       *  @brief  Convert array to uppercase.
+       *
+       *  This virtual function converts each char_type in the range [__lo,__hi)
+       *  to uppercase if possible.  Other elements remain untouched.
+       *
+       *  do_toupper() is a hook for a derived facet to change the behavior of
+       *  uppercasing.  do_toupper() must always return the same result for
+       *  the same input.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+
+      /**
+       *  @brief  Convert to lowercase.
+       *
+       *  This virtual function converts the argument to lowercase if
+       *  possible.  If not possible (for example, '2'), returns the argument.
+       *
+       *  do_tolower() is a hook for a derived facet to change the behavior of
+       *  lowercasing.  do_tolower() must always return the same result for
+       *  the same input.
+       *
+       *  @param __c  The char_type to convert.
+       *  @return  The lowercase char_type if convertible, else @a __c.
+      */
+      virtual char_type
+      do_tolower(char_type __c) const = 0;
+
+      /**
+       *  @brief  Convert array to lowercase.
+       *
+       *  This virtual function converts each char_type in the range [__lo,__hi)
+       *  to lowercase if possible.  Other elements remain untouched.
+       *
+       *  do_tolower() is a hook for a derived facet to change the behavior of
+       *  lowercasing.  do_tolower() must always return the same result for
+       *  the same input.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+
+      /**
+       *  @brief  Widen char
+       *
+       *  This virtual function converts the char to char_type using the
+       *  simplest reasonable transformation.
+       *
+       *  do_widen() is a hook for a derived facet to change the behavior of
+       *  widening.  do_widen() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The converted char_type
+      */
+      virtual char_type
+      do_widen(char __c) const = 0;
+
+      /**
+       *  @brief  Widen char array
+       *
+       *  This function converts each char in the input to char_type using the
+       *  simplest reasonable transformation.
+       *
+       *  do_widen() is a hook for a derived facet to change the behavior of
+       *  widening.  do_widen() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
+
+      /**
+       *  @brief  Narrow char_type to char
+       *
+       *  This virtual function converts the argument to char using the
+       *  simplest reasonable transformation.  If the conversion fails, dfault
+       *  is returned instead.
+       *
+       *  do_narrow() is a hook for a derived facet to change the behavior of
+       *  narrowing.  do_narrow() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char_type to convert.
+       *  @param __dfault  Char to return if conversion fails.
+       *  @return  The converted char.
+      */
+      virtual char
+      do_narrow(char_type __c, char __dfault) const = 0;
+
+      /**
+       *  @brief  Narrow char_type array to char
+       *
+       *  This virtual function converts each char_type in the range
+       *  [__lo,__hi) to char using the simplest reasonable
+       *  transformation and writes the results to the destination
+       *  array.  For any element in the input that cannot be
+       *  converted, @a __dfault is used instead.
+       *
+       *  do_narrow() is a hook for a derived facet to change the behavior of
+       *  narrowing.  do_narrow() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __dfault  Char to use if conversion fails.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+		char __dfault, char* __to) const = 0;
+    };
+
+  /**
+   *  @brief  Primary class template ctype facet.
+   *  @ingroup locales
+   *
+   *  This template class defines classification and conversion functions for
+   *  character sets.  It wraps cctype functionality.  Ctype gets used by
+   *  streams for many I/O operations.
+   *
+   *  This template provides the protected virtual functions the developer
+   *  will have to replace in a derived class or specialization to make a
+   *  working facet.  The public functions that access them are defined in
+   *  __ctype_abstract_base, to allow for implementation flexibility.  See
+   *  ctype<wchar_t> for an example.  The functions are documented in
+   *  __ctype_abstract_base.
+   *
+   *  Note: implementations are provided for all the protected virtual
+   *  functions, but will likely not be useful.
+  */
+  template<typename _CharT>
+    class ctype : public __ctype_abstract_base<_CharT>
+    {
+    public:
+      // Types:
+      typedef _CharT			char_type;
+      typedef typename __ctype_abstract_base<_CharT>::mask mask;
+
+      /// The facet id for ctype<char_type>
+      static locale::id			id;
+
+      explicit
+      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
+
+   protected:
+      virtual
+      ~ctype();
+
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+		  const char_type* __hi) const;
+
+      virtual char_type
+      do_toupper(char_type __c) const;
+
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_tolower(char_type __c) const;
+
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_widen(char __c) const;
+
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+		char __dfault, char* __to) const;
+    };
+
+  template<typename _CharT>
+    locale::id ctype<_CharT>::id;
+
+  /**
+   *  @brief  The ctype<char> specialization.
+   *  @ingroup locales
+   *
+   *  This class defines classification and conversion functions for
+   *  the char type.  It gets used by char streams for many I/O
+   *  operations.  The char specialization provides a number of
+   *  optimizations as well.
+  */
+  template<>
+    class ctype<char> : public locale::facet, public ctype_base
+    {
+    public:
+      // Types:
+      /// Typedef for the template parameter char.
+      typedef char		char_type;
+
+    protected:
+      // Data Members:
+      __c_locale		_M_c_locale_ctype;
+      bool			_M_del;
+      __to_type			_M_toupper;
+      __to_type			_M_tolower;
+      const mask*		_M_table;
+      mutable char		_M_widen_ok;
+      mutable char		_M_widen[1 + static_cast<unsigned char>(-1)];
+      mutable char		_M_narrow[1 + static_cast<unsigned char>(-1)];
+      mutable char		_M_narrow_ok;	// 0 uninitialized, 1 init,
+						// 2 memcpy can't be used
+
+    public:
+      /// The facet id for ctype<char>
+      static locale::id        id;
+      /// The size of the mask table.  It is SCHAR_MAX + 1.
+      static const size_t      table_size = 1 + static_cast<unsigned char>(-1);
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __table If non-zero, table is used as the per-char mask.
+       *               Else classic_table() is used.
+       *  @param __del   If true, passes ownership of table to this facet.
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+
+      /**
+       *  @brief  Constructor performs static initialization.
+       *
+       *  This constructor is used to construct the initial C locale facet.
+       *
+       *  @param __cloc  Handle to C locale data.
+       *  @param __table If non-zero, table is used as the per-char mask.
+       *  @param __del   If true, passes ownership of table to this facet.
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+	    size_t __refs = 0);
+
+      /**
+       *  @brief  Test char classification.
+       *
+       *  This function compares the mask table[c] to @a __m.
+       *
+       *  @param __c  The char to compare the mask of.
+       *  @param __m  The mask to compare against.
+       *  @return  True if __m & table[__c] is true, false otherwise.
+      */
+      inline bool
+      is(mask __m, char __c) const;
+
+      /**
+       *  @brief  Return a mask array.
+       *
+       *  This function finds the mask for each char in the range [lo, hi) and
+       *  successively writes it to vec.  vec must have as many elements as
+       *  the char array.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __vec  Pointer to an array of mask storage.
+       *  @return  @a __hi.
+      */
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+
+      /**
+       *  @brief  Find char matching a mask
+       *
+       *  This function searches for and returns the first char in [lo,hi) for
+       *  which is(m,char) is true.
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to a matching char if found, else @a __hi.
+      */
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+
+      /**
+       *  @brief  Find char not matching a mask
+       *
+       *  This function searches for and returns a pointer to the first char
+       *  in [__lo,__hi) for which is(m,char) is false.
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to a non-matching char if found, else @a __hi.
+      */
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+
+      /**
+       *  @brief  Convert to uppercase.
+       *
+       *  This function converts the char argument to uppercase if possible.
+       *  If not possible (for example, '2'), returns the argument.
+       *
+       *  toupper() acts as if it returns ctype<char>::do_toupper(c).
+       *  do_toupper() must always return the same result for the same input.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The uppercase char if convertible, else @a __c.
+      */
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+
+      /**
+       *  @brief  Convert array to uppercase.
+       *
+       *  This function converts each char in the range [__lo,__hi) to uppercase
+       *  if possible.  Other chars remain untouched.
+       *
+       *  toupper() acts as if it returns ctype<char>:: do_toupper(__lo, __hi).
+       *  do_toupper() must always return the same result for the same input.
+       *
+       *  @param __lo  Pointer to first char in range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+
+      /**
+       *  @brief  Convert to lowercase.
+       *
+       *  This function converts the char argument to lowercase if possible.
+       *  If not possible (for example, '2'), returns the argument.
+       *
+       *  tolower() acts as if it returns ctype<char>::do_tolower(__c).
+       *  do_tolower() must always return the same result for the same input.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The lowercase char if convertible, else @a __c.
+      */
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+
+      /**
+       *  @brief  Convert array to lowercase.
+       *
+       *  This function converts each char in the range [lo,hi) to lowercase
+       *  if possible.  Other chars remain untouched.
+       *
+       *  tolower() acts as if it returns ctype<char>:: do_tolower(__lo, __hi).
+       *  do_tolower() must always return the same result for the same input.
+       *
+       *  @param __lo  Pointer to first char in range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+
+      /**
+       *  @brief  Widen char
+       *
+       *  This function converts the char to char_type using the simplest
+       *  reasonable transformation.  For an underived ctype<char> facet, the
+       *  argument will be returned unchanged.
+       *
+       *  This function works as if it returns ctype<char>::do_widen(c).
+       *  do_widen() must always return the same result for the same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The converted character.
+      */
+      char_type
+      widen(char __c) const
+      {
+	if (_M_widen_ok)
+	  return _M_widen[static_cast<unsigned char>(__c)];
+	this->_M_widen_init();
+	return this->do_widen(__c);
+      }
+
+      /**
+       *  @brief  Widen char array
+       *
+       *  This function converts each char in the input to char using the
+       *  simplest reasonable transformation.  For an underived ctype<char>
+       *  facet, the argument will be copied unchanged.
+       *
+       *  This function works as if it returns ctype<char>::do_widen(c).
+       *  do_widen() must always return the same result for the same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to first char in range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+	if (_M_widen_ok == 1)
+	  {
+	    __builtin_memcpy(__to, __lo, __hi - __lo);
+	    return __hi;
+	  }
+	if (!_M_widen_ok)
+	  _M_widen_init();
+	return this->do_widen(__lo, __hi, __to);
+      }
+
+      /**
+       *  @brief  Narrow char
+       *
+       *  This function converts the char to char using the simplest
+       *  reasonable transformation.  If the conversion fails, dfault is
+       *  returned instead.  For an underived ctype<char> facet, @a c
+       *  will be returned unchanged.
+       *
+       *  This function works as if it returns ctype<char>::do_narrow(c).
+       *  do_narrow() must always return the same result for the same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char to convert.
+       *  @param __dfault  Char to return if conversion fails.
+       *  @return  The converted character.
+      */
+      char
+      narrow(char_type __c, char __dfault) const
+      {
+	if (_M_narrow[static_cast<unsigned char>(__c)])
+	  return _M_narrow[static_cast<unsigned char>(__c)];
+	const char __t = do_narrow(__c, __dfault);
+	if (__t != __dfault)
+	  _M_narrow[static_cast<unsigned char>(__c)] = __t;
+	return __t;
+      }
+
+      /**
+       *  @brief  Narrow char array
+       *
+       *  This function converts each char in the input to char using the
+       *  simplest reasonable transformation and writes the results to the
+       *  destination array.  For any char in the input that cannot be
+       *  converted, @a dfault is used instead.  For an underived ctype<char>
+       *  facet, the argument will be copied unchanged.
+       *
+       *  This function works as if it returns ctype<char>::do_narrow(lo, hi,
+       *  dfault, to).  do_narrow() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __dfault  Char to use if conversion fails.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+	     char __dfault, char* __to) const
+      {
+	if (__builtin_expect(_M_narrow_ok == 1, true))
+	  {
+	    __builtin_memcpy(__to, __lo, __hi - __lo);
+	    return __hi;
+	  }
+	if (!_M_narrow_ok)
+	  _M_narrow_init();
+	return this->do_narrow(__lo, __hi, __dfault, __to);
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 695. ctype<char>::classic_table() not accessible.
+      /// Returns a pointer to the mask table provided to the constructor, or
+      /// the default from classic_table() if none was provided.
+      const mask*
+      table() const throw()
+      { return _M_table; }
+
+      /// Returns a pointer to the C locale mask table.
+      static const mask*
+      classic_table() throw();
+    protected:
+
+      /**
+       *  @brief  Destructor.
+       *
+       *  This function deletes table() if @a del was true in the
+       *  constructor.
+      */
+      virtual
+      ~ctype();
+
+      /**
+       *  @brief  Convert to uppercase.
+       *
+       *  This virtual function converts the char argument to uppercase if
+       *  possible.  If not possible (for example, '2'), returns the argument.
+       *
+       *  do_toupper() is a hook for a derived facet to change the behavior of
+       *  uppercasing.  do_toupper() must always return the same result for
+       *  the same input.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The uppercase char if convertible, else @a __c.
+      */
+      virtual char_type
+      do_toupper(char_type __c) const;
+
+      /**
+       *  @brief  Convert array to uppercase.
+       *
+       *  This virtual function converts each char in the range [lo,hi) to
+       *  uppercase if possible.  Other chars remain untouched.
+       *
+       *  do_toupper() is a hook for a derived facet to change the behavior of
+       *  uppercasing.  do_toupper() must always return the same result for
+       *  the same input.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+
+      /**
+       *  @brief  Convert to lowercase.
+       *
+       *  This virtual function converts the char argument to lowercase if
+       *  possible.  If not possible (for example, '2'), returns the argument.
+       *
+       *  do_tolower() is a hook for a derived facet to change the behavior of
+       *  lowercasing.  do_tolower() must always return the same result for
+       *  the same input.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The lowercase char if convertible, else @a __c.
+      */
+      virtual char_type
+      do_tolower(char_type __c) const;
+
+      /**
+       *  @brief  Convert array to lowercase.
+       *
+       *  This virtual function converts each char in the range [lo,hi) to
+       *  lowercase if possible.  Other chars remain untouched.
+       *
+       *  do_tolower() is a hook for a derived facet to change the behavior of
+       *  lowercasing.  do_tolower() must always return the same result for
+       *  the same input.
+       *
+       *  @param __lo  Pointer to first char in range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+
+      /**
+       *  @brief  Widen char
+       *
+       *  This virtual function converts the char to char using the simplest
+       *  reasonable transformation.  For an underived ctype<char> facet, the
+       *  argument will be returned unchanged.
+       *
+       *  do_widen() is a hook for a derived facet to change the behavior of
+       *  widening.  do_widen() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The converted character.
+      */
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+
+      /**
+       *  @brief  Widen char array
+       *
+       *  This function converts each char in the range [lo,hi) to char using
+       *  the simplest reasonable transformation.  For an underived
+       *  ctype<char> facet, the argument will be copied unchanged.
+       *
+       *  do_widen() is a hook for a derived facet to change the behavior of
+       *  widening.  do_widen() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+	__builtin_memcpy(__to, __lo, __hi - __lo);
+	return __hi;
+      }
+
+      /**
+       *  @brief  Narrow char
+       *
+       *  This virtual function converts the char to char using the simplest
+       *  reasonable transformation.  If the conversion fails, dfault is
+       *  returned instead.  For an underived ctype<char> facet, @a c will be
+       *  returned unchanged.
+       *
+       *  do_narrow() is a hook for a derived facet to change the behavior of
+       *  narrowing.  do_narrow() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char to convert.
+       *  @param __dfault  Char to return if conversion fails.
+       *  @return  The converted char.
+      */
+      virtual char
+      do_narrow(char_type __c, char __dfault) const
+      { return __c; }
+
+      /**
+       *  @brief  Narrow char array to char array
+       *
+       *  This virtual function converts each char in the range [lo,hi) to
+       *  char using the simplest reasonable transformation and writes the
+       *  results to the destination array.  For any char in the input that
+       *  cannot be converted, @a dfault is used instead.  For an underived
+       *  ctype<char> facet, the argument will be copied unchanged.
+       *
+       *  do_narrow() is a hook for a derived facet to change the behavior of
+       *  narrowing.  do_narrow() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __dfault  Char to use if conversion fails.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+		char __dfault, char* __to) const
+      {
+	__builtin_memcpy(__to, __lo, __hi - __lo);
+	return __hi;
+      }
+
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /**
+   *  @brief  The ctype<wchar_t> specialization.
+   *  @ingroup locales
+   *
+   *  This class defines classification and conversion functions for the
+   *  wchar_t type.  It gets used by wchar_t streams for many I/O operations.
+   *  The wchar_t specialization provides a number of optimizations as well.
+   *
+   *  ctype<wchar_t> inherits its public methods from
+   *  __ctype_abstract_base<wchar_t>.
+  */
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+      // Types:
+      /// Typedef for the template parameter wchar_t.
+      typedef wchar_t		char_type;
+      typedef wctype_t		__wmask_type;
+
+    protected:
+      __c_locale		_M_c_locale_ctype;
+
+      // Pre-computed narrowed and widened chars.
+      bool                      _M_narrow_ok;
+      char                      _M_narrow[128];
+      wint_t                    _M_widen[1 + static_cast<unsigned char>(-1)];
+
+      // Pre-computed elements for do_is.
+      mask                      _M_bit[16];
+      __wmask_type              _M_wmask[16];
+
+    public:
+      // Data Members:
+      /// The facet id for ctype<wchar_t>
+      static locale::id		id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      ctype(size_t __refs = 0);
+
+      /**
+       *  @brief  Constructor performs static initialization.
+       *
+       *  This constructor is used to construct the initial C locale facet.
+       *
+       *  @param __cloc  Handle to C locale data.
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+
+      /// Destructor
+      virtual
+      ~ctype();
+
+      /**
+       *  @brief  Test wchar_t classification.
+       *
+       *  This function finds a mask M for @a c and compares it to mask @a m.
+       *
+       *  do_is() is a hook for a derived facet to change the behavior of
+       *  classifying.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __c  The wchar_t to find the mask of.
+       *  @param __m  The mask to compare against.
+       *  @return  (M & __m) != 0.
+      */
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+
+      /**
+       *  @brief  Return a mask array.
+       *
+       *  This function finds the mask for each wchar_t in the range [lo,hi)
+       *  and successively writes it to vec.  vec must have as many elements
+       *  as the input.
+       *
+       *  do_is() is a hook for a derived facet to change the behavior of
+       *  classifying.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __vec  Pointer to an array of mask storage.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+
+      /**
+       *  @brief  Find wchar_t matching mask
+       *
+       *  This function searches for and returns the first wchar_t c in
+       *  [__lo,__hi) for which is(__m,c) is true.
+       *
+       *  do_scan_is() is a hook for a derived facet to change the behavior of
+       *  match searching.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to a matching wchar_t if found, else @a __hi.
+      */
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+
+      /**
+       *  @brief  Find wchar_t not matching mask
+       *
+       *  This function searches for and returns a pointer to the first
+       *  wchar_t c of [__lo,__hi) for which is(__m,c) is false.
+       *
+       *  do_scan_is() is a hook for a derived facet to change the behavior of
+       *  match searching.  do_is() must always return the same result for the
+       *  same input.
+       *
+       *  @param __m  The mask to compare against.
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  Pointer to a non-matching wchar_t if found, else @a __hi.
+      */
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+		  const char_type* __hi) const;
+
+      /**
+       *  @brief  Convert to uppercase.
+       *
+       *  This virtual function converts the wchar_t argument to uppercase if
+       *  possible.  If not possible (for example, '2'), returns the argument.
+       *
+       *  do_toupper() is a hook for a derived facet to change the behavior of
+       *  uppercasing.  do_toupper() must always return the same result for
+       *  the same input.
+       *
+       *  @param __c  The wchar_t to convert.
+       *  @return  The uppercase wchar_t if convertible, else @a __c.
+      */
+      virtual char_type
+      do_toupper(char_type __c) const;
+
+      /**
+       *  @brief  Convert array to uppercase.
+       *
+       *  This virtual function converts each wchar_t in the range [lo,hi) to
+       *  uppercase if possible.  Other elements remain untouched.
+       *
+       *  do_toupper() is a hook for a derived facet to change the behavior of
+       *  uppercasing.  do_toupper() must always return the same result for
+       *  the same input.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+
+      /**
+       *  @brief  Convert to lowercase.
+       *
+       *  This virtual function converts the argument to lowercase if
+       *  possible.  If not possible (for example, '2'), returns the argument.
+       *
+       *  do_tolower() is a hook for a derived facet to change the behavior of
+       *  lowercasing.  do_tolower() must always return the same result for
+       *  the same input.
+       *
+       *  @param __c  The wchar_t to convert.
+       *  @return  The lowercase wchar_t if convertible, else @a __c.
+      */
+      virtual char_type
+      do_tolower(char_type __c) const;
+
+      /**
+       *  @brief  Convert array to lowercase.
+       *
+       *  This virtual function converts each wchar_t in the range [lo,hi) to
+       *  lowercase if possible.  Other elements remain untouched.
+       *
+       *  do_tolower() is a hook for a derived facet to change the behavior of
+       *  lowercasing.  do_tolower() must always return the same result for
+       *  the same input.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+
+      /**
+       *  @brief  Widen char to wchar_t
+       *
+       *  This virtual function converts the char to wchar_t using the
+       *  simplest reasonable transformation.  For an underived ctype<wchar_t>
+       *  facet, the argument will be cast to wchar_t.
+       *
+       *  do_widen() is a hook for a derived facet to change the behavior of
+       *  widening.  do_widen() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The char to convert.
+       *  @return  The converted wchar_t.
+      */
+      virtual char_type
+      do_widen(char __c) const;
+
+      /**
+       *  @brief  Widen char array to wchar_t array
+       *
+       *  This function converts each char in the input to wchar_t using the
+       *  simplest reasonable transformation.  For an underived ctype<wchar_t>
+       *  facet, the argument will be copied, casting each element to wchar_t.
+       *
+       *  do_widen() is a hook for a derived facet to change the behavior of
+       *  widening.  do_widen() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
+
+      /**
+       *  @brief  Narrow wchar_t to char
+       *
+       *  This virtual function converts the argument to char using
+       *  the simplest reasonable transformation.  If the conversion
+       *  fails, dfault is returned instead.  For an underived
+       *  ctype<wchar_t> facet, @a c will be cast to char and
+       *  returned.
+       *
+       *  do_narrow() is a hook for a derived facet to change the
+       *  behavior of narrowing.  do_narrow() must always return the
+       *  same result for the same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __c  The wchar_t to convert.
+       *  @param __dfault  Char to return if conversion fails.
+       *  @return  The converted char.
+      */
+      virtual char
+      do_narrow(char_type __c, char __dfault) const;
+
+      /**
+       *  @brief  Narrow wchar_t array to char array
+       *
+       *  This virtual function converts each wchar_t in the range [lo,hi) to
+       *  char using the simplest reasonable transformation and writes the
+       *  results to the destination array.  For any wchar_t in the input that
+       *  cannot be converted, @a dfault is used instead.  For an underived
+       *  ctype<wchar_t> facet, the argument will be copied, casting each
+       *  element to char.
+       *
+       *  do_narrow() is a hook for a derived facet to change the behavior of
+       *  narrowing.  do_narrow() must always return the same result for the
+       *  same input.
+       *
+       *  Note: this is not what you want for codepage conversions.  See
+       *  codecvt for that.
+       *
+       *  @param __lo  Pointer to start of range.
+       *  @param __hi  Pointer to end of range.
+       *  @param __dfault  Char to use if conversion fails.
+       *  @param __to  Pointer to the destination array.
+       *  @return  @a __hi.
+      */
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+		char __dfault, char* __to) const;
+
+      // For use at construction time only.
+      void
+      _M_initialize_ctype() throw();
+    };
+#endif //_GLIBCXX_USE_WCHAR_T
+
+  /// class ctype_byname [22.2.1.2].
+  template<typename _CharT>
+    class ctype_byname : public ctype<_CharT>
+    {
+    public:
+      typedef typename ctype<_CharT>::mask  mask;
+
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~ctype_byname() { };
+    };
+
+  /// 22.2.1.4  Class ctype_byname specializations.
+  template<>
+    class ctype_byname<char> : public ctype<char>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    class ctype_byname<wchar_t> : public ctype<wchar_t>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+// Include host and configuration specific ctype inlines.
+#include <bits/ctype_inline.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 22.2.2  The numeric category.
+  class __num_base
+  {
+  public:
+    // NB: Code depends on the order of _S_atoms_out elements.
+    // Below are the indices into _S_atoms_out.
+    enum
+      {
+	_S_ominus,
+	_S_oplus,
+	_S_ox,
+	_S_oX,
+	_S_odigits,
+	_S_odigits_end = _S_odigits + 16,
+	_S_oudigits = _S_odigits_end,
+	_S_oudigits_end = _S_oudigits + 16,
+	_S_oe = _S_odigits + 14,  // For scientific notation, 'e'
+	_S_oE = _S_oudigits + 14, // For scientific notation, 'E'
+	_S_oend = _S_oudigits_end
+      };
+
+    // A list of valid numeric literals for output.  This array
+    // contains chars that will be passed through the current locale's
+    // ctype<_CharT>.widen() and then used to render numbers.
+    // For the standard "C" locale, this is
+    // "-+xX0123456789abcdef0123456789ABCDEF".
+    static const char* _S_atoms_out;
+
+    // String literal of acceptable (narrow) input, for num_get.
+    // "-+xX0123456789abcdefABCDEF"
+    static const char* _S_atoms_in;
+
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
+      _S_izero,
+      _S_ie = _S_izero + 14,
+      _S_iE = _S_izero + 20,
+      _S_iend = 26
+    };
+
+    // num_put
+    // Construct and return valid scanf format for floating point types.
+    static void
+    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
+  };
+
+  template<typename _CharT>
+    struct __numpunct_cache : public locale::facet
+    {
+      const char*			_M_grouping;
+      size_t                            _M_grouping_size;
+      bool				_M_use_grouping;
+      const _CharT*			_M_truename;
+      size_t                            _M_truename_size;
+      const _CharT*			_M_falsename;
+      size_t                            _M_falsename_size;
+      _CharT				_M_decimal_point;
+      _CharT				_M_thousands_sep;
+
+      // A list of valid numeric literals for output: in the standard
+      // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
+      // This array contains the chars after having been passed
+      // through the current locale's ctype<_CharT>.widen().
+      _CharT				_M_atoms_out[__num_base::_S_oend];
+
+      // A list of valid numeric literals for input: in the standard
+      // "C" locale, this is "-+xX0123456789abcdefABCDEF"
+      // This array contains the chars after having been passed
+      // through the current locale's ctype<_CharT>.widen().
+      _CharT				_M_atoms_in[__num_base::_S_iend];
+
+      bool				_M_allocated;
+
+      __numpunct_cache(size_t __refs = 0)
+      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
+	_M_use_grouping(false),
+	_M_truename(0), _M_truename_size(0), _M_falsename(0),
+	_M_falsename_size(0), _M_decimal_point(_CharT()),
+	_M_thousands_sep(_CharT()), _M_allocated(false)
+	{ }
+
+      ~__numpunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __numpunct_cache&
+      operator=(const __numpunct_cache&);
+
+      explicit
+      __numpunct_cache(const __numpunct_cache&);
+    };
+
+  template<typename _CharT>
+    __numpunct_cache<_CharT>::~__numpunct_cache()
+    {
+      if (_M_allocated)
+	{
+	  delete [] _M_grouping;
+	  delete [] _M_truename;
+	  delete [] _M_falsename;
+	}
+    }
+
+  /**
+   *  @brief  Primary class template numpunct.
+   *  @ingroup locales
+   *
+   *  This facet stores several pieces of information related to printing and
+   *  scanning numbers, such as the decimal point character.  It takes a
+   *  template parameter specifying the char type.  The numpunct facet is
+   *  used by streams for many I/O operations involving numbers.
+   *
+   *  The numpunct template uses protected virtual functions to provide the
+   *  actual results.  The public accessors forward the call to the virtual
+   *  functions.  These virtual functions are hooks for developers to
+   *  implement the behavior they require from a numpunct facet.
+  */
+  template<typename _CharT>
+    class numpunct : public locale::facet
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef basic_string<_CharT>	string_type;
+      //@}
+      typedef __numpunct_cache<_CharT>  __cache_type;
+
+    protected:
+      __cache_type*			_M_data;
+
+    public:
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Numpunct constructor.
+       *
+       *  @param  __refs  Refcount to pass to the base class.
+       */
+      explicit
+      numpunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(); }
+
+      /**
+       *  @brief  Internal constructor.  Not for general use.
+       *
+       *  This is a constructor for use by the library itself to set up the
+       *  predefined locale facets.
+       *
+       *  @param  __cache  __numpunct_cache object.
+       *  @param  __refs  Refcount to pass to the base class.
+       */
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+
+      /**
+       *  @brief  Internal constructor.  Not for general use.
+       *
+       *  This is a constructor for use by the library itself to set up new
+       *  locales.
+       *
+       *  @param  __cloc  The C locale.
+       *  @param  __refs  Refcount to pass to the base class.
+       */
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(__cloc); }
+
+      /**
+       *  @brief  Return decimal point character.
+       *
+       *  This function returns a char_type to use as a decimal point.  It
+       *  does so by returning returning
+       *  numpunct<char_type>::do_decimal_point().
+       *
+       *  @return  @a char_type representing a decimal point.
+      */
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+
+      /**
+       *  @brief  Return thousands separator character.
+       *
+       *  This function returns a char_type to use as a thousands
+       *  separator.  It does so by returning returning
+       *  numpunct<char_type>::do_thousands_sep().
+       *
+       *  @return  char_type representing a thousands separator.
+      */
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+
+      /**
+       *  @brief  Return grouping specification.
+       *
+       *  This function returns a string representing groupings for the
+       *  integer part of a number.  Groupings indicate where thousands
+       *  separators should be inserted in the integer part of a number.
+       *
+       *  Each char in the return string is interpret as an integer
+       *  rather than a character.  These numbers represent the number
+       *  of digits in a group.  The first char in the string
+       *  represents the number of digits in the least significant
+       *  group.  If a char is negative, it indicates an unlimited
+       *  number of digits for the group.  If more chars from the
+       *  string are required to group a number, the last char is used
+       *  repeatedly.
+       *
+       *  For example, if the grouping() returns "\003\002" and is
+       *  applied to the number 123456789, this corresponds to
+       *  12,34,56,789.  Note that if the string was "32", this would
+       *  put more than 50 digits into the least significant group if
+       *  the character set is ASCII.
+       *
+       *  The string is returned by calling
+       *  numpunct<char_type>::do_grouping().
+       *
+       *  @return  string representing grouping specification.
+      */
+      string
+      grouping() const
+      { return this->do_grouping(); }
+
+      /**
+       *  @brief  Return string representation of bool true.
+       *
+       *  This function returns a string_type containing the text
+       *  representation for true bool variables.  It does so by calling
+       *  numpunct<char_type>::do_truename().
+       *
+       *  @return  string_type representing printed form of true.
+      */
+      string_type
+      truename() const
+      { return this->do_truename(); }
+
+      /**
+       *  @brief  Return string representation of bool false.
+       *
+       *  This function returns a string_type containing the text
+       *  representation for false bool variables.  It does so by calling
+       *  numpunct<char_type>::do_falsename().
+       *
+       *  @return  string_type representing printed form of false.
+      */
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+
+    protected:
+      /// Destructor.
+      virtual
+      ~numpunct();
+
+      /**
+       *  @brief  Return decimal point character.
+       *
+       *  Returns a char_type to use as a decimal point.  This function is a
+       *  hook for derived classes to change the value returned.
+       *
+       *  @return  @a char_type representing a decimal point.
+      */
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+
+      /**
+       *  @brief  Return thousands separator character.
+       *
+       *  Returns a char_type to use as a thousands separator.  This function
+       *  is a hook for derived classes to change the value returned.
+       *
+       *  @return  @a char_type representing a thousands separator.
+      */
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+
+      /**
+       *  @brief  Return grouping specification.
+       *
+       *  Returns a string representing groupings for the integer part of a
+       *  number.  This function is a hook for derived classes to change the
+       *  value returned.  @see grouping() for details.
+       *
+       *  @return  String representing grouping specification.
+      */
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+
+      /**
+       *  @brief  Return string representation of bool true.
+       *
+       *  Returns a string_type containing the text representation for true
+       *  bool variables.  This function is a hook for derived classes to
+       *  change the value returned.
+       *
+       *  @return  string_type representing printed form of true.
+      */
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+
+      /**
+       *  @brief  Return string representation of bool false.
+       *
+       *  Returns a string_type containing the text representation for false
+       *  bool variables.  This function is a hook for derived classes to
+       *  change the value returned.
+       *
+       *  @return  string_type representing printed form of false.
+      */
+      virtual string_type
+      do_falsename() const
+      { return _M_data->_M_falsename; }
+
+      // For use at construction time only.
+      void
+      _M_initialize_numpunct(__c_locale __cloc = 0);
+    };
+
+  template<typename _CharT>
+    locale::id numpunct<_CharT>::id;
+
+  template<>
+    numpunct<char>::~numpunct();
+
+  template<>
+    void
+    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    numpunct<wchar_t>::~numpunct();
+
+  template<>
+    void
+    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
+#endif
+
+  /// class numpunct_byname [22.2.3.2].
+  template<typename _CharT>
+    class numpunct_byname : public numpunct<_CharT>
+    {
+    public:
+      typedef _CharT			char_type;
+      typedef basic_string<_CharT>	string_type;
+
+      explicit
+      numpunct_byname(const char* __s, size_t __refs = 0)
+      : numpunct<_CharT>(__refs)
+      {
+	if (__builtin_strcmp(__s, "C") != 0
+	    && __builtin_strcmp(__s, "POSIX") != 0)
+	  {
+	    __c_locale __tmp;
+	    this->_S_create_c_locale(__tmp, __s);
+	    this->_M_initialize_numpunct(__tmp);
+	    this->_S_destroy_c_locale(__tmp);
+	  }
+      }
+
+    protected:
+      virtual
+      ~numpunct_byname() { }
+    };
+
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
+
+  /**
+   *  @brief  Primary class template num_get.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the code to parse and return a number
+   *  from a string.  It is used by the istream numeric extraction
+   *  operators.
+   *
+   *  The num_get template uses protected virtual functions to provide the
+   *  actual results.  The public accessors forward the call to the virtual
+   *  functions.  These virtual functions are hooks for developers to
+   *  implement the behavior they require from the num_get facet.
+  */
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef _InIter			iter_type;
+      //@}
+
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+
+      /**
+       *  @brief  Numeric parsing.
+       *
+       *  Parses the input stream into the bool @a v.  It does so by calling
+       *  num_get::do_get().
+       *
+       *  If ios_base::boolalpha is set, attempts to read
+       *  ctype<CharT>::truename() or ctype<CharT>::falsename().  Sets
+       *  @a v to true or false if successful.  Sets err to
+       *  ios_base::failbit if reading the string fails.  Sets err to
+       *  ios_base::eofbit if the stream is emptied.
+       *
+       *  If ios_base::boolalpha is not set, proceeds as with reading a long,
+       *  except if the value is 1, sets @a v to true, if the value is 0, sets
+       *  @a v to false, and otherwise set err to ios_base::failbit.
+       *
+       *  @param  __in  Start of input stream.
+       *  @param  __end  End of input stream.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __err  Error flags to set.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after reading.
+      */
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      //@{
+      /**
+       *  @brief  Numeric parsing.
+       *
+       *  Parses the input stream into the integral variable @a v.  It does so
+       *  by calling num_get::do_get().
+       *
+       *  Parsing is affected by the flag settings in @a io.
+       *
+       *  The basic parse is affected by the value of io.flags() &
+       *  ios_base::basefield.  If equal to ios_base::oct, parses like the
+       *  scanf %o specifier.  Else if equal to ios_base::hex, parses like %X
+       *  specifier.  Else if basefield equal to 0, parses like the %i
+       *  specifier.  Otherwise, parses like %d for signed and %u for unsigned
+       *  types.  The matching type length modifier is also used.
+       *
+       *  Digit grouping is interpreted according to
+       *  numpunct::grouping() and numpunct::thousands_sep().  If the
+       *  pattern of digit groups isn't consistent, sets err to
+       *  ios_base::failbit.
+       *
+       *  If parsing the string yields a valid value for @a v, @a v is set.
+       *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
+       *  Sets err to ios_base::eofbit if the stream is emptied.
+       *
+       *  @param  __in  Start of input stream.
+       *  @param  __end  End of input stream.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __err  Error flags to set.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after reading.
+      */
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, unsigned int& __v)   const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, unsigned long& __v)  const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, unsigned long long& __v)  const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+#endif
+      //@}
+
+      //@{
+      /**
+       *  @brief  Numeric parsing.
+       *
+       *  Parses the input stream into the integral variable @a v.  It does so
+       *  by calling num_get::do_get().
+       *
+       *  The input characters are parsed like the scanf %g specifier.  The
+       *  matching type length modifier is also used.
+       *
+       *  The decimal point character used is numpunct::decimal_point().
+       *  Digit grouping is interpreted according to
+       *  numpunct::grouping() and numpunct::thousands_sep().  If the
+       *  pattern of digit groups isn't consistent, sets err to
+       *  ios_base::failbit.
+       *
+       *  If parsing the string yields a valid value for @a v, @a v is set.
+       *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
+       *  Sets err to ios_base::eofbit if the stream is emptied.
+       *
+       *  @param  __in  Start of input stream.
+       *  @param  __end  End of input stream.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __err  Error flags to set.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after reading.
+      */
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      //@}
+
+      /**
+       *  @brief  Numeric parsing.
+       *
+       *  Parses the input stream into the pointer variable @a v.  It does so
+       *  by calling num_get::do_get().
+       *
+       *  The input characters are parsed like the scanf %p specifier.
+       *
+       *  Digit grouping is interpreted according to
+       *  numpunct::grouping() and numpunct::thousands_sep().  If the
+       *  pattern of digit groups isn't consistent, sets err to
+       *  ios_base::failbit.
+       *
+       *  Note that the digit grouping effect for pointers is a bit ambiguous
+       *  in the standard and shouldn't be relied on.  See DR 344.
+       *
+       *  If parsing the string yields a valid value for @a v, @a v is set.
+       *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
+       *  Sets err to ios_base::eofbit if the stream is emptied.
+       *
+       *  @param  __in  Start of input stream.
+       *  @param  __end  End of input stream.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __err  Error flags to set.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after reading.
+      */
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+    protected:
+      /// Destructor.
+      virtual ~num_get() { }
+
+      iter_type
+      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+		       string&) const;
+
+      template<typename _ValueT>
+	iter_type
+	_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+		       _ValueT&) const;
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
+	_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
+	{
+	  int __ret = -1;
+	  if (__len <= 10)
+	    {
+	      if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
+		__ret = __c - _CharT2('0');
+	    }
+	  else
+	    {
+	      if (__c >= _CharT2('0') && __c <= _CharT2('9'))
+		__ret = __c - _CharT2('0');
+	      else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
+		__ret = 10 + (__c - _CharT2('a'));
+	      else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
+		__ret = 10 + (__c - _CharT2('A'));
+	    }
+	  return __ret;
+	}
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
+				      int>::__type
+	_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
+	{
+	  int __ret = -1;
+	  const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
+	  if (__q)
+	    {
+	      __ret = __q - __zero;
+	      if (__ret > 15)
+		__ret -= 6;
+	    }
+	  return __ret;
+	}
+
+      //@{
+      /**
+       *  @brief  Numeric parsing.
+       *
+       *  Parses the input stream into the variable @a v.  This function is a
+       *  hook for derived classes to change the value returned.  @see get()
+       *  for more details.
+       *
+       *  @param  __beg  Start of input stream.
+       *  @param  __end  End of input stream.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __err  Error flags to set.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after reading.
+      */
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	     ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	     ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	     ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	     ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	     ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	     ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+#endif
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+	     double&) const;
+
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      __do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+	       double&) const;
+#else
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+	     long double&) const;
+#endif
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
+
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+	     long double&) const;
+#endif
+      //@}
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+
+
+  /**
+   *  @brief  Primary class template num_put.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the code to convert a number to a string.  It is
+   *  used by the ostream numeric insertion operators.
+   *
+   *  The num_put template uses protected virtual functions to provide the
+   *  actual results.  The public accessors forward the call to the virtual
+   *  functions.  These virtual functions are hooks for developers to
+   *  implement the behavior they require from the num_put facet.
+  */
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT		char_type;
+      typedef _OutIter		iter_type;
+      //@}
+
+      /// Numpunct facet id.
+      static locale::id		id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+
+      /**
+       *  @brief  Numeric formatting.
+       *
+       *  Formats the boolean @a v and inserts it into a stream.  It does so
+       *  by calling num_put::do_put().
+       *
+       *  If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
+       *  ctype<CharT>::falsename().  Otherwise formats @a v as an int.
+       *
+       *  @param  __s  Stream to write to.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __fill  Char_type to use for filling.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after writing.
+      */
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      //@{
+      /**
+       *  @brief  Numeric formatting.
+       *
+       *  Formats the integral value @a v and inserts it into a
+       *  stream.  It does so by calling num_put::do_put().
+       *
+       *  Formatting is affected by the flag settings in @a io.
+       *
+       *  The basic format is affected by the value of io.flags() &
+       *  ios_base::basefield.  If equal to ios_base::oct, formats like the
+       *  printf %o specifier.  Else if equal to ios_base::hex, formats like
+       *  %x or %X with ios_base::uppercase unset or set respectively.
+       *  Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
+       *  for unsigned values.  Note that if both oct and hex are set, neither
+       *  will take effect.
+       *
+       *  If ios_base::showpos is set, '+' is output before positive values.
+       *  If ios_base::showbase is set, '0' precedes octal values (except 0)
+       *  and '0[xX]' precedes hex values.
+       *
+       *  The decimal point character used is numpunct::decimal_point().
+       *  Thousands separators are inserted according to
+       *  numpunct::grouping() and numpunct::thousands_sep().
+       *
+       *  If io.width() is non-zero, enough @a fill characters are inserted to
+       *  make the result at least that wide.  If
+       *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
+       *  padded at the end.  If ios_base::internal, then padding occurs
+       *  immediately after either a '+' or '-' or after '0x' or '0X'.
+       *  Otherwise, padding occurs at the beginning.
+       *
+       *  @param  __s  Stream to write to.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __fill  Char_type to use for filling.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after writing.
+      */
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+	  unsigned long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+	  unsigned long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+#endif
+      //@}
+
+      //@{
+      /**
+       *  @brief  Numeric formatting.
+       *
+       *  Formats the floating point value @a v and inserts it into a stream.
+       *  It does so by calling num_put::do_put().
+       *
+       *  Formatting is affected by the flag settings in @a io.
+       *
+       *  The basic format is affected by the value of io.flags() &
+       *  ios_base::floatfield.  If equal to ios_base::fixed, formats like the
+       *  printf %f specifier.  Else if equal to ios_base::scientific, formats
+       *  like %e or %E with ios_base::uppercase unset or set respectively.
+       *  Otherwise, formats like %g or %G depending on uppercase.  Note that
+       *  if both fixed and scientific are set, the effect will also be like
+       *  %g or %G.
+       *
+       *  The output precision is given by io.precision().  This precision is
+       *  capped at numeric_limits::digits10 + 2 (different for double and
+       *  long double).  The default precision is 6.
+       *
+       *  If ios_base::showpos is set, '+' is output before positive values.
+       *  If ios_base::showpoint is set, a decimal point will always be
+       *  output.
+       *
+       *  The decimal point character used is numpunct::decimal_point().
+       *  Thousands separators are inserted according to
+       *  numpunct::grouping() and numpunct::thousands_sep().
+       *
+       *  If io.width() is non-zero, enough @a fill characters are inserted to
+       *  make the result at least that wide.  If
+       *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
+       *  padded at the end.  If ios_base::internal, then padding occurs
+       *  immediately after either a '+' or '-' or after '0x' or '0X'.
+       *  Otherwise, padding occurs at the beginning.
+       *
+       *  @param  __s  Stream to write to.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __fill  Char_type to use for filling.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after writing.
+      */
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+	  long double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      //@}
+
+      /**
+       *  @brief  Numeric formatting.
+       *
+       *  Formats the pointer value @a v and inserts it into a stream.  It
+       *  does so by calling num_put::do_put().
+       *
+       *  This function formats @a v as an unsigned long with ios_base::hex
+       *  and ios_base::showbase set.
+       *
+       *  @param  __s  Stream to write to.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __fill  Char_type to use for filling.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after writing.
+      */
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+	  const void* __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+    protected:
+      template<typename _ValueT>
+	iter_type
+	_M_insert_float(iter_type, ios_base& __io, char_type __fill,
+			char __mod, _ValueT __v) const;
+
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+		     char_type __sep, const char_type* __p, char_type* __new,
+		     char_type* __cs, int& __len) const;
+
+      template<typename _ValueT>
+	iter_type
+	_M_insert_int(iter_type, ios_base& __io, char_type __fill,
+		      _ValueT __v) const;
+
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+		   char_type __sep, ios_base& __io, char_type* __new,
+		   char_type* __cs, int& __len) const;
+
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+	     char_type* __new, const char_type* __cs, int& __len) const;
+
+      /// Destructor.
+      virtual
+      ~num_put() { };
+
+      //@{
+      /**
+       *  @brief  Numeric formatting.
+       *
+       *  These functions do the work of formatting numeric values and
+       *  inserting them into a stream. This function is a hook for derived
+       *  classes to change the value returned.
+       *
+       *  @param  __s  Stream to write to.
+       *  @param  __io  Source of locale and flags.
+       *  @param  __fill  Char_type to use for filling.
+       *  @param  __v  Value to format and insert.
+       *  @return  Iterator after writing.
+      */
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+	     unsigned long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+	     long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+	     unsigned long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+#endif
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, double) const;
+
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      __do_put(iter_type, ios_base&, char_type, double) const;
+#else
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, long double) const;
+#endif
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, const void*) const;
+
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, long double) const;
+#endif
+      //@}
+    };
+
+  template <typename _CharT, typename _OutIter>
+    locale::id num_put<_CharT, _OutIter>::id;
+
+_GLIBCXX_END_NAMESPACE_LDBL
+
+  // Subclause convenience interfaces, inlines.
+  // NB: These are inline because, when used in a loop, some compilers
+  // can hoist the body out of the loop; then it's just as fast as the
+  // C is*() function.
+
+  /// Convenience interface to ctype.is(ctype_base::space, __c).
+  template<typename _CharT>
+    inline bool
+    isspace(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::print, __c).
+  template<typename _CharT>
+    inline bool
+    isprint(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::cntrl, __c).
+  template<typename _CharT>
+    inline bool
+    iscntrl(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::upper, __c).
+  template<typename _CharT>
+    inline bool
+    isupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::lower, __c).
+  template<typename _CharT>
+    inline bool
+    islower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::alpha, __c).
+  template<typename _CharT>
+    inline bool
+    isalpha(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::digit, __c).
+  template<typename _CharT>
+    inline bool
+    isdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::punct, __c).
+  template<typename _CharT>
+    inline bool
+    ispunct(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::xdigit, __c).
+  template<typename _CharT>
+    inline bool
+    isxdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::alnum, __c).
+  template<typename _CharT>
+    inline bool
+    isalnum(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
+
+  /// Convenience interface to ctype.is(ctype_base::graph, __c).
+  template<typename _CharT>
+    inline bool
+    isgraph(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
+
+  /// Convenience interface to ctype.toupper(__c).
+  template<typename _CharT>
+    inline _CharT
+    toupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
+
+  /// Convenience interface to ctype.tolower(__c).
+  template<typename _CharT>
+    inline _CharT
+    tolower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+# include <bits/locale_facets.tcc>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/locale_facets.tcc b/gcc-4.9/libstdc++-v3/include/bits/locale_facets.tcc
new file mode 100644
index 0000000..cf12a08
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/locale_facets.tcc
@@ -0,0 +1,1360 @@
+// Locale support -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/locale_facets.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+#ifndef _LOCALE_FACETS_TCC
+#define _LOCALE_FACETS_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Routine to access a cache for the facet.  If the cache didn't
+  // exist before, it gets constructed on the fly.
+  template<typename _Facet>
+    struct __use_cache
+    {
+      const _Facet*
+      operator() (const locale& __loc) const;
+    };
+
+  // Specializations.
+  template<typename _CharT>
+    struct __use_cache<__numpunct_cache<_CharT> >
+    {
+      const __numpunct_cache<_CharT>*
+      operator() (const locale& __loc) const
+      {
+	const size_t __i = numpunct<_CharT>::id._M_id();
+	const locale::facet** __caches = __loc._M_impl->_M_caches;
+	if (!__caches[__i])
+	  {
+	    __numpunct_cache<_CharT>* __tmp = 0;
+	    __try
+	      {
+		__tmp = new __numpunct_cache<_CharT>;
+		__tmp->_M_cache(__loc);
+	      }
+	    __catch(...)
+	      {
+		delete __tmp;
+		__throw_exception_again;
+	      }
+	    __loc._M_impl->_M_install_cache(__tmp, __i);
+	  }
+	return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT>
+    void
+    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
+    {
+      _M_allocated = true;
+
+      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+
+      char* __grouping = 0;
+      _CharT* __truename = 0;
+      _CharT* __falsename = 0;
+      __try
+	{
+	  _M_grouping_size = __np.grouping().size();
+	  __grouping = new char[_M_grouping_size];
+	  __np.grouping().copy(__grouping, _M_grouping_size);
+	  _M_grouping = __grouping;
+	  _M_use_grouping = (_M_grouping_size
+			     && static_cast<signed char>(_M_grouping[0]) > 0
+			     && (_M_grouping[0]
+				 != __gnu_cxx::__numeric_traits<char>::__max));
+
+	  _M_truename_size = __np.truename().size();
+	  __truename = new _CharT[_M_truename_size];
+	  __np.truename().copy(__truename, _M_truename_size);
+	  _M_truename = __truename;
+
+	  _M_falsename_size = __np.falsename().size();
+	  __falsename = new _CharT[_M_falsename_size];
+	  __np.falsename().copy(__falsename, _M_falsename_size);
+	  _M_falsename = __falsename;
+
+	  _M_decimal_point = __np.decimal_point();
+	  _M_thousands_sep = __np.thousands_sep();
+
+	  const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+	  __ct.widen(__num_base::_S_atoms_out,
+		     __num_base::_S_atoms_out
+		     + __num_base::_S_oend, _M_atoms_out);
+	  __ct.widen(__num_base::_S_atoms_in,
+		     __num_base::_S_atoms_in
+		     + __num_base::_S_iend, _M_atoms_in);
+	}
+      __catch(...)
+	{
+	  delete [] __grouping;
+	  delete [] __truename;
+	  delete [] __falsename;
+	  __throw_exception_again;
+	}
+    }
+
+  // Used by both numeric and monetary facets.
+  // Check to make sure that the __grouping_tmp string constructed in
+  // money_get or num_get matches the canonical grouping for a given
+  // locale.
+  // __grouping_tmp is parsed L to R
+  // 1,222,444 == __grouping_tmp of "\1\3\3"
+  // __grouping is parsed R to L
+  // 1,222,444 == __grouping of "\3" == "\3\3\3"
+  _GLIBCXX_PURE bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+		    const string& __grouping_tmp) throw ();
+
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
+		     ios_base::iostate& __err, string& __xtrc) const
+    {
+      typedef char_traits<_CharT>			__traits_type;
+      typedef __numpunct_cache<_CharT>                  __cache_type;
+      __use_cache<__cache_type> __uc;
+      const locale& __loc = __io._M_getloc();
+      const __cache_type* __lc = __uc(__loc);
+      const _CharT* __lit = __lc->_M_atoms_in;
+      char_type __c = char_type();
+
+      // True if __beg becomes equal to __end.
+      bool __testeof = __beg == __end;
+
+      // First check for sign.
+      if (!__testeof)
+	{
+	  __c = *__beg;
+	  const bool __plus = __c == __lit[__num_base::_S_iplus];
+	  if ((__plus || __c == __lit[__num_base::_S_iminus])
+	      && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+	      && !(__c == __lc->_M_decimal_point))
+	    {
+	      __xtrc += __plus ? '+' : '-';
+	      if (++__beg != __end)
+		__c = *__beg;
+	      else
+		__testeof = true;
+	    }
+	}
+
+      // Next, look for leading zeros.
+      bool __found_mantissa = false;
+      int __sep_pos = 0;
+      while (!__testeof)
+	{
+	  if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+	      || __c == __lc->_M_decimal_point)
+	    break;
+	  else if (__c == __lit[__num_base::_S_izero])
+	    {
+	      if (!__found_mantissa)
+		{
+		  __xtrc += '0';
+		  __found_mantissa = true;
+		}
+	      ++__sep_pos;
+
+	      if (++__beg != __end)
+		__c = *__beg;
+	      else
+		__testeof = true;
+	    }
+	  else
+	    break;
+	}
+
+      // Only need acceptable digits for floating point numbers.
+      bool __found_dec = false;
+      bool __found_sci = false;
+      string __found_grouping;
+      if (__lc->_M_use_grouping)
+	__found_grouping.reserve(32);
+      const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+      if (!__lc->_M_allocated)
+	// "C" locale
+	while (!__testeof)
+	  {
+	    const int __digit = _M_find(__lit_zero, 10, __c);
+	    if (__digit != -1)
+	      {
+		__xtrc += '0' + __digit;
+		__found_mantissa = true;
+	      }
+	    else if (__c == __lc->_M_decimal_point
+		     && !__found_dec && !__found_sci)
+	      {
+		__xtrc += '.';
+		__found_dec = true;
+	      }
+	    else if ((__c == __lit[__num_base::_S_ie] 
+		      || __c == __lit[__num_base::_S_iE])
+		     && !__found_sci && __found_mantissa)
+	      {
+		// Scientific notation.
+		__xtrc += 'e';
+		__found_sci = true;
+		
+		// Remove optional plus or minus sign, if they exist.
+		if (++__beg != __end)
+		  {
+		    __c = *__beg;
+		    const bool __plus = __c == __lit[__num_base::_S_iplus];
+		    if (__plus || __c == __lit[__num_base::_S_iminus])
+		      __xtrc += __plus ? '+' : '-';
+		    else
+		      continue;
+		  }
+		else
+		  {
+		    __testeof = true;
+		    break;
+		  }
+	      }
+	    else
+	      break;
+
+	    if (++__beg != __end)
+	      __c = *__beg;
+	    else
+	      __testeof = true;
+	  }
+      else
+	while (!__testeof)
+	  {
+	    // According to 22.2.2.1.2, p8-9, first look for thousands_sep
+	    // and decimal_point.
+	    if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+	      {
+		if (!__found_dec && !__found_sci)
+		  {
+		    // NB: Thousands separator at the beginning of a string
+		    // is a no-no, as is two consecutive thousands separators.
+		    if (__sep_pos)
+		      {
+			__found_grouping += static_cast<char>(__sep_pos);
+			__sep_pos = 0;
+		      }
+		    else
+		      {
+			// NB: __convert_to_v will not assign __v and will
+			// set the failbit.
+			__xtrc.clear();
+			break;
+		      }
+		  }
+		else
+		  break;
+	      }
+	    else if (__c == __lc->_M_decimal_point)
+	      {
+		if (!__found_dec && !__found_sci)
+		  {
+		    // If no grouping chars are seen, no grouping check
+		    // is applied. Therefore __found_grouping is adjusted
+		    // only if decimal_point comes after some thousands_sep.
+		    if (__found_grouping.size())
+		      __found_grouping += static_cast<char>(__sep_pos);
+		    __xtrc += '.';
+		    __found_dec = true;
+		  }
+		else
+		  break;
+	      }
+	    else
+	      {
+		const char_type* __q =
+		  __traits_type::find(__lit_zero, 10, __c);
+		if (__q)
+		  {
+		    __xtrc += '0' + (__q - __lit_zero);
+		    __found_mantissa = true;
+		    ++__sep_pos;
+		  }
+		else if ((__c == __lit[__num_base::_S_ie] 
+			  || __c == __lit[__num_base::_S_iE])
+			 && !__found_sci && __found_mantissa)
+		  {
+		    // Scientific notation.
+		    if (__found_grouping.size() && !__found_dec)
+		      __found_grouping += static_cast<char>(__sep_pos);
+		    __xtrc += 'e';
+		    __found_sci = true;
+		    
+		    // Remove optional plus or minus sign, if they exist.
+		    if (++__beg != __end)
+		      {
+			__c = *__beg;
+			const bool __plus = __c == __lit[__num_base::_S_iplus];
+			if ((__plus || __c == __lit[__num_base::_S_iminus])
+			    && !(__lc->_M_use_grouping
+				 && __c == __lc->_M_thousands_sep)
+			    && !(__c == __lc->_M_decimal_point))
+		      __xtrc += __plus ? '+' : '-';
+			else
+			  continue;
+		      }
+		    else
+		      {
+			__testeof = true;
+			break;
+		      }
+		  }
+		else
+		  break;
+	      }
+	    
+	    if (++__beg != __end)
+	      __c = *__beg;
+	    else
+	      __testeof = true;
+	  }
+
+      // Digit grouping is checked. If grouping and found_grouping don't
+      // match, then get very very upset, and set failbit.
+      if (__found_grouping.size())
+        {
+          // Add the ending grouping if a decimal or 'e'/'E' wasn't found.
+	  if (!__found_dec && !__found_sci)
+	    __found_grouping += static_cast<char>(__sep_pos);
+
+          if (!std::__verify_grouping(__lc->_M_grouping, 
+				      __lc->_M_grouping_size,
+				      __found_grouping))
+	    __err = ios_base::failbit;
+        }
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    template<typename _ValueT>
+      _InIter
+      num_get<_CharT, _InIter>::
+      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
+		     ios_base::iostate& __err, _ValueT& __v) const
+      {
+        typedef char_traits<_CharT>			     __traits_type;
+	using __gnu_cxx::__add_unsigned;
+	typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+	typedef __numpunct_cache<_CharT>                     __cache_type;
+	__use_cache<__cache_type> __uc;
+	const locale& __loc = __io._M_getloc();
+	const __cache_type* __lc = __uc(__loc);
+	const _CharT* __lit = __lc->_M_atoms_in;
+	char_type __c = char_type();
+
+	// NB: Iff __basefield == 0, __base can change based on contents.
+	const ios_base::fmtflags __basefield = __io.flags()
+	                                       & ios_base::basefield;
+	const bool __oct = __basefield == ios_base::oct;
+	int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
+
+	// True if __beg becomes equal to __end.
+	bool __testeof = __beg == __end;
+
+	// First check for sign.
+	bool __negative = false;
+	if (!__testeof)
+	  {
+	    __c = *__beg;
+	    __negative = __c == __lit[__num_base::_S_iminus];
+	    if ((__negative || __c == __lit[__num_base::_S_iplus])
+		&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+		&& !(__c == __lc->_M_decimal_point))
+	      {
+		if (++__beg != __end)
+		  __c = *__beg;
+		else
+		  __testeof = true;
+	      }
+	  }
+
+	// Next, look for leading zeros and check required digits
+	// for base formats.
+	bool __found_zero = false;
+	int __sep_pos = 0;
+	while (!__testeof)
+	  {
+	    if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+		|| __c == __lc->_M_decimal_point)
+	      break;
+	    else if (__c == __lit[__num_base::_S_izero] 
+		     && (!__found_zero || __base == 10))
+	      {
+		__found_zero = true;
+		++__sep_pos;
+		if (__basefield == 0)
+		  __base = 8;
+		if (__base == 8)
+		  __sep_pos = 0;
+	      }
+	    else if (__found_zero
+		     && (__c == __lit[__num_base::_S_ix]
+			 || __c == __lit[__num_base::_S_iX]))
+	      {
+		if (__basefield == 0)
+		  __base = 16;
+		if (__base == 16)
+		  {
+		    __found_zero = false;
+		    __sep_pos = 0;
+		  }
+		else
+		  break;
+	      }
+	    else
+	      break;
+
+	    if (++__beg != __end)
+	      {
+		__c = *__beg;
+		if (!__found_zero)
+		  break;
+	      }
+	    else
+	      __testeof = true;
+	  }
+	
+	// At this point, base is determined. If not hex, only allow
+	// base digits as valid input.
+	const size_t __len = (__base == 16 ? __num_base::_S_iend
+			      - __num_base::_S_izero : __base);
+
+	// Extract.
+	string __found_grouping;
+	if (__lc->_M_use_grouping)
+	  __found_grouping.reserve(32);
+	bool __testfail = false;
+	bool __testoverflow = false;
+	const __unsigned_type __max =
+	  (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+	  ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
+	  : __gnu_cxx::__numeric_traits<_ValueT>::__max;
+	const __unsigned_type __smax = __max / __base;
+	__unsigned_type __result = 0;
+	int __digit = 0;
+	const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+	if (!__lc->_M_allocated)
+	  // "C" locale
+	  while (!__testeof)
+	    {
+	      __digit = _M_find(__lit_zero, __len, __c);
+	      if (__digit == -1)
+		break;
+	      
+	      if (__result > __smax)
+		__testoverflow = true;
+	      else
+		{
+		  __result *= __base;
+		  __testoverflow |= __result > __max - __digit;
+		  __result += __digit;
+		  ++__sep_pos;
+		}
+	      
+	      if (++__beg != __end)
+		__c = *__beg;
+	      else
+		__testeof = true;
+	    }
+	else
+	  while (!__testeof)
+	    {
+	      // According to 22.2.2.1.2, p8-9, first look for thousands_sep
+	      // and decimal_point.
+	      if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+		{
+		  // NB: Thousands separator at the beginning of a string
+		  // is a no-no, as is two consecutive thousands separators.
+		  if (__sep_pos)
+		    {
+		      __found_grouping += static_cast<char>(__sep_pos);
+		      __sep_pos = 0;
+		    }
+		  else
+		    {
+		      __testfail = true;
+		      break;
+		    }
+		}
+	      else if (__c == __lc->_M_decimal_point)
+		break;
+	      else
+		{
+		  const char_type* __q =
+		    __traits_type::find(__lit_zero, __len, __c);
+		  if (!__q)
+		    break;
+		  
+		  __digit = __q - __lit_zero;
+		  if (__digit > 15)
+		    __digit -= 6;
+		  if (__result > __smax)
+		    __testoverflow = true;
+		  else
+		    {
+		      __result *= __base;
+		      __testoverflow |= __result > __max - __digit;
+		      __result += __digit;
+		      ++__sep_pos;
+		    }
+		}
+	      
+	      if (++__beg != __end)
+		__c = *__beg;
+	      else
+		__testeof = true;
+	    }
+	
+	// Digit grouping is checked. If grouping and found_grouping don't
+	// match, then get very very upset, and set failbit.
+	if (__found_grouping.size())
+	  {
+	    // Add the ending grouping.
+	    __found_grouping += static_cast<char>(__sep_pos);
+
+	    if (!std::__verify_grouping(__lc->_M_grouping,
+					__lc->_M_grouping_size,
+					__found_grouping))
+	      __err = ios_base::failbit;
+	  }
+
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 23. Num_get overflow result.
+	if ((!__sep_pos && !__found_zero && !__found_grouping.size())
+	    || __testfail)
+	  {
+	    __v = 0;
+	    __err = ios_base::failbit;
+	  }
+	else if (__testoverflow)
+	  {
+	    if (__negative
+		&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+	      __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
+	    else
+	      __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
+	    __err = ios_base::failbit;
+	  }
+	else
+	  __v = __negative ? -__result : __result;
+
+	if (__testeof)
+	  __err |= ios_base::eofbit;
+	return __beg;
+      }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 17.  Bad bool parsing
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+	  // Parse bool values as long.
+          // NB: We can't just call do_get(long) here, as it might
+          // refer to a derived class.
+	  long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+	  if (__l == 0 || __l == 1)
+	    __v = bool(__l);
+	  else
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 23. Num_get overflow result.
+	      __v = true;
+	      __err = ios_base::failbit;
+	      if (__beg == __end)
+		__err |= ios_base::eofbit;
+	    }
+        }
+      else
+        {
+	  // Parse bool values as alphanumeric.
+	  typedef __numpunct_cache<_CharT>  __cache_type;
+	  __use_cache<__cache_type> __uc;
+	  const locale& __loc = __io._M_getloc();
+	  const __cache_type* __lc = __uc(__loc);
+
+	  bool __testf = true;
+	  bool __testt = true;
+	  bool __donef = __lc->_M_falsename_size == 0;
+	  bool __donet = __lc->_M_truename_size == 0;
+	  bool __testeof = false;
+	  size_t __n = 0;
+	  while (!__donef || !__donet)
+	    {
+	      if (__beg == __end)
+		{
+		  __testeof = true;
+		  break;
+		}
+
+	      const char_type __c = *__beg;
+
+	      if (!__donef)
+		__testf = __c == __lc->_M_falsename[__n];
+
+	      if (!__testf && __donet)
+		break;
+
+	      if (!__donet)
+		__testt = __c == __lc->_M_truename[__n];
+
+	      if (!__testt && __donef)
+		break;
+
+	      if (!__testt && !__testf)
+		break;
+
+	      ++__n;
+	      ++__beg;
+
+	      __donef = !__testf || __n >= __lc->_M_falsename_size;
+	      __donet = !__testt || __n >= __lc->_M_truename_size;
+	    }
+	  if (__testf && __n == __lc->_M_falsename_size && __n)
+	    {
+	      __v = false;
+	      if (__testt && __n == __lc->_M_truename_size)
+		__err = ios_base::failbit;
+	      else
+		__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+	    }
+	  else if (__testt && __n == __lc->_M_truename_size && __n)
+	    {
+	      __v = true;
+	      __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+	    }
+	  else
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 23. Num_get overflow result.
+	      __v = false;
+	      __err = ios_base::failbit;
+	      if (__testeof)
+		__err |= ios_base::eofbit;
+	    }
+	}
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	   ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    __do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	     ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+#endif
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, long double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, void*& __v) const
+    {
+      // Prepare for hex formatted input.
+      typedef ios_base::fmtflags        fmtflags;
+      const fmtflags __fmt = __io.flags();
+      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
+					     <= sizeof(unsigned long)),
+	unsigned long, unsigned long long>::__type _UIntPtrType;       
+
+      _UIntPtrType __ul;
+      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
+
+      // Reset from hex formatted input.
+      __io.flags(__fmt);
+
+      __v = reinterpret_cast<void*>(__ul);
+      return __beg;
+    }
+
+  // For use by integer and floating-point types after they have been
+  // converted into a char_type string.
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
+	   _CharT* __new, const _CharT* __cs, int& __len) const
+    {
+      // [22.2.2.2.2] Stage 3.
+      // If necessary, pad.
+      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
+						  __cs, __w, __len);
+      __len = static_cast<int>(__w);
+    }
+
+_GLIBCXX_END_NAMESPACE_LDBL
+
+  template<typename _CharT, typename _ValueT>
+    int
+    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
+		  ios_base::fmtflags __flags, bool __dec)
+    {
+      _CharT* __buf = __bufend;
+      if (__builtin_expect(__dec, true))
+	{
+	  // Decimal.
+	  do
+	    {
+	      *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
+	      __v /= 10;
+	    }
+	  while (__v != 0);
+	}
+      else if ((__flags & ios_base::basefield) == ios_base::oct)
+	{
+	  // Octal.
+	  do
+	    {
+	      *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
+	      __v >>= 3;
+	    }
+	  while (__v != 0);
+	}
+      else
+	{
+	  // Hex.
+	  const bool __uppercase = __flags & ios_base::uppercase;
+	  const int __case_offset = __uppercase ? __num_base::_S_oudigits
+	                                        : __num_base::_S_odigits;
+	  do
+	    {
+	      *--__buf = __lit[(__v & 0xf) + __case_offset];
+	      __v >>= 4;
+	    }
+	  while (__v != 0);
+	}
+      return __bufend - __buf;
+    }
+
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
+		 ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
+    {
+      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
+					__grouping_size, __cs, __cs + __len);
+      __len = __p - __new;
+    }
+  
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
+		    _ValueT __v) const
+      {
+	using __gnu_cxx::__add_unsigned;
+	typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+	typedef __numpunct_cache<_CharT>	             __cache_type;
+	__use_cache<__cache_type> __uc;
+	const locale& __loc = __io._M_getloc();
+	const __cache_type* __lc = __uc(__loc);
+	const _CharT* __lit = __lc->_M_atoms_out;
+	const ios_base::fmtflags __flags = __io.flags();
+
+	// Long enough to hold hex, dec, and octal representations.
+	const int __ilen = 5 * sizeof(_ValueT);
+	_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+							     * __ilen));
+
+	// [22.2.2.2.2] Stage 1, numeric conversion to character.
+	// Result is returned right-justified in the buffer.
+	const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+	const bool __dec = (__basefield != ios_base::oct
+			    && __basefield != ios_base::hex);
+	const __unsigned_type __u = ((__v > 0 || !__dec)
+				     ? __unsigned_type(__v)
+				     : -__unsigned_type(__v));
+ 	int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
+	__cs += __ilen - __len;
+
+	// Add grouping, if necessary.
+	if (__lc->_M_use_grouping)
+	  {
+	    // Grouping can add (almost) as many separators as the number
+	    // of digits + space is reserved for numeric base or sign.
+	    _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+								  * (__len + 1)
+								  * 2));
+	    _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
+			 __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
+	    __cs = __cs2 + 2;
+	  }
+
+	// Complete Stage 1, prepend numeric base or sign.
+	if (__builtin_expect(__dec, true))
+	  {
+	    // Decimal.
+	    if (__v >= 0)
+	      {
+		if (bool(__flags & ios_base::showpos)
+		    && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+		  *--__cs = __lit[__num_base::_S_oplus], ++__len;
+	      }
+	    else
+	      *--__cs = __lit[__num_base::_S_ominus], ++__len;
+	  }
+	else if (bool(__flags & ios_base::showbase) && __v)
+	  {
+	    if (__basefield == ios_base::oct)
+	      *--__cs = __lit[__num_base::_S_odigits], ++__len;
+	    else
+	      {
+		// 'x' or 'X'
+		const bool __uppercase = __flags & ios_base::uppercase;
+		*--__cs = __lit[__num_base::_S_ox + __uppercase];
+		// '0'
+		*--__cs = __lit[__num_base::_S_odigits];
+		__len += 2;
+	      }
+	  }
+
+	// Pad.
+	const streamsize __w = __io.width();
+	if (__w > static_cast<streamsize>(__len))
+	  {
+	    _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+								  * __w));
+	    _M_pad(__fill, __w, __io, __cs3, __cs, __len);
+	    __cs = __cs3;
+	  }
+	__io.width(0);
+
+	// [22.2.2.2.2] Stage 4.
+	// Write resulting, fully-formatted string to output iterator.
+	return std::__write(__s, __cs, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_float(const char* __grouping, size_t __grouping_size,
+		   _CharT __sep, const _CharT* __p, _CharT* __new,
+		   _CharT* __cs, int& __len) const
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 282. What types does numpunct grouping refer to?
+      // Add grouping, if necessary.
+      const int __declen = __p ? __p - __cs : __len;
+      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
+					 __grouping_size,
+					 __cs, __cs + __declen);
+
+      // Tack on decimal part.
+      int __newlen = __p2 - __new;
+      if (__p)
+	{
+	  char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+	  __newlen += __len - __declen;
+	}
+      __len = __newlen;
+    }
+
+  // The following code uses vsnprintf (or vsprintf(), when
+  // _GLIBCXX_USE_C99 is not defined) to convert floating point values
+  // for insertion into a stream.  An optimization would be to replace
+  // them with code that works directly on a wide buffer and then use
+  // __pad to do the padding.  It would be good to replace them anyway
+  // to gain back the efficiency that C++ provides by knowing up front
+  // the type of the values to insert.  Also, sprintf is dangerous
+  // since may lead to accidental buffer overruns.  This
+  // implementation follows the C++ standard fairly directly as
+  // outlined in 22.2.2.2 [lib.locale.num.put]
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
+		       _ValueT __v) const
+      {
+	typedef __numpunct_cache<_CharT>                __cache_type;
+	__use_cache<__cache_type> __uc;
+	const locale& __loc = __io._M_getloc();
+	const __cache_type* __lc = __uc(__loc);
+
+	// Use default precision if out of range.
+	const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
+
+	const int __max_digits =
+	  __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
+
+	// [22.2.2.2.2] Stage 1, numeric conversion to character.
+	int __len;
+	// Long enough for the max format spec.
+	char __fbuf[16];
+	__num_base::_S_format_float(__io, __fbuf, __mod);
+
+#ifdef _GLIBCXX_USE_C99
+	// First try a buffer perhaps big enough (most probably sufficient
+	// for non-ios_base::fixed outputs)
+	int __cs_size = __max_digits * 3;
+	char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+	__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+				      __fbuf, __prec, __v);
+
+	// If the buffer was not large enough, try again with the correct size.
+	if (__len >= __cs_size)
+	  {
+	    __cs_size = __len + 1;
+	    __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+	    __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+					  __fbuf, __prec, __v);
+	  }
+#else
+	// Consider the possibility of long ios_base::fixed outputs
+	const bool __fixed = __io.flags() & ios_base::fixed;
+	const int __max_exp =
+	  __gnu_cxx::__numeric_traits<_ValueT>::__max_exponent10;
+
+	// The size of the output string is computed as follows.
+	// ios_base::fixed outputs may need up to __max_exp + 1 chars
+	// for the integer part + __prec chars for the fractional part
+	// + 3 chars for sign, decimal point, '\0'. On the other hand,
+	// for non-fixed outputs __max_digits * 2 + __prec chars are
+	// largely sufficient.
+	const int __cs_size = __fixed ? __max_exp + __prec + 4
+	                              : __max_digits * 2 + __prec;
+	char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+	__len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, __fbuf, 
+				      __prec, __v);
+#endif
+
+	// [22.2.2.2.2] Stage 2, convert to char_type, using correct
+	// numpunct.decimal_point() values for '.' and adding grouping.
+	const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+	
+	_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+							     * __len));
+	__ctype.widen(__cs, __cs + __len, __ws);
+	
+	// Replace decimal point.
+	_CharT* __wp = 0;
+	const char* __p = char_traits<char>::find(__cs, __len, '.');
+	if (__p)
+	  {
+	    __wp = __ws + (__p - __cs);
+	    *__wp = __lc->_M_decimal_point;
+	  }
+	
+	// Add grouping, if necessary.
+	// N.B. Make sure to not group things like 2e20, i.e., no decimal
+	// point, scientific notation.
+	if (__lc->_M_use_grouping
+	    && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
+				      && __cs[1] >= '0' && __cs[2] >= '0')))
+	  {
+	    // Grouping can add (almost) as many separators as the
+	    // number of digits, but no more.
+	    _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+								  * __len * 2));
+	    
+	    streamsize __off = 0;
+	    if (__cs[0] == '-' || __cs[0] == '+')
+	      {
+		__off = 1;
+		__ws2[0] = __ws[0];
+		__len -= 1;
+	      }
+	    
+	    _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
+			   __lc->_M_thousands_sep, __wp, __ws2 + __off,
+			   __ws + __off, __len);
+	    __len += __off;
+	    
+	    __ws = __ws2;
+	  }
+
+	// Pad.
+	const streamsize __w = __io.width();
+	if (__w > static_cast<streamsize>(__len))
+	  {
+	    _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+								  * __w));
+	    _M_pad(__fill, __w, __io, __ws3, __ws, __len);
+	    __ws = __ws3;
+	  }
+	__io.width(0);
+	
+	// [22.2.2.2.2] Stage 4.
+	// Write resulting, fully-formatted string to output iterator.
+	return std::__write(__s, __ws, __len);
+      }
+  
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+        {
+          const long __l = __v;
+          __s = _M_insert_int(__s, __io, __fill, __l);
+        }
+      else
+        {
+	  typedef __numpunct_cache<_CharT>              __cache_type;
+	  __use_cache<__cache_type> __uc;
+	  const locale& __loc = __io._M_getloc();
+	  const __cache_type* __lc = __uc(__loc);
+
+	  const _CharT* __name = __v ? __lc->_M_truename
+	                             : __lc->_M_falsename;
+	  int __len = __v ? __lc->_M_truename_size
+	                  : __lc->_M_falsename_size;
+
+	  const streamsize __w = __io.width();
+	  if (__w > static_cast<streamsize>(__len))
+	    {
+	      const streamsize __plen = __w - __len;
+	      _CharT* __ps
+		= static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+							* __plen));
+
+	      char_traits<_CharT>::assign(__ps, __plen, __fill);
+	      __io.width(0);
+
+	      if ((__flags & ios_base::adjustfield) == ios_base::left)
+		{
+		  __s = std::__write(__s, __name, __len);
+		  __s = std::__write(__s, __ps, __plen);
+		}
+	      else
+		{
+		  __s = std::__write(__s, __ps, __plen);
+		  __s = std::__write(__s, __name, __len);
+		}
+	      return __s;
+	    }
+	  __io.width(0);
+	  __s = std::__write(__s, __name, __len);
+	}
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    __do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+#endif
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+	   long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+					 | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+					     <= sizeof(unsigned long)),
+	unsigned long, unsigned long long>::__type _UIntPtrType;       
+
+      __s = _M_insert_int(__s, __io, __fill,
+			  reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+
+_GLIBCXX_END_NAMESPACE_LDBL
+
+  // Construct correctly padded string, as per 22.2.2.2.2
+  // Assumes
+  // __newlen > __oldlen
+  // __news is allocated for __newlen size
+
+  // NB: Of the two parameters, _CharT can be deduced from the
+  // function arguments. The other (_Traits) has to be explicitly specified.
+  template<typename _CharT, typename _Traits>
+    void
+    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+				   _CharT* __news, const _CharT* __olds,
+				   streamsize __newlen, streamsize __oldlen)
+    {
+      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
+
+      // Padding last.
+      if (__adjust == ios_base::left)
+	{
+	  _Traits::copy(__news, __olds, __oldlen);
+	  _Traits::assign(__news + __oldlen, __plen, __fill);
+	  return;
+	}
+
+      size_t __mod = 0;
+      if (__adjust == ios_base::internal)
+	{
+	  // Pad after the sign, if there is one.
+	  // Pad after 0[xX], if there is one.
+	  // Who came up with these rules, anyway? Jeeze.
+          const locale& __loc = __io._M_getloc();
+	  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+	  if (__ctype.widen('-') == __olds[0]
+	      || __ctype.widen('+') == __olds[0])
+	    {
+	      __news[0] = __olds[0];
+	      __mod = 1;
+	      ++__news;
+	    }
+	  else if (__ctype.widen('0') == __olds[0]
+		   && __oldlen > 1
+		   && (__ctype.widen('x') == __olds[1]
+		       || __ctype.widen('X') == __olds[1]))
+	    {
+	      __news[0] = __olds[0];
+	      __news[1] = __olds[1];
+	      __mod = 2;
+	      __news += 2;
+	    }
+	  // else Padding first.
+	}
+      _Traits::assign(__news, __plen, __fill);
+      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
+    }
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+		   const char* __gbeg, size_t __gsize,
+		   const _CharT* __first, const _CharT* __last)
+    {
+      size_t __idx = 0;
+      size_t __ctr = 0;
+
+      while (__last - __first > __gbeg[__idx]
+	     && static_cast<signed char>(__gbeg[__idx]) > 0
+	     && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
+	{
+	  __last -= __gbeg[__idx];
+	  __idx < __gsize - 1 ? ++__idx : ++__ctr;
+	}
+
+      while (__first != __last)
+	*__s++ = *__first++;
+
+      while (__ctr--)
+	{
+	  *__s++ = __sep;	  
+	  for (char __i = __gbeg[__idx]; __i > 0; --__i)
+	    *__s++ = *__first++;
+	}
+
+      while (__idx--)
+	{
+	  *__s++ = __sep;	  
+	  for (char __i = __gbeg[__idx]; __i > 0; --__i)
+	    *__s++ = *__first++;
+	}
+
+      return __s;
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class numpunct<char>;
+  extern template class numpunct_byname<char>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL num_get<char>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL num_put<char>;
+  extern template class ctype_byname<char>;
+
+  extern template
+    const ctype<char>&
+    use_facet<ctype<char> >(const locale&);
+
+  extern template
+    const numpunct<char>&
+    use_facet<numpunct<char> >(const locale&);
+
+  extern template
+    const num_put<char>&
+    use_facet<num_put<char> >(const locale&);
+
+  extern template
+    const num_get<char>&
+    use_facet<num_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<ctype<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<char> >(const locale&);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class numpunct<wchar_t>;
+  extern template class numpunct_byname<wchar_t>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL num_get<wchar_t>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL num_put<wchar_t>;
+  extern template class ctype_byname<wchar_t>;
+
+  extern template
+    const ctype<wchar_t>&
+    use_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    const numpunct<wchar_t>&
+    use_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    const num_put<wchar_t>&
+    use_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    const num_get<wchar_t>&
+    use_facet<num_get<wchar_t> >(const locale&);
+
+ extern template
+    bool
+    has_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<wchar_t> >(const locale&);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/locale_facets_nonio.h b/gcc-4.9/libstdc++-v3/include/bits/locale_facets_nonio.h
new file mode 100644
index 0000000..3e2cc7f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/locale_facets_nonio.h
@@ -0,0 +1,1905 @@
+// Locale support -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/locale_facets_nonio.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+//
+// ISO C++ 14882: 22.1  Locales
+//
+
+#ifndef _LOCALE_FACETS_NONIO_H
+#define _LOCALE_FACETS_NONIO_H 1
+
+#pragma GCC system_header
+
+#include <ctime>	// For struct tm
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Time format ordering data.
+   *  @ingroup locales
+   *
+   *  This class provides an enum representing different orderings of
+   *  time: day, month, and year.
+  */
+  class time_base
+  {
+  public:
+    enum dateorder { no_order, dmy, mdy, ymd, ydm };
+  };
+
+  template<typename _CharT>
+    struct __timepunct_cache : public locale::facet
+    {
+      // List of all known timezones, with GMT first.
+      static const _CharT*		_S_timezones[14];
+
+      const _CharT*			_M_date_format;
+      const _CharT*			_M_date_era_format;
+      const _CharT*			_M_time_format;
+      const _CharT*			_M_time_era_format;
+      const _CharT*			_M_date_time_format;
+      const _CharT*			_M_date_time_era_format;
+      const _CharT*			_M_am;
+      const _CharT*			_M_pm;
+      const _CharT*			_M_am_pm_format;
+
+      // Day names, starting with "C"'s Sunday.
+      const _CharT*			_M_day1;
+      const _CharT*			_M_day2;
+      const _CharT*			_M_day3;
+      const _CharT*			_M_day4;
+      const _CharT*			_M_day5;
+      const _CharT*			_M_day6;
+      const _CharT*			_M_day7;
+
+      // Abbreviated day names, starting with "C"'s Sun.
+      const _CharT*			_M_aday1;
+      const _CharT*			_M_aday2;
+      const _CharT*			_M_aday3;
+      const _CharT*			_M_aday4;
+      const _CharT*			_M_aday5;
+      const _CharT*			_M_aday6;
+      const _CharT*			_M_aday7;
+
+      // Month names, starting with "C"'s January.
+      const _CharT*			_M_month01;
+      const _CharT*			_M_month02;
+      const _CharT*			_M_month03;
+      const _CharT*			_M_month04;
+      const _CharT*			_M_month05;
+      const _CharT*			_M_month06;
+      const _CharT*			_M_month07;
+      const _CharT*			_M_month08;
+      const _CharT*			_M_month09;
+      const _CharT*			_M_month10;
+      const _CharT*			_M_month11;
+      const _CharT*			_M_month12;
+
+      // Abbreviated month names, starting with "C"'s Jan.
+      const _CharT*			_M_amonth01;
+      const _CharT*			_M_amonth02;
+      const _CharT*			_M_amonth03;
+      const _CharT*			_M_amonth04;
+      const _CharT*			_M_amonth05;
+      const _CharT*			_M_amonth06;
+      const _CharT*			_M_amonth07;
+      const _CharT*			_M_amonth08;
+      const _CharT*			_M_amonth09;
+      const _CharT*			_M_amonth10;
+      const _CharT*			_M_amonth11;
+      const _CharT*			_M_amonth12;
+
+      bool				_M_allocated;
+
+      __timepunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
+      _M_time_era_format(0), _M_date_time_format(0),
+      _M_date_time_era_format(0), _M_am(0), _M_pm(0),
+      _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
+      _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
+      _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
+      _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
+      _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
+      _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
+      _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
+      _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
+      _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
+      _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
+      _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
+      { }
+
+      ~__timepunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __timepunct_cache&
+      operator=(const __timepunct_cache&);
+      
+      explicit
+      __timepunct_cache(const __timepunct_cache&);
+    };
+
+  template<typename _CharT>
+    __timepunct_cache<_CharT>::~__timepunct_cache()
+    {
+      if (_M_allocated)
+	{
+	  // Unused.
+	}
+    }
+
+  // Specializations.
+  template<>
+    const char*
+    __timepunct_cache<char>::_S_timezones[14];
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    const wchar_t*
+    __timepunct_cache<wchar_t>::_S_timezones[14];
+#endif
+
+  // Generic.
+  template<typename _CharT>
+    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
+
+  template<typename _CharT>
+    class __timepunct : public locale::facet
+    {
+    public:
+      // Types:
+      typedef _CharT			__char_type;
+      typedef basic_string<_CharT>	__string_type;
+      typedef __timepunct_cache<_CharT>	__cache_type;
+
+    protected:
+      __cache_type*			_M_data;
+      __c_locale			_M_c_locale_timepunct;
+      const char*			_M_name_timepunct;
+
+    public:
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      explicit
+      __timepunct(size_t __refs = 0);
+
+      explicit
+      __timepunct(__cache_type* __cache, size_t __refs = 0);
+
+      /**
+       *  @brief  Internal constructor. Not for general use.
+       *
+       *  This is a constructor for use by the library itself to set up new
+       *  locales.
+       *
+       *  @param __cloc  The C locale.
+       *  @param __s  The name of a locale.
+       *  @param refs  Passed to the base facet class.
+      */
+      explicit
+      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
+
+      // FIXME: for error checking purposes _M_put should return the return
+      // value of strftime/wcsftime.
+      void
+      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
+	     const tm* __tm) const throw ();
+
+      void
+      _M_date_formats(const _CharT** __date) const
+      {
+	// Always have default first.
+	__date[0] = _M_data->_M_date_format;
+	__date[1] = _M_data->_M_date_era_format;
+      }
+
+      void
+      _M_time_formats(const _CharT** __time) const
+      {
+	// Always have default first.
+	__time[0] = _M_data->_M_time_format;
+	__time[1] = _M_data->_M_time_era_format;
+      }
+
+      void
+      _M_date_time_formats(const _CharT** __dt) const
+      {
+	// Always have default first.
+	__dt[0] = _M_data->_M_date_time_format;
+	__dt[1] = _M_data->_M_date_time_era_format;
+      }
+
+      void
+      _M_am_pm_format(const _CharT* __ampm) const
+      { __ampm = _M_data->_M_am_pm_format; }
+
+      void
+      _M_am_pm(const _CharT** __ampm) const
+      {
+	__ampm[0] = _M_data->_M_am;
+	__ampm[1] = _M_data->_M_pm;
+      }
+
+      void
+      _M_days(const _CharT** __days) const
+      {
+	__days[0] = _M_data->_M_day1;
+	__days[1] = _M_data->_M_day2;
+	__days[2] = _M_data->_M_day3;
+	__days[3] = _M_data->_M_day4;
+	__days[4] = _M_data->_M_day5;
+	__days[5] = _M_data->_M_day6;
+	__days[6] = _M_data->_M_day7;
+      }
+
+      void
+      _M_days_abbreviated(const _CharT** __days) const
+      {
+	__days[0] = _M_data->_M_aday1;
+	__days[1] = _M_data->_M_aday2;
+	__days[2] = _M_data->_M_aday3;
+	__days[3] = _M_data->_M_aday4;
+	__days[4] = _M_data->_M_aday5;
+	__days[5] = _M_data->_M_aday6;
+	__days[6] = _M_data->_M_aday7;
+      }
+
+      void
+      _M_months(const _CharT** __months) const
+      {
+	__months[0] = _M_data->_M_month01;
+	__months[1] = _M_data->_M_month02;
+	__months[2] = _M_data->_M_month03;
+	__months[3] = _M_data->_M_month04;
+	__months[4] = _M_data->_M_month05;
+	__months[5] = _M_data->_M_month06;
+	__months[6] = _M_data->_M_month07;
+	__months[7] = _M_data->_M_month08;
+	__months[8] = _M_data->_M_month09;
+	__months[9] = _M_data->_M_month10;
+	__months[10] = _M_data->_M_month11;
+	__months[11] = _M_data->_M_month12;
+      }
+
+      void
+      _M_months_abbreviated(const _CharT** __months) const
+      {
+	__months[0] = _M_data->_M_amonth01;
+	__months[1] = _M_data->_M_amonth02;
+	__months[2] = _M_data->_M_amonth03;
+	__months[3] = _M_data->_M_amonth04;
+	__months[4] = _M_data->_M_amonth05;
+	__months[5] = _M_data->_M_amonth06;
+	__months[6] = _M_data->_M_amonth07;
+	__months[7] = _M_data->_M_amonth08;
+	__months[8] = _M_data->_M_amonth09;
+	__months[9] = _M_data->_M_amonth10;
+	__months[10] = _M_data->_M_amonth11;
+	__months[11] = _M_data->_M_amonth12;
+      }
+
+    protected:
+      virtual
+      ~__timepunct();
+
+      // For use at construction time only.
+      void
+      _M_initialize_timepunct(__c_locale __cloc = 0);
+    };
+
+  template<typename _CharT>
+    locale::id __timepunct<_CharT>::id;
+
+  // Specializations.
+  template<>
+    void
+    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    void
+    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
+				 const tm*) const throw ();
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+  // Include host and configuration specific timepunct functions.
+  #include <bits/time_members.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Primary class template time_get.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the code to parse and return a date or
+   *  time from a string.  It is used by the istream numeric
+   *  extraction operators.
+   *
+   *  The time_get template uses protected virtual functions to provide the
+   *  actual results.  The public accessors forward the call to the virtual
+   *  functions.  These virtual functions are hooks for developers to
+   *  implement the behavior they require from the time_get facet.
+  */
+  template<typename _CharT, typename _InIter>
+    class time_get : public locale::facet, public time_base
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef _InIter			iter_type;
+      //@}
+      typedef basic_string<_CharT>	__string_type;
+
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      time_get(size_t __refs = 0)
+      : facet (__refs) { }
+
+      /**
+       *  @brief  Return preferred order of month, day, and year.
+       *
+       *  This function returns an enum from timebase::dateorder giving the
+       *  preferred ordering if the format @a x given to time_put::put() only
+       *  uses month, day, and year.  If the format @a x for the associated
+       *  locale uses other fields, this function returns
+       *  timebase::dateorder::noorder.
+       *
+       *  NOTE: The library always returns noorder at the moment.
+       *
+       *  @return  A member of timebase::dateorder.
+      */
+      dateorder
+      date_order()  const
+      { return this->do_date_order(); }
+
+      /**
+       *  @brief  Parse input time string.
+       *
+       *  This function parses a time according to the format @a X and puts the
+       *  results into a user-supplied struct tm.  The result is returned by
+       *  calling time_get::do_get_time().
+       *
+       *  If there is a valid time string according to format @a X, @a tm will
+       *  be filled in accordingly and the returned iterator will point to the
+       *  first character beyond the time string.  If an error occurs before
+       *  the end, err |= ios_base::failbit.  If parsing reads all the
+       *  characters, err |= ios_base::eofbit.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond time string.
+      */
+      iter_type
+      get_time(iter_type __beg, iter_type __end, ios_base& __io,
+	       ios_base::iostate& __err, tm* __tm)  const
+      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
+
+      /**
+       *  @brief  Parse input date string.
+       *
+       *  This function parses a date according to the format @a x and puts the
+       *  results into a user-supplied struct tm.  The result is returned by
+       *  calling time_get::do_get_date().
+       *
+       *  If there is a valid date string according to format @a x, @a tm will
+       *  be filled in accordingly and the returned iterator will point to the
+       *  first character beyond the date string.  If an error occurs before
+       *  the end, err |= ios_base::failbit.  If parsing reads all the
+       *  characters, err |= ios_base::eofbit.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond date string.
+      */
+      iter_type
+      get_date(iter_type __beg, iter_type __end, ios_base& __io,
+	       ios_base::iostate& __err, tm* __tm)  const
+      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
+
+      /**
+       *  @brief  Parse input weekday string.
+       *
+       *  This function parses a weekday name and puts the results into a
+       *  user-supplied struct tm.  The result is returned by calling
+       *  time_get::do_get_weekday().
+       *
+       *  Parsing starts by parsing an abbreviated weekday name.  If a valid
+       *  abbreviation is followed by a character that would lead to the full
+       *  weekday name, parsing continues until the full name is found or an
+       *  error occurs.  Otherwise parsing finishes at the end of the
+       *  abbreviated name.
+       *
+       *  If an error occurs before the end, err |= ios_base::failbit.  If
+       *  parsing reads all the characters, err |= ios_base::eofbit.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond weekday name.
+      */
+      iter_type
+      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+		  ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
+
+      /**
+       *  @brief  Parse input month string.
+       *
+       *  This function parses a month name and puts the results into a
+       *  user-supplied struct tm.  The result is returned by calling
+       *  time_get::do_get_monthname().
+       *
+       *  Parsing starts by parsing an abbreviated month name.  If a valid
+       *  abbreviation is followed by a character that would lead to the full
+       *  month name, parsing continues until the full name is found or an
+       *  error occurs.  Otherwise parsing finishes at the end of the
+       *  abbreviated name.
+       *
+       *  If an error occurs before the end, err |= ios_base::failbit.  If
+       *  parsing reads all the characters, err |=
+       *  ios_base::eofbit.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond month name.
+      */
+      iter_type
+      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
+		    ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
+
+      /**
+       *  @brief  Parse input year string.
+       *
+       *  This function reads up to 4 characters to parse a year string and
+       *  puts the results into a user-supplied struct tm.  The result is
+       *  returned by calling time_get::do_get_year().
+       *
+       *  4 consecutive digits are interpreted as a full year.  If there are
+       *  exactly 2 consecutive digits, the library interprets this as the
+       *  number of years since 1900.
+       *
+       *  If an error occurs before the end, err |= ios_base::failbit.  If
+       *  parsing reads all the characters, err |= ios_base::eofbit.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond year.
+      */
+      iter_type
+      get_year(iter_type __beg, iter_type __end, ios_base& __io,
+	       ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_year(__beg, __end, __io, __err, __tm); }
+
+    protected:
+      /// Destructor.
+      virtual
+      ~time_get() { }
+
+      /**
+       *  @brief  Return preferred order of month, day, and year.
+       *
+       *  This function returns an enum from timebase::dateorder giving the
+       *  preferred ordering if the format @a x given to time_put::put() only
+       *  uses month, day, and year.  This function is a hook for derived
+       *  classes to change the value returned.
+       *
+       *  @return  A member of timebase::dateorder.
+      */
+      virtual dateorder
+      do_date_order() const;
+
+      /**
+       *  @brief  Parse input time string.
+       *
+       *  This function parses a time according to the format @a x and puts the
+       *  results into a user-supplied struct tm.  This function is a hook for
+       *  derived classes to change the value returned.  @see get_time() for
+       *  details.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond time string.
+      */
+      virtual iter_type
+      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+		  ios_base::iostate& __err, tm* __tm) const;
+
+      /**
+       *  @brief  Parse input date string.
+       *
+       *  This function parses a date according to the format @a X and puts the
+       *  results into a user-supplied struct tm.  This function is a hook for
+       *  derived classes to change the value returned.  @see get_date() for
+       *  details.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond date string.
+      */
+      virtual iter_type
+      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+		  ios_base::iostate& __err, tm* __tm) const;
+
+      /**
+       *  @brief  Parse input weekday string.
+       *
+       *  This function parses a weekday name and puts the results into a
+       *  user-supplied struct tm.  This function is a hook for derived
+       *  classes to change the value returned.  @see get_weekday() for
+       *  details.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond weekday name.
+      */
+      virtual iter_type
+      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
+		     ios_base::iostate& __err, tm* __tm) const;
+
+      /**
+       *  @brief  Parse input month string.
+       *
+       *  This function parses a month name and puts the results into a
+       *  user-supplied struct tm.  This function is a hook for derived
+       *  classes to change the value returned.  @see get_monthname() for
+       *  details.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond month name.
+      */
+      virtual iter_type
+      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
+		       ios_base::iostate& __err, tm* __tm) const;
+
+      /**
+       *  @brief  Parse input year string.
+       *
+       *  This function reads up to 4 characters to parse a year string and
+       *  puts the results into a user-supplied struct tm.  This function is a
+       *  hook for derived classes to change the value returned.  @see
+       *  get_year() for details.
+       *
+       *  @param  __beg  Start of string to parse.
+       *  @param  __end  End of string to parse.
+       *  @param  __io  Source of the locale.
+       *  @param  __err  Error flags to set.
+       *  @param  __tm  Pointer to struct tm to fill in.
+       *  @return  Iterator to first char beyond year.
+      */
+      virtual iter_type
+      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+		  ios_base::iostate& __err, tm* __tm) const;
+
+      // Extract numeric component of length __len.
+      iter_type
+      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+		     int __min, int __max, size_t __len,
+		     ios_base& __io, ios_base::iostate& __err) const;
+
+      // Extract any unique array of string literals in a const _CharT* array.
+      iter_type
+      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+		      const _CharT** __names, size_t __indexlen,
+		      ios_base& __io, ios_base::iostate& __err) const;
+
+      // Extract day or month name in a const _CharT* array.
+      iter_type
+      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+			       const _CharT** __names, size_t __indexlen,
+			       ios_base& __io, ios_base::iostate& __err) const;
+
+      // Extract on a component-by-component basis, via __format argument.
+      iter_type
+      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+			    ios_base::iostate& __err, tm* __tm,
+			    const _CharT* __format) const;
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id time_get<_CharT, _InIter>::id;
+
+  /// class time_get_byname [22.2.5.2].
+  template<typename _CharT, typename _InIter>
+    class time_get_byname : public time_get<_CharT, _InIter>
+    {
+    public:
+      // Types:
+      typedef _CharT			char_type;
+      typedef _InIter			iter_type;
+
+      explicit
+      time_get_byname(const char*, size_t __refs = 0)
+      : time_get<_CharT, _InIter>(__refs) { }
+
+    protected:
+      virtual
+      ~time_get_byname() { }
+    };
+
+  /**
+   *  @brief  Primary class template time_put.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the code to format and output dates and times
+   *  according to formats used by strftime().
+   *
+   *  The time_put template uses protected virtual functions to provide the
+   *  actual results.  The public accessors forward the call to the virtual
+   *  functions.  These virtual functions are hooks for developers to
+   *  implement the behavior they require from the time_put facet.
+  */
+  template<typename _CharT, typename _OutIter>
+    class time_put : public locale::facet
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef _OutIter			iter_type;
+      //@}
+
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      time_put(size_t __refs = 0)
+      : facet(__refs) { }
+
+      /**
+       *  @brief  Format and output a time or date.
+       *
+       *  This function formats the data in struct tm according to the
+       *  provided format string.  The format string is interpreted as by
+       *  strftime().
+       *
+       *  @param  __s  The stream to write to.
+       *  @param  __io  Source of locale.
+       *  @param  __fill  char_type to use for padding.
+       *  @param  __tm  Struct tm with date and time info to format.
+       *  @param  __beg  Start of format string.
+       *  @param  __end  End of format string.
+       *  @return  Iterator after writing.
+       */
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+	  const _CharT* __beg, const _CharT* __end) const;
+
+      /**
+       *  @brief  Format and output a time or date.
+       *
+       *  This function formats the data in struct tm according to the
+       *  provided format char and optional modifier.  The format and modifier
+       *  are interpreted as by strftime().  It does so by returning
+       *  time_put::do_put().
+       *
+       *  @param  __s  The stream to write to.
+       *  @param  __io  Source of locale.
+       *  @param  __fill  char_type to use for padding.
+       *  @param  __tm  Struct tm with date and time info to format.
+       *  @param  __format  Format char.
+       *  @param  __mod  Optional modifier char.
+       *  @return  Iterator after writing.
+       */
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+	  const tm* __tm, char __format, char __mod = 0) const
+      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
+
+    protected:
+      /// Destructor.
+      virtual
+      ~time_put()
+      { }
+
+      /**
+       *  @brief  Format and output a time or date.
+       *
+       *  This function formats the data in struct tm according to the
+       *  provided format char and optional modifier.  This function is a hook
+       *  for derived classes to change the value returned.  @see put() for
+       *  more details.
+       *
+       *  @param  __s  The stream to write to.
+       *  @param  __io  Source of locale.
+       *  @param  __fill  char_type to use for padding.
+       *  @param  __tm  Struct tm with date and time info to format.
+       *  @param  __format  Format char.
+       *  @param  __mod  Optional modifier char.
+       *  @return  Iterator after writing.
+       */
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+	     char __format, char __mod) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id time_put<_CharT, _OutIter>::id;
+
+  /// class time_put_byname [22.2.5.4].
+  template<typename _CharT, typename _OutIter>
+    class time_put_byname : public time_put<_CharT, _OutIter>
+    {
+    public:
+      // Types:
+      typedef _CharT			char_type;
+      typedef _OutIter			iter_type;
+
+      explicit
+      time_put_byname(const char*, size_t __refs = 0)
+      : time_put<_CharT, _OutIter>(__refs)
+      { };
+
+    protected:
+      virtual
+      ~time_put_byname() { }
+    };
+
+
+  /**
+   *  @brief  Money format ordering data.
+   *  @ingroup locales
+   *
+   *  This class contains an ordered array of 4 fields to represent the
+   *  pattern for formatting a money amount.  Each field may contain one entry
+   *  from the part enum.  symbol, sign, and value must be present and the
+   *  remaining field must contain either none or space.  @see
+   *  moneypunct::pos_format() and moneypunct::neg_format() for details of how
+   *  these fields are interpreted.
+  */
+  class money_base
+  {
+  public:
+    enum part { none, space, symbol, sign, value };
+    struct pattern { char field[4]; };
+
+    static const pattern _S_default_pattern;
+
+    enum
+    {
+      _S_minus,
+      _S_zero,
+      _S_end = 11
+    };
+
+    // String literal of acceptable (narrow) input/output, for
+    // money_get/money_put. "-0123456789"
+    static const char* _S_atoms;
+
+    // Construct and return valid pattern consisting of some combination of:
+    // space none symbol sign value
+    _GLIBCXX_CONST static pattern
+    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
+  };
+
+  template<typename _CharT, bool _Intl>
+    struct __moneypunct_cache : public locale::facet
+    {
+      const char*			_M_grouping;
+      size_t                            _M_grouping_size;
+      bool				_M_use_grouping;
+      _CharT				_M_decimal_point;
+      _CharT				_M_thousands_sep;
+      const _CharT*			_M_curr_symbol;
+      size_t                            _M_curr_symbol_size;
+      const _CharT*			_M_positive_sign;
+      size_t                            _M_positive_sign_size;
+      const _CharT*			_M_negative_sign;
+      size_t                            _M_negative_sign_size;
+      int				_M_frac_digits;
+      money_base::pattern		_M_pos_format;
+      money_base::pattern	        _M_neg_format;
+
+      // A list of valid numeric literals for input and output: in the standard
+      // "C" locale, this is "-0123456789". This array contains the chars after
+      // having been passed through the current locale's ctype<_CharT>.widen().
+      _CharT				_M_atoms[money_base::_S_end];
+
+      bool				_M_allocated;
+
+      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
+      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
+      _M_curr_symbol(0), _M_curr_symbol_size(0),
+      _M_positive_sign(0), _M_positive_sign_size(0),
+      _M_negative_sign(0), _M_negative_sign_size(0),
+      _M_frac_digits(0),
+      _M_pos_format(money_base::pattern()),
+      _M_neg_format(money_base::pattern()), _M_allocated(false)
+      { }
+
+      ~__moneypunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __moneypunct_cache&
+      operator=(const __moneypunct_cache&);
+      
+      explicit
+      __moneypunct_cache(const __moneypunct_cache&);
+    };
+
+  template<typename _CharT, bool _Intl>
+    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
+    {
+      if (_M_allocated)
+	{
+	  delete [] _M_grouping;
+	  delete [] _M_curr_symbol;
+	  delete [] _M_positive_sign;
+	  delete [] _M_negative_sign;
+	}
+    }
+
+  /**
+   *  @brief  Primary class template moneypunct.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the punctuation, grouping and other formatting
+   *  features of money amount string representations.
+  */
+  template<typename _CharT, bool _Intl>
+    class moneypunct : public locale::facet, public money_base
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef basic_string<_CharT>	string_type;
+      //@}
+      typedef __moneypunct_cache<_CharT, _Intl>     __cache_type;
+
+    private:
+      __cache_type*			_M_data;
+
+    public:
+      /// This value is provided by the standard, but no reason for its
+      /// existence.
+      static const bool			intl = _Intl;
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      moneypunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(); }
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is an internal constructor.
+       *
+       *  @param __cache  Cache for optimization.
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      moneypunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_moneypunct(); }
+
+      /**
+       *  @brief  Internal constructor. Not for general use.
+       *
+       *  This is a constructor for use by the library itself to set up new
+       *  locales.
+       *
+       *  @param __cloc  The C locale.
+       *  @param __s  The name of a locale.
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(__cloc, __s); }
+
+      /**
+       *  @brief  Return decimal point character.
+       *
+       *  This function returns a char_type to use as a decimal point.  It
+       *  does so by returning returning
+       *  moneypunct<char_type>::do_decimal_point().
+       *
+       *  @return  @a char_type representing a decimal point.
+      */
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+
+      /**
+       *  @brief  Return thousands separator character.
+       *
+       *  This function returns a char_type to use as a thousands
+       *  separator.  It does so by returning returning
+       *  moneypunct<char_type>::do_thousands_sep().
+       *
+       *  @return  char_type representing a thousands separator.
+      */
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+
+      /**
+       *  @brief  Return grouping specification.
+       *
+       *  This function returns a string representing groupings for the
+       *  integer part of an amount.  Groupings indicate where thousands
+       *  separators should be inserted.
+       *
+       *  Each char in the return string is interpret as an integer rather
+       *  than a character.  These numbers represent the number of digits in a
+       *  group.  The first char in the string represents the number of digits
+       *  in the least significant group.  If a char is negative, it indicates
+       *  an unlimited number of digits for the group.  If more chars from the
+       *  string are required to group a number, the last char is used
+       *  repeatedly.
+       *
+       *  For example, if the grouping() returns <code>\003\002</code>
+       *  and is applied to the number 123456789, this corresponds to
+       *  12,34,56,789.  Note that if the string was <code>32</code>, this would
+       *  put more than 50 digits into the least significant group if
+       *  the character set is ASCII.
+       *
+       *  The string is returned by calling
+       *  moneypunct<char_type>::do_grouping().
+       *
+       *  @return  string representing grouping specification.
+      */
+      string
+      grouping() const
+      { return this->do_grouping(); }
+
+      /**
+       *  @brief  Return currency symbol string.
+       *
+       *  This function returns a string_type to use as a currency symbol.  It
+       *  does so by returning returning
+       *  moneypunct<char_type>::do_curr_symbol().
+       *
+       *  @return  @a string_type representing a currency symbol.
+      */
+      string_type
+      curr_symbol() const
+      { return this->do_curr_symbol(); }
+
+      /**
+       *  @brief  Return positive sign string.
+       *
+       *  This function returns a string_type to use as a sign for positive
+       *  amounts.  It does so by returning returning
+       *  moneypunct<char_type>::do_positive_sign().
+       *
+       *  If the return value contains more than one character, the first
+       *  character appears in the position indicated by pos_format() and the
+       *  remainder appear at the end of the formatted string.
+       *
+       *  @return  @a string_type representing a positive sign.
+      */
+      string_type
+      positive_sign() const
+      { return this->do_positive_sign(); }
+
+      /**
+       *  @brief  Return negative sign string.
+       *
+       *  This function returns a string_type to use as a sign for negative
+       *  amounts.  It does so by returning returning
+       *  moneypunct<char_type>::do_negative_sign().
+       *
+       *  If the return value contains more than one character, the first
+       *  character appears in the position indicated by neg_format() and the
+       *  remainder appear at the end of the formatted string.
+       *
+       *  @return  @a string_type representing a negative sign.
+      */
+      string_type
+      negative_sign() const
+      { return this->do_negative_sign(); }
+
+      /**
+       *  @brief  Return number of digits in fraction.
+       *
+       *  This function returns the exact number of digits that make up the
+       *  fractional part of a money amount.  It does so by returning
+       *  returning moneypunct<char_type>::do_frac_digits().
+       *
+       *  The fractional part of a money amount is optional.  But if it is
+       *  present, there must be frac_digits() digits.
+       *
+       *  @return  Number of digits in amount fraction.
+      */
+      int
+      frac_digits() const
+      { return this->do_frac_digits(); }
+
+      //@{
+      /**
+       *  @brief  Return pattern for money values.
+       *
+       *  This function returns a pattern describing the formatting of a
+       *  positive or negative valued money amount.  It does so by returning
+       *  returning moneypunct<char_type>::do_pos_format() or
+       *  moneypunct<char_type>::do_neg_format().
+       *
+       *  The pattern has 4 fields describing the ordering of symbol, sign,
+       *  value, and none or space.  There must be one of each in the pattern.
+       *  The none and space enums may not appear in the first field and space
+       *  may not appear in the final field.
+       *
+       *  The parts of a money string must appear in the order indicated by
+       *  the fields of the pattern.  The symbol field indicates that the
+       *  value of curr_symbol() may be present.  The sign field indicates
+       *  that the value of positive_sign() or negative_sign() must be
+       *  present.  The value field indicates that the absolute value of the
+       *  money amount is present.  none indicates 0 or more whitespace
+       *  characters, except at the end, where it permits no whitespace.
+       *  space indicates that 1 or more whitespace characters must be
+       *  present.
+       *
+       *  For example, for the US locale and pos_format() pattern
+       *  {symbol,sign,value,none}, curr_symbol() == &apos;$&apos;
+       *  positive_sign() == &apos;+&apos;, and value 10.01, and
+       *  options set to force the symbol, the corresponding string is
+       *  <code>$+10.01</code>.
+       *
+       *  @return  Pattern for money values.
+      */
+      pattern
+      pos_format() const
+      { return this->do_pos_format(); }
+
+      pattern
+      neg_format() const
+      { return this->do_neg_format(); }
+      //@}
+
+    protected:
+      /// Destructor.
+      virtual
+      ~moneypunct();
+
+      /**
+       *  @brief  Return decimal point character.
+       *
+       *  Returns a char_type to use as a decimal point.  This function is a
+       *  hook for derived classes to change the value returned.
+       *
+       *  @return  @a char_type representing a decimal point.
+      */
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+
+      /**
+       *  @brief  Return thousands separator character.
+       *
+       *  Returns a char_type to use as a thousands separator.  This function
+       *  is a hook for derived classes to change the value returned.
+       *
+       *  @return  @a char_type representing a thousands separator.
+      */
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+
+      /**
+       *  @brief  Return grouping specification.
+       *
+       *  Returns a string representing groupings for the integer part of a
+       *  number.  This function is a hook for derived classes to change the
+       *  value returned.  @see grouping() for details.
+       *
+       *  @return  String representing grouping specification.
+      */
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+
+      /**
+       *  @brief  Return currency symbol string.
+       *
+       *  This function returns a string_type to use as a currency symbol.
+       *  This function is a hook for derived classes to change the value
+       *  returned.  @see curr_symbol() for details.
+       *
+       *  @return  @a string_type representing a currency symbol.
+      */
+      virtual string_type
+      do_curr_symbol()   const
+      { return _M_data->_M_curr_symbol; }
+
+      /**
+       *  @brief  Return positive sign string.
+       *
+       *  This function returns a string_type to use as a sign for positive
+       *  amounts.  This function is a hook for derived classes to change the
+       *  value returned.  @see positive_sign() for details.
+       *
+       *  @return  @a string_type representing a positive sign.
+      */
+      virtual string_type
+      do_positive_sign() const
+      { return _M_data->_M_positive_sign; }
+
+      /**
+       *  @brief  Return negative sign string.
+       *
+       *  This function returns a string_type to use as a sign for negative
+       *  amounts.  This function is a hook for derived classes to change the
+       *  value returned.  @see negative_sign() for details.
+       *
+       *  @return  @a string_type representing a negative sign.
+      */
+      virtual string_type
+      do_negative_sign() const
+      { return _M_data->_M_negative_sign; }
+
+      /**
+       *  @brief  Return number of digits in fraction.
+       *
+       *  This function returns the exact number of digits that make up the
+       *  fractional part of a money amount.  This function is a hook for
+       *  derived classes to change the value returned.  @see frac_digits()
+       *  for details.
+       *
+       *  @return  Number of digits in amount fraction.
+      */
+      virtual int
+      do_frac_digits() const
+      { return _M_data->_M_frac_digits; }
+
+      /**
+       *  @brief  Return pattern for money values.
+       *
+       *  This function returns a pattern describing the formatting of a
+       *  positive valued money amount.  This function is a hook for derived
+       *  classes to change the value returned.  @see pos_format() for
+       *  details.
+       *
+       *  @return  Pattern for money values.
+      */
+      virtual pattern
+      do_pos_format() const
+      { return _M_data->_M_pos_format; }
+
+      /**
+       *  @brief  Return pattern for money values.
+       *
+       *  This function returns a pattern describing the formatting of a
+       *  negative valued money amount.  This function is a hook for derived
+       *  classes to change the value returned.  @see neg_format() for
+       *  details.
+       *
+       *  @return  Pattern for money values.
+      */
+      virtual pattern
+      do_neg_format() const
+      { return _M_data->_M_neg_format; }
+
+      // For use at construction time only.
+       void
+       _M_initialize_moneypunct(__c_locale __cloc = 0,
+				const char* __name = 0);
+    };
+
+  template<typename _CharT, bool _Intl>
+    locale::id moneypunct<_CharT, _Intl>::id;
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct<_CharT, _Intl>::intl;
+
+  template<>
+    moneypunct<char, true>::~moneypunct();
+
+  template<>
+    moneypunct<char, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
+
+  template<>
+    void
+    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    moneypunct<wchar_t, true>::~moneypunct();
+
+  template<>
+    moneypunct<wchar_t, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
+							const char*);
+
+  template<>
+    void
+    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
+							 const char*);
+#endif
+
+  /// class moneypunct_byname [22.2.6.4].
+  template<typename _CharT, bool _Intl>
+    class moneypunct_byname : public moneypunct<_CharT, _Intl>
+    {
+    public:
+      typedef _CharT			char_type;
+      typedef basic_string<_CharT>	string_type;
+
+      static const bool intl = _Intl;
+
+      explicit
+      moneypunct_byname(const char* __s, size_t __refs = 0)
+      : moneypunct<_CharT, _Intl>(__refs)
+      {
+	if (__builtin_strcmp(__s, "C") != 0
+	    && __builtin_strcmp(__s, "POSIX") != 0)
+	  {
+	    __c_locale __tmp;
+	    this->_S_create_c_locale(__tmp, __s);
+	    this->_M_initialize_moneypunct(__tmp);
+	    this->_S_destroy_c_locale(__tmp);
+	  }
+      }
+
+    protected:
+      virtual
+      ~moneypunct_byname() { }
+    };
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct_byname<_CharT, _Intl>::intl;
+
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
+
+  /**
+   *  @brief  Primary class template money_get.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the code to parse and return a monetary
+   *  amount from a string.
+   *
+   *  The money_get template uses protected virtual functions to
+   *  provide the actual results.  The public accessors forward the
+   *  call to the virtual functions.  These virtual functions are
+   *  hooks for developers to implement the behavior they require from
+   *  the money_get facet.
+  */
+  template<typename _CharT, typename _InIter>
+    class money_get : public locale::facet
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef _InIter			iter_type;
+      typedef basic_string<_CharT>	string_type;
+      //@}
+
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      money_get(size_t __refs = 0) : facet(__refs) { }
+
+      /**
+       *  @brief  Read and parse a monetary value.
+       *
+       *  This function reads characters from @a __s, interprets them as a
+       *  monetary value according to moneypunct and ctype facets retrieved
+       *  from io.getloc(), and returns the result in @a units as an integral
+       *  value moneypunct::frac_digits() * the actual amount.  For example,
+       *  the string $10.01 in a US locale would store 1001 in @a units.
+       *
+       *  Any characters not part of a valid money amount are not consumed.
+       *
+       *  If a money value cannot be parsed from the input stream, sets
+       *  err=(err|io.failbit).  If the stream is consumed before finishing
+       *  parsing,  sets err=(err|io.failbit|io.eofbit).  @a units is
+       *  unchanged if parsing fails.
+       *
+       *  This function works by returning the result of do_get().
+       *
+       *  @param  __s  Start of characters to parse.
+       *  @param  __end  End of characters to parse.
+       *  @param  __intl  Parameter to use_facet<moneypunct<CharT,intl> >.
+       *  @param  __io  Source of facets and io state.
+       *  @param  __err  Error field to set if parsing fails.
+       *  @param  __units  Place to store result of parsing.
+       *  @return  Iterator referencing first character beyond valid money
+       *	   amount.
+       */
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+	  ios_base::iostate& __err, long double& __units) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
+
+      /**
+       *  @brief  Read and parse a monetary value.
+       *
+       *  This function reads characters from @a __s, interprets them as
+       *  a monetary value according to moneypunct and ctype facets
+       *  retrieved from io.getloc(), and returns the result in @a
+       *  digits.  For example, the string $10.01 in a US locale would
+       *  store <code>1001</code> in @a digits.
+       *
+       *  Any characters not part of a valid money amount are not consumed.
+       *
+       *  If a money value cannot be parsed from the input stream, sets
+       *  err=(err|io.failbit).  If the stream is consumed before finishing
+       *  parsing,  sets err=(err|io.failbit|io.eofbit).
+       *
+       *  This function works by returning the result of do_get().
+       *
+       *  @param  __s  Start of characters to parse.
+       *  @param  __end  End of characters to parse.
+       *  @param  __intl  Parameter to use_facet<moneypunct<CharT,intl> >.
+       *  @param  __io  Source of facets and io state.
+       *  @param  __err  Error field to set if parsing fails.
+       *  @param  __digits  Place to store result of parsing.
+       *  @return  Iterator referencing first character beyond valid money
+       *	   amount.
+       */
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+	  ios_base::iostate& __err, string_type& __digits) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
+
+    protected:
+      /// Destructor.
+      virtual
+      ~money_get() { }
+
+      /**
+       *  @brief  Read and parse a monetary value.
+       *
+       *  This function reads and parses characters representing a monetary
+       *  value.  This function is a hook for derived classes to change the
+       *  value returned.  @see get() for details.
+       */
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      __do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+	       ios_base::iostate& __err, double& __units) const;
+#else
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+	     ios_base::iostate& __err, long double& __units) const;
+#endif
+
+      /**
+       *  @brief  Read and parse a monetary value.
+       *
+       *  This function reads and parses characters representing a monetary
+       *  value.  This function is a hook for derived classes to change the
+       *  value returned.  @see get() for details.
+       */
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+	     ios_base::iostate& __err, string_type& __digits) const;
+
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+	     ios_base::iostate& __err, long double& __units) const;
+#endif
+
+      template<bool _Intl>
+        iter_type
+        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
+		   ios_base::iostate& __err, string& __digits) const;     
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id money_get<_CharT, _InIter>::id;
+
+  /**
+   *  @brief  Primary class template money_put.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the code to format and output a monetary
+   *  amount.
+   *
+   *  The money_put template uses protected virtual functions to
+   *  provide the actual results.  The public accessors forward the
+   *  call to the virtual functions.  These virtual functions are
+   *  hooks for developers to implement the behavior they require from
+   *  the money_put facet.
+  */
+  template<typename _CharT, typename _OutIter>
+    class money_put : public locale::facet
+    {
+    public:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef _OutIter			iter_type;
+      typedef basic_string<_CharT>	string_type;
+      //@}
+
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      money_put(size_t __refs = 0) : facet(__refs) { }
+
+      /**
+       *  @brief  Format and output a monetary value.
+       *
+       *  This function formats @a units as a monetary value according to
+       *  moneypunct and ctype facets retrieved from io.getloc(), and writes
+       *  the resulting characters to @a __s.  For example, the value 1001 in a
+       *  US locale would write <code>$10.01</code> to @a __s.
+       *
+       *  This function works by returning the result of do_put().
+       *
+       *  @param  __s  The stream to write to.
+       *  @param  __intl  Parameter to use_facet<moneypunct<CharT,intl> >.
+       *  @param  __io  Source of facets and io state.
+       *  @param  __fill  char_type to use for padding.
+       *  @param  __units  Place to store result of parsing.
+       *  @return  Iterator after writing.
+       */
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+	  char_type __fill, long double __units) const
+      { return this->do_put(__s, __intl, __io, __fill, __units); }
+
+      /**
+       *  @brief  Format and output a monetary value.
+       *
+       *  This function formats @a digits as a monetary value
+       *  according to moneypunct and ctype facets retrieved from
+       *  io.getloc(), and writes the resulting characters to @a __s.
+       *  For example, the string <code>1001</code> in a US locale
+       *  would write <code>$10.01</code> to @a __s.
+       *
+       *  This function works by returning the result of do_put().
+       *
+       *  @param  __s  The stream to write to.
+       *  @param  __intl  Parameter to use_facet<moneypunct<CharT,intl> >.
+       *  @param  __io  Source of facets and io state.
+       *  @param  __fill  char_type to use for padding.
+       *  @param  __digits  Place to store result of parsing.
+       *  @return  Iterator after writing.
+       */
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+	  char_type __fill, const string_type& __digits) const
+      { return this->do_put(__s, __intl, __io, __fill, __digits); }
+
+    protected:
+      /// Destructor.
+      virtual
+      ~money_put() { }
+
+      /**
+       *  @brief  Format and output a monetary value.
+       *
+       *  This function formats @a units as a monetary value according to
+       *  moneypunct and ctype facets retrieved from io.getloc(), and writes
+       *  the resulting characters to @a __s.  For example, the value 1001 in a
+       *  US locale would write <code>$10.01</code> to @a __s.
+       *
+       *  This function is a hook for derived classes to change the value
+       *  returned.  @see put().
+       *
+       *  @param  __s  The stream to write to.
+       *  @param  __intl  Parameter to use_facet<moneypunct<CharT,intl> >.
+       *  @param  __io  Source of facets and io state.
+       *  @param  __fill  char_type to use for padding.
+       *  @param  __units  Place to store result of parsing.
+       *  @return  Iterator after writing.
+       */
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+	       double __units) const;
+#else
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+	     long double __units) const;
+#endif
+
+      /**
+       *  @brief  Format and output a monetary value.
+       *
+       *  This function formats @a digits as a monetary value
+       *  according to moneypunct and ctype facets retrieved from
+       *  io.getloc(), and writes the resulting characters to @a __s.
+       *  For example, the string <code>1001</code> in a US locale
+       *  would write <code>$10.01</code> to @a __s.
+       *
+       *  This function is a hook for derived classes to change the value
+       *  returned.  @see put().
+       *
+       *  @param  __s  The stream to write to.
+       *  @param  __intl  Parameter to use_facet<moneypunct<CharT,intl> >.
+       *  @param  __io  Source of facets and io state.
+       *  @param  __fill  char_type to use for padding.
+       *  @param  __digits  Place to store result of parsing.
+       *  @return  Iterator after writing.
+       */
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+	     const string_type& __digits) const;
+
+      // XXX GLIBCXX_ABI Deprecated
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+	     long double __units) const;
+#endif
+
+      template<bool _Intl>
+        iter_type
+        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+		  const string_type& __digits) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id money_put<_CharT, _OutIter>::id;
+
+_GLIBCXX_END_NAMESPACE_LDBL
+
+  /**
+   *  @brief  Messages facet base class providing catalog typedef.
+   *  @ingroup locales
+   */
+  struct messages_base
+  {
+    typedef int catalog;
+  };
+
+  /**
+   *  @brief  Primary class template messages.
+   *  @ingroup locales
+   *
+   *  This facet encapsulates the code to retrieve messages from
+   *  message catalogs.  The only thing defined by the standard for this facet
+   *  is the interface.  All underlying functionality is
+   *  implementation-defined.
+   *
+   *  This library currently implements 3 versions of the message facet.  The
+   *  first version (gnu) is a wrapper around gettext, provided by libintl.
+   *  The second version (ieee) is a wrapper around catgets.  The final
+   *  version (default) does no actual translation.  These implementations are
+   *  only provided for char and wchar_t instantiations.
+   *
+   *  The messages template uses protected virtual functions to
+   *  provide the actual results.  The public accessors forward the
+   *  call to the virtual functions.  These virtual functions are
+   *  hooks for developers to implement the behavior they require from
+   *  the messages facet.
+  */
+  template<typename _CharT>
+    class messages : public locale::facet, public messages_base
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT			char_type;
+      typedef basic_string<_CharT>	string_type;
+      //@}
+
+    protected:
+      // Underlying "C" library locale information saved from
+      // initialization, needed by messages_byname as well.
+      __c_locale			_M_c_locale_messages;
+      const char*			_M_name_messages;
+
+    public:
+      /// Numpunct facet id.
+      static locale::id			id;
+
+      /**
+       *  @brief  Constructor performs initialization.
+       *
+       *  This is the constructor provided by the standard.
+       *
+       *  @param __refs  Passed to the base facet class.
+      */
+      explicit
+      messages(size_t __refs = 0);
+
+      // Non-standard.
+      /**
+       *  @brief  Internal constructor.  Not for general use.
+       *
+       *  This is a constructor for use by the library itself to set up new
+       *  locales.
+       *
+       *  @param  __cloc  The C locale.
+       *  @param  __s  The name of a locale.
+       *  @param  __refs  Refcount to pass to the base class.
+       */
+      explicit
+      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
+
+      /*
+       *  @brief  Open a message catalog.
+       *
+       *  This function opens and returns a handle to a message catalog by
+       *  returning do_open(__s, __loc).
+       *
+       *  @param  __s  The catalog to open.
+       *  @param  __loc  Locale to use for character set conversions.
+       *  @return  Handle to the catalog or value < 0 if open fails.
+      */
+      catalog
+      open(const basic_string<char>& __s, const locale& __loc) const
+      { return this->do_open(__s, __loc); }
+
+      // Non-standard and unorthodox, yet effective.
+      /*
+       *  @brief  Open a message catalog.
+       *
+       *  This non-standard function opens and returns a handle to a message
+       *  catalog by returning do_open(s, loc).  The third argument provides a
+       *  message catalog root directory for gnu gettext and is ignored
+       *  otherwise.
+       *
+       *  @param  __s  The catalog to open.
+       *  @param  __loc  Locale to use for character set conversions.
+       *  @param  __dir  Message catalog root directory.
+       *  @return  Handle to the catalog or value < 0 if open fails.
+      */
+      catalog
+      open(const basic_string<char>&, const locale&, const char*) const;
+
+      /*
+       *  @brief  Look up a string in a message catalog.
+       *
+       *  This function retrieves and returns a message from a catalog by
+       *  returning do_get(c, set, msgid, s).
+       *
+       *  For gnu, @a __set and @a msgid are ignored.  Returns gettext(s).
+       *  For default, returns s. For ieee, returns catgets(c,set,msgid,s).
+       *
+       *  @param  __c  The catalog to access.
+       *  @param  __set  Implementation-defined.
+       *  @param  __msgid  Implementation-defined.
+       *  @param  __s  Default return value if retrieval fails.
+       *  @return  Retrieved message or @a __s if get fails.
+      */
+      string_type
+      get(catalog __c, int __set, int __msgid, const string_type& __s) const
+      { return this->do_get(__c, __set, __msgid, __s); }
+
+      /*
+       *  @brief  Close a message catalog.
+       *
+       *  Closes catalog @a c by calling do_close(c).
+       *
+       *  @param  __c  The catalog to close.
+      */
+      void
+      close(catalog __c) const
+      { return this->do_close(__c); }
+
+    protected:
+      /// Destructor.
+      virtual
+      ~messages();
+
+      /*
+       *  @brief  Open a message catalog.
+       *
+       *  This function opens and returns a handle to a message catalog in an
+       *  implementation-defined manner.  This function is a hook for derived
+       *  classes to change the value returned.
+       *
+       *  @param  __s  The catalog to open.
+       *  @param  __loc  Locale to use for character set conversions.
+       *  @return  Handle to the opened catalog, value < 0 if open failed.
+      */
+      virtual catalog
+      do_open(const basic_string<char>&, const locale&) const;
+
+      /*
+       *  @brief  Look up a string in a message catalog.
+       *
+       *  This function retrieves and returns a message from a catalog in an
+       *  implementation-defined manner.  This function is a hook for derived
+       *  classes to change the value returned.
+       *
+       *  For gnu, @a __set and @a __msgid are ignored.  Returns gettext(s).
+       *  For default, returns s. For ieee, returns catgets(c,set,msgid,s).
+       *
+       *  @param  __c  The catalog to access.
+       *  @param  __set  Implementation-defined.
+       *  @param  __msgid  Implementation-defined.
+       *  @param  __s  Default return value if retrieval fails.
+       *  @return  Retrieved message or @a __s if get fails.
+      */
+      virtual string_type
+      do_get(catalog, int, int, const string_type& __dfault) const;
+
+      /*
+       *  @brief  Close a message catalog.
+       *
+       *  @param  __c  The catalog to close.
+      */
+      virtual void
+      do_close(catalog) const;
+
+      // Returns a locale and codeset-converted string, given a char* message.
+      char*
+      _M_convert_to_char(const string_type& __msg) const
+      {
+	// XXX
+	return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
+      }
+
+      // Returns a locale and codeset-converted string, given a char* message.
+      string_type
+      _M_convert_from_char(char*) const
+      {
+	// XXX
+	return string_type();
+      }
+     };
+
+  template<typename _CharT>
+    locale::id messages<_CharT>::id;
+
+  /// Specializations for required instantiations.
+  template<>
+    string
+    messages<char>::do_get(catalog, int, int, const string&) const;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    wstring
+    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
+#endif
+
+   /// class messages_byname [22.2.7.2].
+   template<typename _CharT>
+    class messages_byname : public messages<_CharT>
+    {
+    public:
+      typedef _CharT			char_type;
+      typedef basic_string<_CharT>	string_type;
+
+      explicit
+      messages_byname(const char* __s, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~messages_byname()
+      { }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+// Include host and configuration specific messages functions.
+#include <bits/messages_members.h>
+
+// 22.2.1.5  Template class codecvt
+#include <bits/codecvt.h>
+
+#include <bits/locale_facets_nonio.tcc>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/locale_facets_nonio.tcc b/gcc-4.9/libstdc++-v3/include/bits/locale_facets_nonio.tcc
new file mode 100644
index 0000000..41d944d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/locale_facets_nonio.tcc
@@ -0,0 +1,1373 @@
+// Locale support -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/locale_facets_nonio.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+#ifndef _LOCALE_FACETS_NONIO_TCC
+#define _LOCALE_FACETS_NONIO_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, bool _Intl>
+    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
+    {
+      const __moneypunct_cache<_CharT, _Intl>*
+      operator() (const locale& __loc) const
+      {
+	const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
+	const locale::facet** __caches = __loc._M_impl->_M_caches;
+	if (!__caches[__i])
+	  {
+	    __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
+	    __try
+	      {
+		__tmp = new __moneypunct_cache<_CharT, _Intl>;
+		__tmp->_M_cache(__loc);
+	      }
+	    __catch(...)
+	      {
+		delete __tmp;
+		__throw_exception_again;
+	      }
+	    __loc._M_impl->_M_install_cache(__tmp, __i);
+	  }
+	return static_cast<
+	  const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT, bool _Intl>
+    void
+    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
+    {
+      _M_allocated = true;
+
+      const moneypunct<_CharT, _Intl>& __mp =
+	use_facet<moneypunct<_CharT, _Intl> >(__loc);
+
+      _M_decimal_point = __mp.decimal_point();
+      _M_thousands_sep = __mp.thousands_sep();
+      _M_frac_digits = __mp.frac_digits();
+
+      char* __grouping = 0;
+      _CharT* __curr_symbol = 0;
+      _CharT* __positive_sign = 0;
+      _CharT* __negative_sign = 0;     
+      __try
+	{
+	  _M_grouping_size = __mp.grouping().size();
+	  __grouping = new char[_M_grouping_size];
+	  __mp.grouping().copy(__grouping, _M_grouping_size);
+	  _M_grouping = __grouping;
+	  _M_use_grouping = (_M_grouping_size
+			     && static_cast<signed char>(_M_grouping[0]) > 0
+			     && (_M_grouping[0]
+				 != __gnu_cxx::__numeric_traits<char>::__max));
+
+	  _M_curr_symbol_size = __mp.curr_symbol().size();
+	  __curr_symbol = new _CharT[_M_curr_symbol_size];
+	  __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
+	  _M_curr_symbol = __curr_symbol;
+
+	  _M_positive_sign_size = __mp.positive_sign().size();
+	  __positive_sign = new _CharT[_M_positive_sign_size];
+	  __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
+	  _M_positive_sign = __positive_sign;
+
+	  _M_negative_sign_size = __mp.negative_sign().size();
+	  __negative_sign = new _CharT[_M_negative_sign_size];
+	  __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
+	  _M_negative_sign = __negative_sign;
+
+	  _M_pos_format = __mp.pos_format();
+	  _M_neg_format = __mp.neg_format();
+
+	  const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+	  __ct.widen(money_base::_S_atoms,
+		     money_base::_S_atoms + money_base::_S_end, _M_atoms);
+	}
+      __catch(...)
+	{
+	  delete [] __grouping;
+	  delete [] __curr_symbol;
+	  delete [] __positive_sign;
+	  delete [] __negative_sign;
+	  __throw_exception_again;
+	}
+    }
+
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
+
+  template<typename _CharT, typename _InIter>
+    template<bool _Intl>
+      _InIter
+      money_get<_CharT, _InIter>::
+      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
+		 ios_base::iostate& __err, string& __units) const
+      {
+	typedef char_traits<_CharT>			  __traits_type;
+	typedef typename string_type::size_type	          size_type;	
+	typedef money_base::part			  part;
+	typedef __moneypunct_cache<_CharT, _Intl>         __cache_type;
+	
+	const locale& __loc = __io._M_getloc();
+	const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+	__use_cache<__cache_type> __uc;
+	const __cache_type* __lc = __uc(__loc);
+	const char_type* __lit = __lc->_M_atoms;
+
+	// Deduced sign.
+	bool __negative = false;
+	// Sign size.
+	size_type __sign_size = 0;
+	// True if sign is mandatory.
+	const bool __mandatory_sign = (__lc->_M_positive_sign_size
+				       && __lc->_M_negative_sign_size);
+	// String of grouping info from thousands_sep plucked from __units.
+	string __grouping_tmp;
+	if (__lc->_M_use_grouping)
+	  __grouping_tmp.reserve(32);
+	// Last position before the decimal point.
+	int __last_pos = 0;
+	// Separator positions, then, possibly, fractional digits.
+	int __n = 0;
+	// If input iterator is in a valid state.
+	bool __testvalid = true;
+	// Flag marking when a decimal point is found.
+	bool __testdecfound = false;
+
+	// The tentative returned string is stored here.
+	string __res;
+	__res.reserve(32);
+
+	const char_type* __lit_zero = __lit + money_base::_S_zero;
+	const money_base::pattern __p = __lc->_M_neg_format;
+	for (int __i = 0; __i < 4 && __testvalid; ++__i)
+	  {
+	    const part __which = static_cast<part>(__p.field[__i]);
+	    switch (__which)
+	      {
+	      case money_base::symbol:
+		// According to 22.2.6.1.2, p2, symbol is required
+		// if (__io.flags() & ios_base::showbase), otherwise
+		// is optional and consumed only if other characters
+		// are needed to complete the format.
+		if (__io.flags() & ios_base::showbase || __sign_size > 1
+		    || __i == 0
+		    || (__i == 1 && (__mandatory_sign
+				     || (static_cast<part>(__p.field[0])
+					 == money_base::sign)
+				     || (static_cast<part>(__p.field[2])
+					 == money_base::space)))
+		    || (__i == 2 && ((static_cast<part>(__p.field[3])
+				      == money_base::value)
+				     || (__mandatory_sign
+					 && (static_cast<part>(__p.field[3])
+					     == money_base::sign)))))
+		  {
+		    const size_type __len = __lc->_M_curr_symbol_size;
+		    size_type __j = 0;
+		    for (; __beg != __end && __j < __len
+			   && *__beg == __lc->_M_curr_symbol[__j];
+			 ++__beg, ++__j);
+		    if (__j != __len
+			&& (__j || __io.flags() & ios_base::showbase))
+		      __testvalid = false;
+		  }
+		break;
+	      case money_base::sign:
+		// Sign might not exist, or be more than one character long.
+		if (__lc->_M_positive_sign_size && __beg != __end
+		    && *__beg == __lc->_M_positive_sign[0])
+		  {
+		    __sign_size = __lc->_M_positive_sign_size;
+		    ++__beg;
+		  }
+		else if (__lc->_M_negative_sign_size && __beg != __end
+			 && *__beg == __lc->_M_negative_sign[0])
+		  {
+		    __negative = true;
+		    __sign_size = __lc->_M_negative_sign_size;
+		    ++__beg;
+		  }
+		else if (__lc->_M_positive_sign_size
+			 && !__lc->_M_negative_sign_size)
+		  // "... if no sign is detected, the result is given the sign
+		  // that corresponds to the source of the empty string"
+		  __negative = true;
+		else if (__mandatory_sign)
+		  __testvalid = false;
+		break;
+	      case money_base::value:
+		// Extract digits, remove and stash away the
+		// grouping of found thousands separators.
+		for (; __beg != __end; ++__beg)
+		  {
+		    const char_type __c = *__beg;
+		    const char_type* __q = __traits_type::find(__lit_zero, 
+							       10, __c);
+		    if (__q != 0)
+		      {
+			__res += money_base::_S_atoms[__q - __lit];
+			++__n;
+		      }
+		    else if (__c == __lc->_M_decimal_point 
+			     && !__testdecfound)
+		      {
+			if (__lc->_M_frac_digits <= 0)
+			  break;
+
+			__last_pos = __n;
+			__n = 0;
+			__testdecfound = true;
+		      }
+		    else if (__lc->_M_use_grouping
+			     && __c == __lc->_M_thousands_sep
+			     && !__testdecfound)
+		      {
+			if (__n)
+			  {
+			    // Mark position for later analysis.
+			    __grouping_tmp += static_cast<char>(__n);
+			    __n = 0;
+			  }
+			else
+			  {
+			    __testvalid = false;
+			    break;
+			  }
+		      }
+		    else
+		      break;
+		  }
+		if (__res.empty())
+		  __testvalid = false;
+		break;
+	      case money_base::space:
+		// At least one space is required.
+		if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
+		  ++__beg;
+		else
+		  __testvalid = false;
+	      case money_base::none:
+		// Only if not at the end of the pattern.
+		if (__i != 3)
+		  for (; __beg != __end
+			 && __ctype.is(ctype_base::space, *__beg); ++__beg);
+		break;
+	      }
+	  }
+
+	// Need to get the rest of the sign characters, if they exist.
+	if (__sign_size > 1 && __testvalid)
+	  {
+	    const char_type* __sign = __negative ? __lc->_M_negative_sign
+	                                         : __lc->_M_positive_sign;
+	    size_type __i = 1;
+	    for (; __beg != __end && __i < __sign_size
+		   && *__beg == __sign[__i]; ++__beg, ++__i);
+	    
+	    if (__i != __sign_size)
+	      __testvalid = false;
+	  }
+
+	if (__testvalid)
+	  {
+	    // Strip leading zeros.
+	    if (__res.size() > 1)
+	      {
+		const size_type __first = __res.find_first_not_of('0');
+		const bool __only_zeros = __first == string::npos;
+		if (__first)
+		  __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
+	      }
+
+	    // 22.2.6.1.2, p4
+	    if (__negative && __res[0] != '0')
+	      __res.insert(__res.begin(), '-');
+	    
+	    // Test for grouping fidelity.
+	    if (__grouping_tmp.size())
+	      {
+		// Add the ending grouping.
+		__grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
+						                   : __n);
+		if (!std::__verify_grouping(__lc->_M_grouping,
+					    __lc->_M_grouping_size,
+					    __grouping_tmp))
+		  __err |= ios_base::failbit;
+	      }
+	    
+	    // Iff not enough digits were supplied after the decimal-point.
+	    if (__testdecfound && __n != __lc->_M_frac_digits)
+	      __testvalid = false;
+	  }
+
+	// Iff valid sequence is not recognized.
+	if (!__testvalid)
+	  __err |= ios_base::failbit;
+	else
+	  __units.swap(__res);
+	
+	// Iff no more characters are available.
+	if (__beg == __end)
+	  __err |= ios_base::eofbit;
+	return __beg;
+      }
+
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+	     ios_base::iostate& __err, double& __units) const
+    {
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+                     : _M_extract<false>(__beg, __end, __io, __err, __str);
+      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
+      return __beg;
+    }
+#endif
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+	   ios_base::iostate& __err, long double& __units) const
+    {
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+	             : _M_extract<false>(__beg, __end, __io, __err, __str);
+      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+	   ios_base::iostate& __err, string_type& __digits) const
+    {
+      typedef typename string::size_type                  size_type;
+
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+	             : _M_extract<false>(__beg, __end, __io, __err, __str);
+      const size_type __len = __str.size();
+      if (__len)
+	{
+	  __digits.resize(__len);
+	  __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
+	}
+      return __beg;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<bool _Intl>
+      _OutIter
+      money_put<_CharT, _OutIter>::
+      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+		const string_type& __digits) const
+      {
+	typedef typename string_type::size_type	          size_type;
+	typedef money_base::part                          part;
+	typedef __moneypunct_cache<_CharT, _Intl>         __cache_type;
+      
+	const locale& __loc = __io._M_getloc();
+	const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+	__use_cache<__cache_type> __uc;
+	const __cache_type* __lc = __uc(__loc);
+	const char_type* __lit = __lc->_M_atoms;
+
+	// Determine if negative or positive formats are to be used, and
+	// discard leading negative_sign if it is present.
+	const char_type* __beg = __digits.data();
+
+	money_base::pattern __p;
+	const char_type* __sign;
+	size_type __sign_size;
+	if (!(*__beg == __lit[money_base::_S_minus]))
+	  {
+	    __p = __lc->_M_pos_format;
+	    __sign = __lc->_M_positive_sign;
+	    __sign_size = __lc->_M_positive_sign_size;
+	  }
+	else
+	  {
+	    __p = __lc->_M_neg_format;
+	    __sign = __lc->_M_negative_sign;
+	    __sign_size = __lc->_M_negative_sign_size;
+	    if (__digits.size())
+	      ++__beg;
+	  }
+       
+	// Look for valid numbers in the ctype facet within input digits.
+	size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
+					   __beg + __digits.size()) - __beg;
+	if (__len)
+	  {
+	    // Assume valid input, and attempt to format.
+	    // Break down input numbers into base components, as follows:
+	    //   final_value = grouped units + (decimal point) + (digits)
+	    string_type __value;
+	    __value.reserve(2 * __len);
+
+	    // Add thousands separators to non-decimal digits, per
+	    // grouping rules.
+	    long __paddec = __len - __lc->_M_frac_digits;
+	    if (__paddec > 0)
+  	      {
+		if (__lc->_M_frac_digits < 0)
+		  __paddec = __len;
+  		if (__lc->_M_grouping_size)
+  		  {
+		    __value.assign(2 * __paddec, char_type());
+ 		    _CharT* __vend = 
+		      std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
+					  __lc->_M_grouping,
+					  __lc->_M_grouping_size,
+					  __beg, __beg + __paddec);
+		    __value.erase(__vend - &__value[0]);
+  		  }
+  		else
+		  __value.assign(__beg, __paddec);
+	      }
+
+	    // Deal with decimal point, decimal digits.
+	    if (__lc->_M_frac_digits > 0)
+	      {
+		__value += __lc->_M_decimal_point;
+		if (__paddec >= 0)
+		  __value.append(__beg + __paddec, __lc->_M_frac_digits);
+		else
+		  {
+		    // Have to pad zeros in the decimal position.
+		    __value.append(-__paddec, __lit[money_base::_S_zero]);
+		    __value.append(__beg, __len);
+		  }
+  	      }
+  
+	    // Calculate length of resulting string.
+	    const ios_base::fmtflags __f = __io.flags() 
+	                                   & ios_base::adjustfield;
+	    __len = __value.size() + __sign_size;
+	    __len += ((__io.flags() & ios_base::showbase)
+		      ? __lc->_M_curr_symbol_size : 0);
+
+	    string_type __res;
+	    __res.reserve(2 * __len);
+	    
+	    const size_type __width = static_cast<size_type>(__io.width());  
+	    const bool __testipad = (__f == ios_base::internal
+				     && __len < __width);
+	    // Fit formatted digits into the required pattern.
+	    for (int __i = 0; __i < 4; ++__i)
+	      {
+		const part __which = static_cast<part>(__p.field[__i]);
+		switch (__which)
+		  {
+		  case money_base::symbol:
+		    if (__io.flags() & ios_base::showbase)
+		      __res.append(__lc->_M_curr_symbol,
+				   __lc->_M_curr_symbol_size);
+		    break;
+		  case money_base::sign:
+		    // Sign might not exist, or be more than one
+		    // character long. In that case, add in the rest
+		    // below.
+		    if (__sign_size)
+		      __res += __sign[0];
+		    break;
+		  case money_base::value:
+		    __res += __value;
+		    break;
+		  case money_base::space:
+		    // At least one space is required, but if internal
+		    // formatting is required, an arbitrary number of
+		    // fill spaces will be necessary.
+		    if (__testipad)
+		      __res.append(__width - __len, __fill);
+		    else
+		      __res += __fill;
+		    break;
+		  case money_base::none:
+		    if (__testipad)
+		      __res.append(__width - __len, __fill);
+		    break;
+		  }
+	      }
+	    
+	    // Special case of multi-part sign parts.
+	    if (__sign_size > 1)
+	      __res.append(__sign + 1, __sign_size - 1);
+	    
+	    // Pad, if still necessary.
+	    __len = __res.size();
+	    if (__width > __len)
+	      {
+		if (__f == ios_base::left)
+		  // After.
+		  __res.append(__width - __len, __fill);
+		else
+		  // Before.
+		  __res.insert(0, __width - __len, __fill);
+		__len = __width;
+	      }
+	    
+	    // Write resulting, fully-formatted string to output iterator.
+	    __s = std::__write(__s, __res.data(), __len);
+	  }
+	__io.width(0);
+	return __s;    
+      }
+
+#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+	     double __units) const
+    { return this->do_put(__s, __intl, __io, __fill, (long double) __units); }
+#endif
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+	   long double __units) const
+    {
+      const locale __loc = __io.getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+#ifdef _GLIBCXX_USE_C99
+      // First try a buffer perhaps big enough.
+      int __cs_size = 64;
+      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 328. Bad sprintf format modifier in money_put<>::do_put()
+      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+					"%.*Lf", 0, __units);
+      // If the buffer was not large enough, try again with the correct size.
+      if (__len >= __cs_size)
+	{
+	  __cs_size = __len + 1;
+	  __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+	  __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+					"%.*Lf", 0, __units);
+	}
+#else
+      // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'.
+      const int __cs_size =
+	__gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 3;
+      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, "%.*Lf", 
+					0, __units);
+#endif
+      string_type __digits(__len, char_type());
+      __ctype.widen(__cs, __cs + __len, &__digits[0]);
+      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+	            : _M_insert<false>(__s, __io, __fill, __digits);
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+	   const string_type& __digits) const
+    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+	            : _M_insert<false>(__s, __io, __fill, __digits); }
+
+_GLIBCXX_END_NAMESPACE_LDBL
+
+  // NB: Not especially useful. Without an ios_base object or some
+  // kind of locale reference, we are left clawing at the air where
+  // the side of the mountain used to be...
+  template<typename _CharT, typename _InIter>
+    time_base::dateorder
+    time_get<_CharT, _InIter>::do_date_order() const
+    { return time_base::no_order; }
+
+  // Expand a strftime format string and parse it.  E.g., do_get_date() may
+  // pass %m/%d/%Y => extracted characters.
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+			  ios_base::iostate& __err, tm* __tm,
+			  const _CharT* __format) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const size_t __len = char_traits<_CharT>::length(__format);
+
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      size_t __i = 0;
+      for (; __beg != __end && __i < __len && !__tmperr; ++__i)
+	{
+	  if (__ctype.narrow(__format[__i], 0) == '%')
+	    {
+	      // Verify valid formatting code, attempt to extract.
+	      char __c = __ctype.narrow(__format[++__i], 0);
+	      int __mem = 0;
+	      if (__c == 'E' || __c == 'O')
+		__c = __ctype.narrow(__format[++__i], 0);
+	      switch (__c)
+		{
+		  const char* __cs;
+		  _CharT __wcs[10];
+		case 'a':
+		  // Abbreviated weekday name [tm_wday]
+		  const char_type*  __days1[7];
+		  __tp._M_days_abbreviated(__days1);
+		  __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
+					  7, __io, __tmperr);
+		  break;
+		case 'A':
+		  // Weekday name [tm_wday].
+		  const char_type*  __days2[7];
+		  __tp._M_days(__days2);
+		  __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
+					  7, __io, __tmperr);
+		  break;
+		case 'h':
+		case 'b':
+		  // Abbreviated month name [tm_mon]
+		  const char_type*  __months1[12];
+		  __tp._M_months_abbreviated(__months1);
+		  __beg = _M_extract_name(__beg, __end, __tm->tm_mon, 
+					  __months1, 12, __io, __tmperr);
+		  break;
+		case 'B':
+		  // Month name [tm_mon].
+		  const char_type*  __months2[12];
+		  __tp._M_months(__months2);
+		  __beg = _M_extract_name(__beg, __end, __tm->tm_mon, 
+					  __months2, 12, __io, __tmperr);
+		  break;
+		case 'c':
+		  // Default time and date representation.
+		  const char_type*  __dt[2];
+		  __tp._M_date_time_formats(__dt);
+		  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, 
+						__tm, __dt[0]);
+		  break;
+		case 'd':
+		  // Day [01, 31]. [tm_mday]
+		  __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
+					 __io, __tmperr);
+		  break;
+		case 'e':
+		  // Day [1, 31], with single digits preceded by
+		  // space. [tm_mday]
+		  if (__ctype.is(ctype_base::space, *__beg))
+		    __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
+					   1, __io, __tmperr);
+		  else
+		    __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
+					   2, __io, __tmperr);
+		  break;
+		case 'D':
+		  // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
+		  __cs = "%m/%d/%y";
+		  __ctype.widen(__cs, __cs + 9, __wcs);
+		  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, 
+						__tm, __wcs);
+		  break;
+		case 'H':
+		  // Hour [00, 23]. [tm_hour]
+		  __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
+					 __io, __tmperr);
+		  break;
+		case 'I':
+		  // Hour [01, 12]. [tm_hour]
+		  __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
+					 __io, __tmperr);
+		  break;
+		case 'm':
+		  // Month [01, 12]. [tm_mon]
+		  __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2, 
+					 __io, __tmperr);
+		  if (!__tmperr)
+		    __tm->tm_mon = __mem - 1;
+		  break;
+		case 'M':
+		  // Minute [00, 59]. [tm_min]
+		  __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
+					 __io, __tmperr);
+		  break;
+		case 'n':
+		  if (__ctype.narrow(*__beg, 0) == '\n')
+		    ++__beg;
+		  else
+		    __tmperr |= ios_base::failbit;
+		  break;
+		case 'R':
+		  // Equivalent to (%H:%M).
+		  __cs = "%H:%M";
+		  __ctype.widen(__cs, __cs + 6, __wcs);
+		  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, 
+						__tm, __wcs);
+		  break;
+		case 'S':
+		  // Seconds. [tm_sec]
+		  // [00, 60] in C99 (one leap-second), [00, 61] in C89.
+#ifdef _GLIBCXX_USE_C99
+		  __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
+#else
+		  __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 61, 2,
+#endif
+					 __io, __tmperr);
+		  break;
+		case 't':
+		  if (__ctype.narrow(*__beg, 0) == '\t')
+		    ++__beg;
+		  else
+		    __tmperr |= ios_base::failbit;
+		  break;
+		case 'T':
+		  // Equivalent to (%H:%M:%S).
+		  __cs = "%H:%M:%S";
+		  __ctype.widen(__cs, __cs + 9, __wcs);
+		  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, 
+						__tm, __wcs);
+		  break;
+		case 'x':
+		  // Locale's date.
+		  const char_type*  __dates[2];
+		  __tp._M_date_formats(__dates);
+		  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, 
+						__tm, __dates[0]);
+		  break;
+		case 'X':
+		  // Locale's time.
+		  const char_type*  __times[2];
+		  __tp._M_time_formats(__times);
+		  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, 
+						__tm, __times[0]);
+		  break;
+		case 'y':
+		case 'C': // C99
+		  // Two digit year.
+		case 'Y':
+		  // Year [1900).
+		  // NB: We parse either two digits, implicitly years since
+		  // 1900, or 4 digits, full year.  In both cases we can 
+		  // reconstruct [tm_year].  See also libstdc++/26701.
+		  __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
+					 __io, __tmperr);
+		  if (!__tmperr)
+		    __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
+		  break;
+		case 'Z':
+		  // Timezone info.
+		  if (__ctype.is(ctype_base::upper, *__beg))
+		    {
+		      int __tmp;
+		      __beg = _M_extract_name(__beg, __end, __tmp,
+				       __timepunct_cache<_CharT>::_S_timezones,
+					      14, __io, __tmperr);
+
+		      // GMT requires special effort.
+		      if (__beg != __end && !__tmperr && __tmp == 0
+			  && (*__beg == __ctype.widen('-')
+			      || *__beg == __ctype.widen('+')))
+			{
+			  __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
+						 __io, __tmperr);
+			  __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
+						 __io, __tmperr);
+			}
+		    }
+		  else
+		    __tmperr |= ios_base::failbit;
+		  break;
+		default:
+		  // Not recognized.
+		  __tmperr |= ios_base::failbit;
+		}
+	    }
+	  else
+	    {
+	      // Verify format and input match, extract and discard.
+	      if (__format[__i] == *__beg)
+		++__beg;
+	      else
+		__tmperr |= ios_base::failbit;
+	    }
+	}
+
+      if (__tmperr || __i != __len)
+	__err |= ios_base::failbit;
+  
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+		   int __min, int __max, size_t __len,
+		   ios_base& __io, ios_base::iostate& __err) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      // As-is works for __len = 1, 2, 4, the values actually used.
+      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
+
+      ++__min;
+      size_t __i = 0;
+      int __value = 0;
+      for (; __beg != __end && __i < __len; ++__beg, ++__i)
+	{
+	  const char __c = __ctype.narrow(*__beg, '*');
+	  if (__c >= '0' && __c <= '9')
+	    {
+	      __value = __value * 10 + (__c - '0');
+	      const int __valuec = __value * __mult;
+	      if (__valuec > __max || __valuec + __mult < __min)
+		break;
+	      __mult /= 10;
+	    }
+	  else
+	    break;
+	}
+      if (__i == __len)
+	__member = __value;
+      // Special encoding for do_get_year, 'y', and 'Y' above.
+      else if (__len == 4 && __i == 2)
+	__member = __value - 100;
+      else
+	__err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  // Assumptions:
+  // All elements in __names are unique.
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+		    const _CharT** __names, size_t __indexlen,
+		    ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT>		__traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
+							  * __indexlen));
+      size_t __nmatches = 0;
+      size_t __pos = 0;
+      bool __testvalid = true;
+      const char_type* __name;
+
+      // Look for initial matches.
+      // NB: Some of the locale data is in the form of all lowercase
+      // names, and some is in the form of initially-capitalized
+      // names. Look for both.
+      if (__beg != __end)
+	{
+	  const char_type __c = *__beg;
+	  for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
+	    if (__c == __names[__i1][0]
+		|| __c == __ctype.toupper(__names[__i1][0]))
+	      __matches[__nmatches++] = __i1;
+	}
+
+      while (__nmatches > 1)
+	{
+	  // Find smallest matching string.
+	  size_t __minlen = __traits_type::length(__names[__matches[0]]);
+	  for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
+	    __minlen = std::min(__minlen,
+			      __traits_type::length(__names[__matches[__i2]]));
+	  ++__beg, ++__pos;
+	  if (__pos < __minlen && __beg != __end)
+	    for (size_t __i3 = 0; __i3 < __nmatches;)
+	      {
+		__name = __names[__matches[__i3]];
+		if (!(__name[__pos] == *__beg))
+		  __matches[__i3] = __matches[--__nmatches];
+		else
+		  ++__i3;
+	      }
+	  else
+	    break;
+	}
+
+      if (__nmatches == 1)
+	{
+	  // Make sure found name is completely extracted.
+	  ++__beg, ++__pos;
+	  __name = __names[__matches[0]];
+	  const size_t __len = __traits_type::length(__name);
+	  while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
+	    ++__beg, ++__pos;
+
+	  if (__len == __pos)
+	    __member = __matches[0];
+	  else
+	    __testvalid = false;
+	}
+      else
+	__testvalid = false;
+      if (!__testvalid)
+	__err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+			     const _CharT** __names, size_t __indexlen,
+			     ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT>		__traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
+							  * __indexlen));
+      size_t __nmatches = 0;
+      size_t* __matches_lengths = 0;
+      size_t __pos = 0;
+
+      if (__beg != __end)
+	{
+	  const char_type __c = *__beg;
+	  for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
+	    if (__c == __names[__i][0]
+		|| __c == __ctype.toupper(__names[__i][0]))
+	      __matches[__nmatches++] = __i;
+	}
+
+      if (__nmatches)
+	{
+	  ++__beg, ++__pos;
+
+	  __matches_lengths
+	    = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
+						    * __nmatches));
+	  for (size_t __i = 0; __i < __nmatches; ++__i)
+	    __matches_lengths[__i]
+	      = __traits_type::length(__names[__matches[__i]]);
+	}
+
+      for (; __beg != __end; ++__beg, ++__pos)
+	{
+	  size_t __nskipped = 0;
+	  const char_type __c = *__beg;
+	  for (size_t __i = 0; __i < __nmatches;)
+	    {
+	      const char_type* __name = __names[__matches[__i]];
+	      if (__pos >= __matches_lengths[__i])
+		++__nskipped, ++__i;
+	      else if (!(__name[__pos] == __c))
+		{
+		  --__nmatches;
+		  __matches[__i] = __matches[__nmatches];
+		  __matches_lengths[__i] = __matches_lengths[__nmatches];
+		}
+	      else
+		++__i;
+	    }
+	  if (__nskipped == __nmatches)
+	    break;
+	}
+
+      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
+	  || (__nmatches == 2 && (__matches_lengths[0] == __pos
+				  || __matches_lengths[1] == __pos)))
+	__member = (__matches[0] >= __indexlen
+		    ? __matches[0] - __indexlen : __matches[0]);
+      else
+	__err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+		ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type*  __times[2];
+      __tp._M_time_formats(__times);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err, 
+				    __tm, __times[0]);
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+		ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type*  __dates[2];
+      __tp._M_date_formats(__dates);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err, 
+				    __tm, __dates[0]);
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+		   ios_base::iostate& __err, tm* __tm) const
+    {
+      typedef char_traits<_CharT>		__traits_type;
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const char_type* __days[14];
+      __tp._M_days_abbreviated(__days);
+      __tp._M_days(__days + 7);
+      int __tmpwday;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
+				       __io, __tmperr);
+      if (!__tmperr)
+	__tm->tm_wday = __tmpwday;
+      else
+	__err |= ios_base::failbit;
+
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+     }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_monthname(iter_type __beg, iter_type __end,
+                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
+    {
+      typedef char_traits<_CharT>		__traits_type;
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const char_type*  __months[24];
+      __tp._M_months_abbreviated(__months);
+      __tp._M_months(__months + 12);
+      int __tmpmon;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
+				       __io, __tmperr);
+      if (!__tmperr)
+	__tm->tm_mon = __tmpmon;
+      else
+	__err |= ios_base::failbit;
+
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+		ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      int __tmpyear;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
+			     __io, __tmperr);
+      if (!__tmperr)
+	__tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
+      else
+	__err |= ios_base::failbit;
+
+      if (__beg == __end)
+	__err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+	const _CharT* __beg, const _CharT* __end) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      for (; __beg != __end; ++__beg)
+	if (__ctype.narrow(*__beg, 0) != '%')
+	  {
+	    *__s = *__beg;
+	    ++__s;
+	  }
+	else if (++__beg != __end)
+	  {
+	    char __format;
+	    char __mod = 0;
+	    const char __c = __ctype.narrow(*__beg, 0);
+	    if (__c != 'E' && __c != 'O')
+	      __format = __c;
+	    else if (++__beg != __end)
+	      {
+		__mod = __c;
+		__format = __ctype.narrow(*__beg, 0);
+	      }
+	    else
+	      break;
+	    __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
+	  }
+	else
+	  break;
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
+	   char __format, char __mod) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
+
+      // NB: This size is arbitrary. Should this be a data member,
+      // initialized at construction?
+      const size_t __maxlen = 128;
+      char_type __res[__maxlen];
+
+      // NB: In IEE 1003.1-200x, and perhaps other locale models, it
+      // is possible that the format character will be longer than one
+      // character. Possibilities include 'E' or 'O' followed by a
+      // format character: if __mod is not the default argument, assume
+      // it's a valid modifier.
+      char_type __fmt[4];
+      __fmt[0] = __ctype.widen('%');
+      if (!__mod)
+	{
+	  __fmt[1] = __format;
+	  __fmt[2] = char_type();
+	}
+      else
+	{
+	  __fmt[1] = __mod;
+	  __fmt[2] = __format;
+	  __fmt[3] = char_type();
+	}
+
+      __tp._M_put(__res, __maxlen, __fmt, __tm);
+
+      // Write resulting, fully-formatted string to output iterator.
+      return std::__write(__s, __res, char_traits<char_type>::length(__res));
+    }
+
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class moneypunct<char, false>;
+  extern template class moneypunct<char, true>;
+  extern template class moneypunct_byname<char, false>;
+  extern template class moneypunct_byname<char, true>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL money_get<char>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL money_put<char>;
+  extern template class __timepunct<char>;
+  extern template class time_put<char>;
+  extern template class time_put_byname<char>;
+  extern template class time_get<char>;
+  extern template class time_get_byname<char>;
+  extern template class messages<char>;
+  extern template class messages_byname<char>;
+
+  extern template
+    const moneypunct<char, true>&
+    use_facet<moneypunct<char, true> >(const locale&);
+
+  extern template
+    const moneypunct<char, false>&
+    use_facet<moneypunct<char, false> >(const locale&);
+
+  extern template
+    const money_put<char>&
+    use_facet<money_put<char> >(const locale&);
+
+  extern template
+    const money_get<char>&
+    use_facet<money_get<char> >(const locale&);
+
+  extern template
+    const __timepunct<char>&
+    use_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    const time_put<char>&
+    use_facet<time_put<char> >(const locale&);
+
+  extern template
+    const time_get<char>&
+    use_facet<time_get<char> >(const locale&);
+
+  extern template
+    const messages<char>&
+    use_facet<messages<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<char> >(const locale&);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class moneypunct<wchar_t, false>;
+  extern template class moneypunct<wchar_t, true>;
+  extern template class moneypunct_byname<wchar_t, false>;
+  extern template class moneypunct_byname<wchar_t, true>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL money_get<wchar_t>;
+  extern template class _GLIBCXX_NAMESPACE_LDBL money_put<wchar_t>;
+  extern template class __timepunct<wchar_t>;
+  extern template class time_put<wchar_t>;
+  extern template class time_put_byname<wchar_t>;
+  extern template class time_get<wchar_t>;
+  extern template class time_get_byname<wchar_t>;
+  extern template class messages<wchar_t>;
+  extern template class messages_byname<wchar_t>;
+
+  extern template
+    const moneypunct<wchar_t, true>&
+    use_facet<moneypunct<wchar_t, true> >(const locale&);
+
+  extern template
+    const moneypunct<wchar_t, false>&
+    use_facet<moneypunct<wchar_t, false> >(const locale&);
+
+  extern template
+    const money_put<wchar_t>&
+    use_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    const money_get<wchar_t>&
+    use_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    const __timepunct<wchar_t>&
+    use_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    const time_put<wchar_t>&
+    use_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    const time_get<wchar_t>&
+    use_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    const messages<wchar_t>&
+    use_facet<messages<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<wchar_t> >(const locale&);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/localefwd.h b/gcc-4.9/libstdc++-v3/include/bits/localefwd.h
new file mode 100644
index 0000000..f9983c9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/localefwd.h
@@ -0,0 +1,190 @@
+// <locale> Forward declarations -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/localefwd.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{locale}
+ */
+
+//
+// ISO C++ 14882: 22.1  Locales
+//
+
+#ifndef _LOCALE_FWD_H
+#define _LOCALE_FWD_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/c++locale.h>  // Defines __c_locale, config-specific include
+#include <iosfwd>            // For ostreambuf_iterator, istreambuf_iterator
+#include <cctype>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /** 
+   *  @defgroup locales Locales
+   *
+   *  Classes and functions for internationalization and localization.
+   */
+
+  // 22.1.1 Locale
+  class locale;
+
+  template<typename _Facet>
+    bool
+    has_facet(const locale&) throw();
+
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale&);
+
+  // 22.1.3 Convenience interfaces
+  template<typename _CharT>
+    bool
+    isspace(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isprint(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    iscntrl(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    islower(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalpha(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    ispunct(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isxdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalnum(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isgraph(_CharT, const locale&);
+
+  template<typename _CharT>
+    _CharT
+    toupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    _CharT
+    tolower(_CharT, const locale&);
+
+  // 22.2.1 and 22.2.1.3 ctype
+  class ctype_base;
+  template<typename _CharT>
+    class ctype;
+  template<> class ctype<char>;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<> class ctype<wchar_t>;
+#endif
+  template<typename _CharT>
+    class ctype_byname;
+  // NB: Specialized for char and wchar_t in locale_facets.h.
+
+  class codecvt_base;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt;
+  template<> class codecvt<char, char, mbstate_t>;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<> class codecvt<wchar_t, char, mbstate_t>;
+#endif
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname;
+
+  // 22.2.2 and 22.2.3 numeric
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class num_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class num_put;
+_GLIBCXX_END_NAMESPACE_LDBL
+  template<typename _CharT> class numpunct;
+  template<typename _CharT> class numpunct_byname;
+
+  // 22.2.4 collation
+  template<typename _CharT>
+    class collate;
+  template<typename _CharT> class
+    collate_byname;
+
+  // 22.2.5 date and time
+  class time_base;
+  template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
+    class time_get;
+  template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
+    class time_get_byname;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put_byname;
+
+  // 22.2.6 money
+  class money_base;
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
+  template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
+    class money_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class money_put;
+_GLIBCXX_END_NAMESPACE_LDBL
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct;
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct_byname;
+
+  // 22.2.7 message retrieval
+  class messages_base;
+  template<typename _CharT>
+    class messages;
+  template<typename _CharT>
+    class messages_byname;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/mask_array.h b/gcc-4.9/libstdc++-v3/include/bits/mask_array.h
new file mode 100644
index 0000000..d1b6793
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/mask_array.h
@@ -0,0 +1,208 @@
+// The template and inlines for the -*- C++ -*- mask_array class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/mask_array.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _MASK_ARRAY_H
+#define _MASK_ARRAY_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup numeric_arrays
+   * @{
+   */
+
+  /**
+   *  @brief  Reference to selected subset of an array.
+   *
+   *  A mask_array is a reference to the actual elements of an array specified
+   *  by a bitmask in the form of an array of bool.  The way to get a
+   *  mask_array is to call operator[](valarray<bool>) on a valarray.  The
+   *  returned mask_array then permits carrying operations out on the
+   *  referenced subset of elements in the original valarray.
+   *
+   *  For example, if a mask_array is obtained using the array (false, true,
+   *  false, true) as an argument, the mask array has two elements referring
+   *  to array[1] and array[3] in the underlying array.
+   *
+   *  @param  Tp  Element type.
+   */
+  template <class _Tp>
+    class mask_array
+    {
+    public:
+      typedef _Tp value_type;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 253. valarray helper functions are almost entirely useless
+
+      ///  Copy constructor.  Both slices refer to the same underlying array.
+      mask_array (const mask_array&);
+      
+      ///  Assignment operator.  Assigns elements to corresponding elements
+      ///  of @a a.
+      mask_array& operator=(const mask_array&);
+
+      void operator=(const valarray<_Tp>&) const;
+      ///  Multiply slice elements by corresponding elements of @a v.
+      void operator*=(const valarray<_Tp>&) const;
+      ///  Divide slice elements by corresponding elements of @a v.
+      void operator/=(const valarray<_Tp>&) const;
+      ///  Modulo slice elements by corresponding elements of @a v.
+      void operator%=(const valarray<_Tp>&) const;
+      ///  Add corresponding elements of @a v to slice elements.
+      void operator+=(const valarray<_Tp>&) const;
+      ///  Subtract corresponding elements of @a v from slice elements.
+      void operator-=(const valarray<_Tp>&) const;
+      ///  Logical xor slice elements with corresponding elements of @a v.
+      void operator^=(const valarray<_Tp>&) const;
+      ///  Logical and slice elements with corresponding elements of @a v.
+      void operator&=(const valarray<_Tp>&) const;
+      ///  Logical or slice elements with corresponding elements of @a v.
+      void operator|=(const valarray<_Tp>&) const;
+      ///  Left shift slice elements by corresponding elements of @a v.
+      void operator<<=(const valarray<_Tp>&) const;
+      ///  Right shift slice elements by corresponding elements of @a v.
+      void operator>>=(const valarray<_Tp>&) const;
+      ///  Assign all slice elements to @a t.
+      void operator=(const _Tp&) const;
+
+        //        ~mask_array ();
+
+      template<class _Dom>
+        void operator=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator*=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator/=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator%=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator+=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator-=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator^=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator&=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator|=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator<<=(const _Expr<_Dom,_Tp>&) const;
+      template<class _Dom>
+        void operator>>=(const _Expr<_Dom,_Tp>&) const;
+
+    private:
+      mask_array(_Array<_Tp>, size_t, _Array<bool>);
+      friend class valarray<_Tp>;
+
+      const size_t       _M_sz;
+      const _Array<bool> _M_mask;
+      const _Array<_Tp>  _M_array;
+
+      // not implemented
+      mask_array();
+    };
+
+  template<typename _Tp>
+    inline mask_array<_Tp>::mask_array(const mask_array<_Tp>& a)
+    : _M_sz(a._M_sz), _M_mask(a._M_mask), _M_array(a._M_array) {}
+
+  template<typename _Tp>
+    inline
+    mask_array<_Tp>::mask_array(_Array<_Tp> __a, size_t __s, _Array<bool> __m)
+    : _M_sz(__s), _M_mask(__m), _M_array(__a) {}
+
+  template<typename _Tp>
+    inline mask_array<_Tp>&
+    mask_array<_Tp>::operator=(const mask_array<_Tp>& __a)
+    {
+      std::__valarray_copy(__a._M_array, __a._M_mask,
+			   _M_sz, _M_array, _M_mask);
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline void
+    mask_array<_Tp>::operator=(const _Tp& __t) const
+    { std::__valarray_fill(_M_array, _M_sz, _M_mask, __t); }
+
+  template<typename _Tp>
+    inline void
+    mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const
+    { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); }
+
+  template<typename _Tp>
+    template<class _Ex>
+      inline void
+      mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const
+      { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)				\
+  template<typename _Tp>						\
+    inline void								\
+    mask_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const	\
+    {									\
+      _Array_augmented_##_Name(_M_array, _M_mask,			\
+			       _Array<_Tp>(__v), __v.size());		\
+    }									\
+									\
+  template<typename _Tp>                                                \
+    template<class _Dom>			                        \
+      inline void							\
+      mask_array<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) const\
+      {									\
+	_Array_augmented_##_Name(_M_array, _M_mask, __e, __e.size());   \
+      }
+
+_DEFINE_VALARRAY_OPERATOR(*, __multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, __divides)
+_DEFINE_VALARRAY_OPERATOR(%, __modulus)
+_DEFINE_VALARRAY_OPERATOR(+, __plus)
+_DEFINE_VALARRAY_OPERATOR(-, __minus)
+_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
+_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
+_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
+_DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR
+
+  // @} group numeric_arrays
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _MASK_ARRAY_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/memoryfwd.h b/gcc-4.9/libstdc++-v3/include/bits/memoryfwd.h
new file mode 100644
index 0000000..65d8bd6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/memoryfwd.h
@@ -0,0 +1,78 @@
+// <memory> Forward declarations -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/memoryfwd.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _MEMORYFWD_H
+#define _MEMORYFWD_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup allocators Allocators
+   * @ingroup memory
+   *
+   * Classes encapsulating memory operations.
+   *
+   * @{
+   */
+
+  template<typename>
+    class allocator;
+
+  template<>
+    class allocator<void>;
+
+  /// Declare uses_allocator so it can be specialized in \<queue\> etc.
+  template<typename, typename>
+    struct uses_allocator;
+
+  /// @} group memory
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/move.h b/gcc-4.9/libstdc++-v3/include/bits/move.h
new file mode 100644
index 0000000..dc4ac0f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/move.h
@@ -0,0 +1,198 @@
+// Move, forward and identity for C++0x + swap -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/move.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{utility}
+ */
+
+#ifndef _MOVE_H
+#define _MOVE_H 1
+
+#include <bits/c++config.h>
+#include <bits/concept_check.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Used, in C++03 mode too, by allocators, etc.
+  /**
+   *  @brief Same as C++11 std::addressof
+   *  @ingroup utilities
+   */
+  template<typename _Tp>
+    inline _Tp*
+    __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
+    {
+      return reinterpret_cast<_Tp*>
+	(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if __cplusplus >= 201103L
+#include <type_traits> // Brings in std::declval too.
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @addtogroup utilities
+   *  @{
+   */
+
+  /**
+   *  @brief  Forward an lvalue.
+   *  @return The parameter cast to the specified type.
+   *
+   *  This function is used to implement "perfect forwarding".
+   */
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Tp&&>(__t); }
+
+  /**
+   *  @brief  Forward an rvalue.
+   *  @return The parameter cast to the specified type.
+   *
+   *  This function is used to implement "perfect forwarding".
+   */
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
+    {
+      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
+		    " substituting _Tp is an lvalue reference type");
+      return static_cast<_Tp&&>(__t);
+    }
+
+  /**
+   *  @brief  Convert a value to an rvalue.
+   *  @param  __t  A thing of arbitrary type.
+   *  @return The parameter cast to an rvalue-reference to allow moving it.
+  */
+  template<typename _Tp>
+    constexpr typename std::remove_reference<_Tp>::type&&
+    move(_Tp&& __t) noexcept
+    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
+
+
+  template<typename _Tp>
+    struct __move_if_noexcept_cond
+    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
+                    is_copy_constructible<_Tp>>::type { };
+
+  /**
+   *  @brief  Conditionally convert a value to an rvalue.
+   *  @param  __x  A thing of arbitrary type.
+   *  @return The parameter, possibly cast to an rvalue-reference.
+   *
+   *  Same as std::move unless the type's move constructor could throw and the
+   *  type is copyable, in which case an lvalue-reference is returned instead.
+   */
+  template<typename _Tp>
+    constexpr typename
+    conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
+    move_if_noexcept(_Tp& __x) noexcept
+    { return std::move(__x); }
+
+  // declval, from type_traits.
+
+  /**
+   *  @brief Returns the actual address of the object or function
+   *         referenced by r, even in the presence of an overloaded
+   *         operator&.
+   *  @param  __r  Reference to an object or function.
+   *  @return   The actual address.
+  */
+  template<typename _Tp>
+    inline _Tp*
+    addressof(_Tp& __r) noexcept
+    { return std::__addressof(__r); }
+
+  /// @} group utilities
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#define _GLIBCXX_MOVE(__val) std::move(__val)
+#define _GLIBCXX_FORWARD(_Tp, __val) std::forward<_Tp>(__val)
+#else
+#define _GLIBCXX_MOVE(__val) (__val)
+#define _GLIBCXX_FORWARD(_Tp, __val) (__val)
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @addtogroup utilities
+   *  @{
+   */
+
+  /**
+   *  @brief Swaps two values.
+   *  @param  __a  A thing of arbitrary type.
+   *  @param  __b  Another thing of arbitrary type.
+   *  @return   Nothing.
+  */
+  template<typename _Tp>
+    inline void
+    swap(_Tp& __a, _Tp& __b)
+#if __cplusplus >= 201103L
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+	            is_nothrow_move_assignable<_Tp>>::value)
+#endif
+    {
+      // concept requirements
+      __glibcxx_function_requires(_SGIAssignableConcept<_Tp>)
+
+      _Tp __tmp = _GLIBCXX_MOVE(__a);
+      __a = _GLIBCXX_MOVE(__b);
+      __b = _GLIBCXX_MOVE(__tmp);
+    }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 809. std::swap should be overloaded for array types.
+  /// Swap the contents of two arrays.
+  template<typename _Tp, size_t _Nm>
+    inline void
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+#if __cplusplus >= 201103L
+    noexcept(noexcept(swap(*__a, *__b)))
+#endif
+    {
+      for (size_t __n = 0; __n < _Nm; ++__n)
+	swap(__a[__n], __b[__n]);
+    }
+
+  /// @} group utilities
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _MOVE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/ostream.tcc b/gcc-4.9/libstdc++-v3/include/bits/ostream.tcc
new file mode 100644
index 0000000..a3a8695
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/ostream.tcc
@@ -0,0 +1,407 @@
+// ostream classes -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/ostream.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ostream}
+ */
+
+//
+// ISO C++ 14882: 27.6.2  Output streams
+//
+
+#ifndef _OSTREAM_TCC
+#define _OSTREAM_TCC 1
+
+#pragma GCC system_header
+
+#include <bits/cxxabi_forced.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>::sentry::
+    sentry(basic_ostream<_CharT, _Traits>& __os)
+    : _M_ok(false), _M_os(__os)
+    {
+      // XXX MT
+      if (__os.tie() && __os.good())
+	__os.tie()->flush();
+
+      if (__os.good())
+	_M_ok = true;
+      else
+	__os.setstate(ios_base::failbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_ostream<_CharT, _Traits>&
+      basic_ostream<_CharT, _Traits>::
+      _M_insert(_ValueT __v)
+      {
+	sentry __cerb(*this);
+	if (__cerb)
+	  {
+	    ios_base::iostate __err = ios_base::goodbit;
+	    __try
+	      {
+		const __num_put_type& __np = __check_facet(this->_M_num_put);
+		if (__np.put(*this, *this, this->fill(), __v).failed())
+		  __err |= ios_base::badbit;
+	      }
+	    __catch(__cxxabiv1::__forced_unwind&)
+	      {
+		this->_M_setstate(ios_base::badbit);		
+		__throw_exception_again;
+	      }
+	    __catch(...)
+	      { this->_M_setstate(ios_base::badbit); }
+	    if (__err)
+	      this->setstate(__err);
+	  }
+	return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(short __n)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 117. basic_ostream uses nonexistent num_put member functions.
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+	return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
+      else
+	return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(int __n)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 117. basic_ostream uses nonexistent num_put member functions.
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+	return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
+      else
+	return _M_insert(static_cast<long>(__n));
+    }
+  
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(__streambuf_type* __sbin)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this);
+      if (__cerb && __sbin)
+	{
+	  __try
+	    {
+	      if (!__copy_streambufs(__sbin, this->rdbuf()))
+		__err |= ios_base::failbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);		
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::failbit); }
+	}
+      else if (!__sbin)
+	__err |= ios_base::badbit;
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    put(char_type __c)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 60. What is a formatted input function?
+      // basic_ostream::put(char_type) is an unformatted output function.
+      // DR 63. Exception-handling policy for unformatted output.
+      // Unformatted output functions should catch exceptions thrown
+      // from streambuf members.
+      sentry __cerb(*this);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      const int_type __put = this->rdbuf()->sputc(__c);
+	      if (traits_type::eq_int_type(__put, traits_type::eof()))
+		__err |= ios_base::badbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);		
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	  if (__err)
+	    this->setstate(__err);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    write(const _CharT* __s, streamsize __n)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 60. What is a formatted input function?
+      // basic_ostream::write(const char_type*, streamsize) is an
+      // unformatted output function.
+      // DR 63. Exception-handling policy for unformatted output.
+      // Unformatted output functions should catch exceptions thrown
+      // from streambuf members.
+      sentry __cerb(*this);
+      if (__cerb)
+	{
+	  __try
+	    { _M_write(__s, __n); }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      this->_M_setstate(ios_base::badbit);		
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { this->_M_setstate(ios_base::badbit); }
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    flush()
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 60. What is a formatted input function?
+      // basic_ostream::flush() is *not* an unformatted output function.
+      ios_base::iostate __err = ios_base::goodbit;
+      __try
+	{
+	  if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
+	    __err |= ios_base::badbit;
+	}
+      __catch(__cxxabiv1::__forced_unwind&)
+	{
+	  this->_M_setstate(ios_base::badbit);		
+	  __throw_exception_again;
+	}
+      __catch(...)
+	{ this->_M_setstate(ios_base::badbit); }
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_ostream<_CharT, _Traits>::pos_type
+    basic_ostream<_CharT, _Traits>::
+    tellp()
+    {
+      pos_type __ret = pos_type(-1);
+      __try
+	{
+	  if (!this->fail())
+	    __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+	}
+      __catch(__cxxabiv1::__forced_unwind&)
+	{
+	  this->_M_setstate(ios_base::badbit);		
+	  __throw_exception_again;
+	}
+      __catch(...)
+	{ this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(pos_type __pos)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      __try
+	{
+	  if (!this->fail())
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 136.  seekp, seekg setting wrong streams?
+	      const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+							     ios_base::out);
+
+	      // 129. Need error indication from seekp() and seekg()
+	      if (__p == pos_type(off_type(-1)))
+		__err |= ios_base::failbit;
+	    }
+	}
+      __catch(__cxxabiv1::__forced_unwind&)
+	{
+	  this->_M_setstate(ios_base::badbit);		
+	  __throw_exception_again;
+	}
+      __catch(...)
+	{ this->_M_setstate(ios_base::badbit); }
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(off_type __off, ios_base::seekdir __dir)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      __try
+	{
+	  if (!this->fail())
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 136.  seekp, seekg setting wrong streams?
+	      const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+							     ios_base::out);
+
+	      // 129. Need error indication from seekp() and seekg()
+	      if (__p == pos_type(off_type(-1)))
+		__err |= ios_base::failbit;
+	    }
+	}
+      __catch(__cxxabiv1::__forced_unwind&)
+	{
+	  this->_M_setstate(ios_base::badbit);		
+	  __throw_exception_again;
+	}
+      __catch(...)
+	{ this->_M_setstate(ios_base::badbit); }
+      if (__err)
+	this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+	__out.setstate(ios_base::badbit);
+      else
+	{
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 167.  Improper use of traits_type::length()
+	  const size_t __clen = char_traits<char>::length(__s);
+	  __try
+	    {
+	      struct __ptr_guard
+	      {
+		_CharT *__p;
+		__ptr_guard (_CharT *__ip): __p(__ip) { }
+		~__ptr_guard() { delete[] __p; }
+		_CharT* __get() { return __p; }
+	      } __pg (new _CharT[__clen]);
+
+	      _CharT *__ws = __pg.__get();
+	      for (size_t  __i = 0; __i < __clen; ++__i)
+		__ws[__i] = __out.widen(__s[__i]);
+	      __ostream_insert(__out, __ws, __clen);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __out._M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __out._M_setstate(ios_base::badbit); }
+	}
+      return __out;
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class basic_ostream<char>;
+  extern template ostream& endl(ostream&);
+  extern template ostream& ends(ostream&);
+  extern template ostream& flush(ostream&);
+  extern template ostream& operator<<(ostream&, char);
+  extern template ostream& operator<<(ostream&, unsigned char);
+  extern template ostream& operator<<(ostream&, signed char);
+  extern template ostream& operator<<(ostream&, const char*);
+  extern template ostream& operator<<(ostream&, const unsigned char*);
+  extern template ostream& operator<<(ostream&, const signed char*);
+
+  extern template ostream& ostream::_M_insert(long);
+  extern template ostream& ostream::_M_insert(unsigned long);
+  extern template ostream& ostream::_M_insert(bool);
+#ifdef _GLIBCXX_USE_LONG_LONG
+  extern template ostream& ostream::_M_insert(long long);
+  extern template ostream& ostream::_M_insert(unsigned long long);
+#endif
+  extern template ostream& ostream::_M_insert(double);
+  extern template ostream& ostream::_M_insert(long double);
+  extern template ostream& ostream::_M_insert(const void*);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_ostream<wchar_t>;
+  extern template wostream& endl(wostream&);
+  extern template wostream& ends(wostream&);
+  extern template wostream& flush(wostream&);
+  extern template wostream& operator<<(wostream&, wchar_t);
+  extern template wostream& operator<<(wostream&, char);
+  extern template wostream& operator<<(wostream&, const wchar_t*);
+  extern template wostream& operator<<(wostream&, const char*);
+
+  extern template wostream& wostream::_M_insert(long);
+  extern template wostream& wostream::_M_insert(unsigned long);
+  extern template wostream& wostream::_M_insert(bool);
+#ifdef _GLIBCXX_USE_LONG_LONG
+  extern template wostream& wostream::_M_insert(long long);
+  extern template wostream& wostream::_M_insert(unsigned long long);
+#endif
+  extern template wostream& wostream::_M_insert(double);
+  extern template wostream& wostream::_M_insert(long double);
+  extern template wostream& wostream::_M_insert(const void*);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/ostream_insert.h b/gcc-4.9/libstdc++-v3/include/bits/ostream_insert.h
new file mode 100644
index 0000000..4447586
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/ostream_insert.h
@@ -0,0 +1,129 @@
+// Helpers for ostream inserters -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/ostream_insert.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ostream}
+ */
+
+#ifndef _OSTREAM_INSERT_H
+#define _OSTREAM_INSERT_H 1
+
+#pragma GCC system_header
+
+#include <iosfwd>
+#include <bits/cxxabi_forced.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+		    const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits>       __ostream_type;      
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+	__out.setstate(__ios_base::badbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits>       __ostream_type;      
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+	{
+	  const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+	  if (_Traits::eq_int_type(__put, _Traits::eof()))
+	    {
+	      __out.setstate(__ios_base::badbit);
+	      break;
+	    }
+	}
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+		     const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits>       __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      const streamsize __w = __out.width();
+	      if (__w > __n)
+		{
+		  const bool __left = ((__out.flags()
+					& __ios_base::adjustfield)
+				       == __ios_base::left);
+		  if (!__left)
+		    __ostream_fill(__out, __w - __n);
+		  if (__out.good())
+		    __ostream_write(__out, __s, __n);
+		  if (__left && __out.good())
+		    __ostream_fill(__out, __w - __n);
+		}
+	      else
+		__ostream_write(__out, __s, __n);
+	      __out.width(0);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __out._M_setstate(__ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __out._M_setstate(__ios_base::badbit); }
+	}
+      return __out;
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+					     streamsize);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif /* _OSTREAM_INSERT_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/parse_numbers.h b/gcc-4.9/libstdc++-v3/include/bits/parse_numbers.h
new file mode 100644
index 0000000..91a127c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/parse_numbers.h
@@ -0,0 +1,417 @@
+// Components for compile-time parsing of numbers -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/parse_numbers.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{chrono}
+ */
+
+#ifndef _PARSE_NUMBERS_H
+#define _PARSE_NUMBERS_H 1
+
+#pragma GCC system_header
+
+// From n3642.pdf except I added binary literals and digit separator '\''.
+
+#if __cplusplus > 201103L
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+namespace __parse_int {
+
+  template<unsigned _Base, char _Dig>
+    struct _Digit;
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '0'>
+    {
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '1'>
+    {
+      static constexpr bool valid{true};
+      static constexpr unsigned value{1};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '2'>
+    {
+      static_assert(_Base > 2, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{2};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '3'>
+    {
+      static_assert(_Base > 3, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{3};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '4'>
+    {
+      static_assert(_Base > 4, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{4};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '5'>
+    {
+      static_assert(_Base > 5, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{5};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '6'>
+    {
+      static_assert(_Base > 6, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{6};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '7'>
+    {
+      static_assert(_Base > 7, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{7};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '8'>
+    {
+      static_assert(_Base > 8, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{8};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '9'>
+    {
+      static_assert(_Base > 9, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{9};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'a'>
+    {
+      static_assert(_Base > 0xa, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xa};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'A'>
+    {
+      static_assert(_Base > 0xa, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xa};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'b'>
+    {
+      static_assert(_Base > 0xb, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xb};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'B'>
+    {
+      static_assert(_Base > 0xb, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xb};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'c'>
+    {
+      static_assert(_Base > 0xc, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xc};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'C'>
+    {
+      static_assert(_Base > 0xc, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xc};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'd'>
+    {
+      static_assert(_Base > 0xd, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xd};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'D'>
+    {
+      static_assert(_Base > 0xd, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xd};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'e'>
+    {
+      static_assert(_Base > 0xe, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xe};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'E'>
+    {
+      static_assert(_Base > 0xe, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xe};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'f'>
+    {
+      static_assert(_Base > 0xf, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xf};
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'F'>
+    {
+      static_assert(_Base > 0xf, "invalid digit");
+      static constexpr bool valid{true};
+      static constexpr unsigned value{0xf};
+    };
+
+  //  Digit separator
+  template<unsigned _Base>
+    struct _Digit<_Base, '\''>
+    {
+      static constexpr bool valid{false};
+      static constexpr unsigned value{0};
+    };
+
+
+//------------------------------------------------------------------------------
+
+  template<unsigned _Base, char _Dig, char... _Digs>
+    struct _Digits_help
+    {
+      static constexpr unsigned
+	value{_Digit<_Base, _Dig>::valid ?
+	      1U + _Digits_help<_Base, _Digs...>::value :
+	      _Digits_help<_Base, _Digs...>::value};
+    };
+
+  template<unsigned _Base, char _Dig>
+    struct _Digits_help<_Base, _Dig>
+    {
+      static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U};
+    };
+
+  template<unsigned _Base, char... _Digs>
+    struct _Digits
+    {
+      static constexpr unsigned value{_Digits_help<_Base, _Digs...>::value};
+    };
+
+  template<unsigned _Base>
+    struct _Digits<_Base>
+    {
+      static constexpr unsigned value{0U};
+    };
+
+//------------------------------------------------------------------------------
+
+  template<unsigned _Base, char _Dig, char... _Digs>
+    struct _Power_help
+    {
+      static constexpr unsigned
+	value{_Digit<_Base, _Dig>::valid ?
+	      _Base * _Power_help<_Base, _Digs...>::value :
+	      _Power_help<_Base, _Digs...>::value};
+    };
+
+  template<unsigned _Base, char _Dig>
+    struct _Power_help<_Base, _Dig>
+    {
+      static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U};
+    };
+
+  template<unsigned _Base, char... _Digs>
+    struct _Power
+    {
+      static constexpr unsigned value{_Power_help<_Base, _Digs...>::value};
+    };
+
+  template<unsigned _Base>
+    struct _Power<_Base>
+    {
+      static constexpr unsigned value{0U};
+    };
+
+//------------------------------------------------------------------------------
+
+  template<unsigned _Base, unsigned _Pow, char _Dig, char... _Digs>
+    struct _Number_help
+    {
+      static constexpr unsigned
+	value{_Digit<_Base, _Dig>::valid ?
+	      _Pow * _Digit<_Base, _Dig>::value
+	      + _Number_help<_Base, _Pow / _Base, _Digs...>::value :
+	      _Number_help<_Base, _Pow, _Digs...>::value};
+    };
+
+  template<unsigned _Base, unsigned _Pow, char _Dig>
+    struct _Number_help<_Base, _Pow, _Dig>
+    {
+      //static_assert(_Pow == 1U, "power should be one");
+      static constexpr unsigned
+	value{_Digit<_Base, _Dig>::valid ? _Digit<_Base, _Dig>::value : 0U};
+    };
+
+  template<unsigned _Base, char... _Digs>
+    struct _Number
+    {
+      static constexpr unsigned
+	value{_Number_help<_Base, _Power<_Base, _Digs...>::value,
+			   _Digs...>::value};
+    };
+
+  template<unsigned _Base>
+    struct _Number<_Base>
+    {
+      static constexpr unsigned value{0U};
+    };
+
+//------------------------------------------------------------------------------
+//  This _Parse_int is the same 'level' as the old _Base_dispatch.
+
+  template<char... _Digs>
+    struct _Parse_int;
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'b', _Digs...>
+    {
+      static constexpr unsigned long long
+	value{_Number<2U, _Digs...>::value};
+    };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'B', _Digs...>
+    {
+      static constexpr unsigned long long
+	value{_Number<2U, _Digs...>::value};
+    };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'x', _Digs...>
+    {
+      static constexpr unsigned long long
+	value{_Number<16U, _Digs...>::value};
+    };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'X', _Digs...>
+    {
+      static constexpr unsigned long long
+	value{_Number<16U, _Digs...>::value};
+    };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', _Digs...>
+    {
+      static constexpr unsigned long long
+	value{_Number<8U, _Digs...>::value};
+    };
+
+  template<char... _Digs>
+    struct _Parse_int
+    {
+      static constexpr unsigned long long
+	value{_Number<10U, _Digs...>::value};
+    };
+
+} // namespace __parse_int
+
+
+namespace __select_int {
+
+  template<unsigned long long _Val, typename... _Ints>
+    struct _Select_int_base;
+
+  template<unsigned long long _Val, typename _IntType, typename... _Ints>
+    struct _Select_int_base<_Val, _IntType, _Ints...>
+    : integral_constant
+      <
+	typename conditional
+	<
+	  _Val <= static_cast<unsigned long long>
+		    (std::numeric_limits<_IntType>::max()),
+	  _IntType,
+	  typename _Select_int_base<_Val, _Ints...>::value_type
+	>::type,
+	_Val
+      >
+    { };
+
+  template<unsigned long long _Val>
+    struct _Select_int_base<_Val> : integral_constant<unsigned long long, _Val>
+    { };
+
+  template<char... _Digs>
+    struct _Select_int
+    : _Select_int_base<
+	__parse_int::_Parse_int<_Digs...>::value,
+	unsigned char,
+	unsigned short,
+	unsigned int,
+	unsigned long,
+	unsigned long long
+      >
+    { };
+
+} // namespace __select_int
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // __cplusplus > 201103L
+
+#endif // _PARSE_NUMBERS_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/postypes.h b/gcc-4.9/libstdc++-v3/include/bits/postypes.h
new file mode 100644
index 0000000..158f5d0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/postypes.h
@@ -0,0 +1,242 @@
+// Position types -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/postypes.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iosfwd}
+ */
+
+//
+// ISO C++ 14882: 27.4.1 - Types
+// ISO C++ 14882: 27.4.3 - Template class fpos
+//
+
+#ifndef _GLIBCXX_POSTYPES_H
+#define _GLIBCXX_POSTYPES_H 1
+
+#pragma GCC system_header
+
+#include <cwchar> // For mbstate_t
+
+// XXX If <stdint.h> is really needed, make sure to define the macros
+// before including it, in order not to break <tr1/cstdint> (and <cstdint>
+// in C++0x).  Reconsider all this as soon as possible...
+#if (defined(_GLIBCXX_HAVE_INT64_T) && !defined(_GLIBCXX_HAVE_INT64_T_LONG) \
+     && !defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG))
+
+#ifndef __STDC_LIMIT_MACROS
+# define _UNDEF__STDC_LIMIT_MACROS
+# define __STDC_LIMIT_MACROS
+#endif
+#ifndef __STDC_CONSTANT_MACROS
+# define _UNDEF__STDC_CONSTANT_MACROS
+# define __STDC_CONSTANT_MACROS
+#endif
+#include <stdint.h> // For int64_t
+#ifdef _UNDEF__STDC_LIMIT_MACROS
+# undef __STDC_LIMIT_MACROS
+# undef _UNDEF__STDC_LIMIT_MACROS
+#endif
+#ifdef _UNDEF__STDC_CONSTANT_MACROS
+# undef __STDC_CONSTANT_MACROS
+# undef _UNDEF__STDC_CONSTANT_MACROS
+#endif
+
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // The types streamoff, streampos and wstreampos and the class
+  // template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2,
+  // 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbiage, the
+  // behaviour of these types is mostly implementation defined or
+  // unspecified. The behaviour in this implementation is as noted
+  // below.
+
+  /**
+   *  @brief  Type used by fpos, char_traits<char>, and char_traits<wchar_t>.
+   *
+   *  In clauses 21.1.3.1 and 27.4.1 streamoff is described as an
+   *  implementation defined type.
+   *  Note: In versions of GCC up to and including GCC 3.3, streamoff
+   *  was typedef long.
+  */  
+#ifdef _GLIBCXX_HAVE_INT64_T_LONG
+  typedef long          streamoff;
+#elif defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG)
+  typedef long long     streamoff;
+#elif defined(_GLIBCXX_HAVE_INT64_T) 
+  typedef int64_t       streamoff;
+#else
+  typedef long long     streamoff;
+#endif
+
+  /// Integral type for I/O operation counts and buffer sizes.
+  typedef ptrdiff_t	streamsize; // Signed integral type
+
+  /**
+   *  @brief  Class representing stream positions.
+   *
+   *  The standard places no requirements upon the template parameter StateT.
+   *  In this implementation StateT must be DefaultConstructible,
+   *  CopyConstructible and Assignable.  The standard only requires that fpos
+   *  should contain a member of type StateT. In this implementation it also
+   *  contains an offset stored as a signed integer.
+   *
+   *  @param  StateT  Type passed to and returned from state().
+   */
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff	                _M_off;
+      _StateT			_M_state;
+
+    public:
+      // The standard doesn't require that fpos objects can be default
+      // constructed. This implementation provides a default
+      // constructor that initializes the offset to 0 and default
+      // constructs the state.
+      fpos()
+      : _M_off(0), _M_state() { }
+
+      // The standard requires that fpos objects can be constructed
+      // from streamoff objects using the constructor syntax, and
+      // fails to give any meaningful semantics. In this
+      // implementation implicit conversion is also allowed, and this
+      // constructor stores the streamoff as the offset and default
+      // constructs the state.
+      /// Construct position from offset.
+      fpos(streamoff __off)
+      : _M_off(__off), _M_state() { }
+
+      /// Convert to streamoff.
+      operator streamoff() const { return _M_off; }
+
+      /// Remember the value of @a st.
+      void
+      state(_StateT __st)
+      { _M_state = __st; }
+
+      /// Return the last set value of @a st.
+      _StateT
+      state() const
+      { return _M_state; }
+
+      // The standard requires that this operator must be defined, but
+      // gives no semantics. In this implementation it just adds its
+      // argument to the stored offset and returns *this.
+      /// Add offset to this position.
+      fpos&
+      operator+=(streamoff __off)
+      {
+	_M_off += __off;
+	return *this;
+      }
+
+      // The standard requires that this operator must be defined, but
+      // gives no semantics. In this implementation it just subtracts
+      // its argument from the stored offset and returns *this.
+      /// Subtract offset from this position.
+      fpos&
+      operator-=(streamoff __off)
+      {
+	_M_off -= __off;
+	return *this;
+      }
+
+      // The standard requires that this operator must be defined, but
+      // defines its semantics only in terms of operator-. In this
+      // implementation it constructs a copy of *this, adds the
+      // argument to that copy using operator+= and then returns the
+      // copy.
+      /// Add position and offset.
+      fpos
+      operator+(streamoff __off) const
+      {
+	fpos __pos(*this);
+	__pos += __off;
+	return __pos;
+      }
+
+      // The standard requires that this operator must be defined, but
+      // defines its semantics only in terms of operator+. In this
+      // implementation it constructs a copy of *this, subtracts the
+      // argument from that copy using operator-= and then returns the
+      // copy.
+      /// Subtract offset from position.
+      fpos
+      operator-(streamoff __off) const
+      {
+	fpos __pos(*this);
+	__pos -= __off;
+	return __pos;
+      }
+
+      // The standard requires that this operator must be defined, but
+      // defines its semantics only in terms of operator+. In this
+      // implementation it returns the difference between the offset
+      // stored in *this and in the argument.
+      /// Subtract position to return offset.
+      streamoff
+      operator-(const fpos& __other) const
+      { return _M_off - __other._M_off; }
+    };
+
+  // The standard only requires that operator== must be an
+  // equivalence relation. In this implementation two fpos<StateT>
+  // objects belong to the same equivalence class if the contained
+  // offsets compare equal.
+  /// Test if equivalent to another position.
+  template<typename _StateT>
+    inline bool
+    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) == streamoff(__rhs); }
+
+  template<typename _StateT>
+    inline bool
+    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) != streamoff(__rhs); }
+
+  // Clauses 21.1.3.1 and 21.1.3.2 describe streampos and wstreampos
+  // as implementation defined types, but clause 27.2 requires that
+  // they must both be typedefs for fpos<mbstate_t>
+  /// File position for char streams.
+  typedef fpos<mbstate_t> streampos;
+  /// File position for wchar_t streams.
+  typedef fpos<mbstate_t> wstreampos;
+
+#if __cplusplus >= 201103L
+  /// File position for char16_t streams.
+  typedef fpos<mbstate_t> u16streampos;
+  /// File position for char32_t streams.
+  typedef fpos<mbstate_t> u32streampos;
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/predefined_ops.h b/gcc-4.9/libstdc++-v3/include/bits/predefined_ops.h
new file mode 100644
index 0000000..78f5e37
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/predefined_ops.h
@@ -0,0 +1,304 @@
+// Default predicates for internal use -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file predefined_ops.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+#ifndef _GLIBCXX_PREDEFINED_OPS_H
+#define _GLIBCXX_PREDEFINED_OPS_H	1
+
+namespace __gnu_cxx
+{
+namespace __ops
+{
+  struct _Iter_less_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 < *__it2; }
+  };
+
+  inline _Iter_less_iter
+  __iter_less_iter()
+  { return _Iter_less_iter(); }
+
+  struct _Iter_less_val
+  {
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it < __val; }
+    };
+
+  inline _Iter_less_val
+  __iter_less_val()
+  { return _Iter_less_val(); }
+
+  inline _Iter_less_val
+  __iter_comp_val(_Iter_less_iter)
+  { return _Iter_less_val(); }
+
+  struct _Val_less_iter
+  {
+    template<typename _Value, typename _Iterator>
+      bool
+      operator()(_Value& __val, _Iterator __it) const
+      { return __val < *__it; }
+    };
+
+  inline _Val_less_iter
+  __val_less_iter()
+  { return _Val_less_iter(); }
+
+  inline _Val_less_iter
+  __val_comp_iter(_Iter_less_iter)
+  { return _Val_less_iter(); }
+
+  struct _Iter_equal_to_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 == *__it2; }
+    };
+
+  inline _Iter_equal_to_iter
+  __iter_equal_to_iter()
+  { return _Iter_equal_to_iter(); }
+
+  struct _Iter_equal_to_val
+  {
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it == __val; }
+    };
+
+  inline _Iter_equal_to_val
+  __iter_equal_to_val()
+  { return _Iter_equal_to_val(); }
+
+  inline _Iter_equal_to_val
+  __iter_comp_val(_Iter_equal_to_iter)
+  { return _Iter_equal_to_val(); }
+
+  template<typename _Compare>
+    struct _Iter_comp_iter
+    {
+      _Compare _M_comp;
+
+      _Iter_comp_iter(_Compare __comp)
+	: _M_comp(__comp)
+      { }
+
+      template<typename _Iterator1, typename _Iterator2>
+        bool
+        operator()(_Iterator1 __it1, _Iterator2 __it2)
+        { return bool(_M_comp(*__it1, *__it2)); }
+    };
+
+  template<typename _Compare>
+    inline _Iter_comp_iter<_Compare>
+    __iter_comp_iter(_Compare __comp)
+    { return _Iter_comp_iter<_Compare>(__comp); }
+
+  template<typename _Compare>
+    struct _Iter_comp_val
+    {
+      _Compare _M_comp;
+
+      _Iter_comp_val(_Compare __comp)
+	: _M_comp(__comp)
+      { }
+
+      template<typename _Iterator, typename _Value>
+	bool
+	operator()(_Iterator __it, _Value& __val)
+	{ return bool(_M_comp(*__it, __val)); }
+    };
+
+  template<typename _Compare>
+   inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Compare __comp)
+    { return _Iter_comp_val<_Compare>(__comp); }
+
+  template<typename _Compare>
+    inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
+    { return _Iter_comp_val<_Compare>(__comp._M_comp); }
+
+  template<typename _Compare>
+    struct _Val_comp_iter
+    {
+      _Compare _M_comp;
+
+      _Val_comp_iter(_Compare __comp)
+	: _M_comp(__comp)
+      { }
+
+      template<typename _Value, typename _Iterator>
+	bool
+	operator()(_Value& __val, _Iterator __it)
+	{ return bool(_M_comp(__val, *__it)); }
+    };
+
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Compare __comp)
+    { return _Val_comp_iter<_Compare>(__comp); }
+
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
+    { return _Val_comp_iter<_Compare>(__comp._M_comp); }
+
+  template<typename _Value>
+    struct _Iter_equals_val
+    {
+      _Value& _M_value;
+
+      _Iter_equals_val(_Value& __value)
+	: _M_value(__value)
+      { }
+
+      template<typename _Iterator>
+	bool
+	operator()(_Iterator __it)
+	{ return *__it == _M_value; }
+    };
+
+  template<typename _Value>
+    inline _Iter_equals_val<_Value>
+    __iter_equals_val(_Value& __val)
+    { return _Iter_equals_val<_Value>(__val); }
+
+  template<typename _Iterator1>
+    struct _Iter_equals_iter
+    {
+      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+
+      _Iter_equals_iter(_Iterator1 __it1)
+	: _M_ref(*__it1)
+      { }
+
+      template<typename _Iterator2>
+	bool
+	operator()(_Iterator2 __it2)
+	{ return *__it2 == _M_ref; }
+    };
+
+  template<typename _Iterator>
+    inline _Iter_equals_iter<_Iterator>
+    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
+    { return _Iter_equals_iter<_Iterator>(__it); }
+
+  template<typename _Predicate>
+    struct _Iter_pred
+    {
+      _Predicate _M_pred;
+
+      _Iter_pred(_Predicate __pred)
+	: _M_pred(__pred)
+      { }
+
+      template<typename _Iterator>
+	bool
+	operator()(_Iterator __it)
+	{ return bool(_M_pred(*__it)); }
+    };
+
+  template<typename _Predicate>
+    inline _Iter_pred<_Predicate>
+    __pred_iter(_Predicate __pred)
+    { return _Iter_pred<_Predicate>(__pred); }
+
+  template<typename _Compare, typename _Value>
+    struct _Iter_comp_to_val
+    {
+      _Compare _M_comp;
+      _Value& _M_value;
+
+      _Iter_comp_to_val(_Compare __comp, _Value& __value)
+	: _M_comp(__comp), _M_value(__value)
+      { }
+
+      template<typename _Iterator>
+	bool
+	operator()(_Iterator __it)
+	{ return bool(_M_comp(*__it, _M_value)); }
+    };
+
+  template<typename _Compare, typename _Value>
+    _Iter_comp_to_val<_Compare, _Value>
+    __iter_comp_val(_Compare __comp, _Value &__val)
+    { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }
+
+  template<typename _Compare, typename _Iterator1>
+    struct _Iter_comp_to_iter
+    {
+      _Compare _M_comp;
+      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+
+      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
+	: _M_comp(__comp), _M_ref(*__it1)
+      { }
+
+      template<typename _Iterator2>
+	bool
+	operator()(_Iterator2 __it2)
+	{ return bool(_M_comp(*__it2, _M_ref)); }
+    };
+
+  template<typename _Compare, typename _Iterator>
+    inline _Iter_comp_to_iter<_Compare, _Iterator>
+    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
+    { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }
+
+  template<typename _Predicate>
+    struct _Iter_negate
+    {
+      _Predicate _M_pred;
+
+      _Iter_negate(_Predicate __pred)
+	: _M_pred(__pred)
+      { }
+
+      template<typename _Iterator>
+	bool
+	operator()(_Iterator __it)
+	{ return !bool(_M_pred(*__it)); }
+    };
+
+  template<typename _Predicate>
+    inline _Iter_negate<_Predicate>
+    __negate(_Iter_pred<_Predicate> __pred)
+    { return _Iter_negate<_Predicate>(__pred._M_pred); }
+
+} // namespace __ops
+} // namespace __gnu_cxx
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/ptr_traits.h b/gcc-4.9/libstdc++-v3/include/bits/ptr_traits.h
new file mode 100644
index 0000000..94995c8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/ptr_traits.h
@@ -0,0 +1,177 @@
+// Pointer Traits -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/ptr_traits.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _PTR_TRAITS_H
+#define _PTR_TRAITS_H 1
+
+#if __cplusplus >= 201103L
+
+#include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+_GLIBCXX_HAS_NESTED_TYPE(element_type)
+_GLIBCXX_HAS_NESTED_TYPE(difference_type)
+
+  template<typename _Tp, bool = __has_element_type<_Tp>::value>
+    struct __ptrtr_elt_type;
+
+  template<typename _Tp>
+    struct __ptrtr_elt_type<_Tp, true>
+    {
+      typedef typename _Tp::element_type __type;
+    };
+
+  template<template<typename, typename...> class _SomePtr, typename _Tp,
+            typename... _Args>
+    struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false>
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp, bool = __has_difference_type<_Tp>::value>
+    struct __ptrtr_diff_type
+    {
+      typedef typename _Tp::difference_type __type;
+    };
+
+  template<typename _Tp>
+    struct __ptrtr_diff_type<_Tp, false>
+    {
+      typedef ptrdiff_t __type;
+    };
+
+  template<typename _Ptr, typename _Up>
+    class __ptrtr_rebind_helper
+    {
+      template<typename _Ptr2, typename _Up2>
+	static constexpr true_type
+	_S_chk(typename _Ptr2::template rebind<_Up2>*);
+
+      template<typename, typename>
+	static constexpr false_type
+	_S_chk(...);
+
+    public:
+      using __type = decltype(_S_chk<_Ptr, _Up>(nullptr));
+    };
+
+  template<typename _Tp, typename _Up,
+           bool = __ptrtr_rebind_helper<_Tp, _Up>::__type::value>
+    struct __ptrtr_rebind;
+
+  template<typename _Tp, typename _Up>
+    struct __ptrtr_rebind<_Tp, _Up, true>
+    {
+      typedef typename _Tp::template rebind<_Up> __type;
+    };
+
+  template<template<typename, typename...> class _SomePtr, typename _Up,
+            typename _Tp, typename... _Args>
+    struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false>
+    {
+      typedef _SomePtr<_Up, _Args...> __type;
+    };
+
+  template<typename _Tp, typename = typename remove_cv<_Tp>::type>
+    struct __ptrtr_not_void
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp>
+    struct __ptrtr_not_void<_Tp, void>
+    {
+      struct __type { };
+    };
+
+  template<typename _Ptr>
+    class __ptrtr_pointer_to
+    {
+      typedef typename __ptrtr_elt_type<_Ptr>::__type   __orig_type;
+      typedef typename __ptrtr_not_void<__orig_type>::__type __element_type;
+
+    public:
+      static _Ptr pointer_to(__element_type& __e)
+      { return _Ptr::pointer_to(__e); }
+    };
+
+  /**
+   * @brief  Uniform interface to all pointer-like types
+   * @ingroup pointer_abstractions
+  */
+  template<typename _Ptr>
+    struct pointer_traits : __ptrtr_pointer_to<_Ptr>
+    {
+      /// The pointer type
+      typedef _Ptr                                      pointer;
+      /// The type pointed to
+      typedef typename __ptrtr_elt_type<_Ptr>::__type   element_type;
+      /// Type used to represent the difference between two pointers
+      typedef typename __ptrtr_diff_type<_Ptr>::__type  difference_type;
+
+      template<typename _Up>
+        using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type;
+    };
+
+  /**
+   * @brief  Partial specialization for built-in pointers.
+   * @ingroup pointer_abstractions
+  */
+  template<typename _Tp>
+    struct pointer_traits<_Tp*>
+    {
+      /// The pointer type
+      typedef _Tp* pointer;
+      /// The type pointed to
+      typedef _Tp  element_type;
+      /// Type used to represent the difference between two pointers
+      typedef ptrdiff_t difference_type;
+
+      template<typename _Up>
+        using rebind = _Up*;
+
+      /**
+       *  @brief  Obtain a pointer to an object
+       *  @param  __r  A reference to an object of type @c element_type
+       *  @return @c addressof(__r)
+      */
+      static pointer
+      pointer_to(typename __ptrtr_not_void<element_type>::__type& __r) noexcept
+      { return std::addressof(__r); }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/random.h b/gcc-4.9/libstdc++-v3/include/bits/random.h
new file mode 100644
index 0000000..edfd797
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/random.h
@@ -0,0 +1,6069 @@
+// random number generation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/random.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{random}
+ */
+
+#ifndef _RANDOM_H
+#define _RANDOM_H 1
+
+#include <vector>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // [26.4] Random number generation
+
+  /**
+   * @defgroup random Random Number Generation
+   * @ingroup numerics
+   *
+   * A facility for generating random numbers on selected distributions.
+   * @{
+   */
+
+  /**
+   * @brief A function template for converting the output of a (integral)
+   * uniform random number generator to a floatng point result in the range
+   * [0-1).
+   */
+  template<typename _RealType, size_t __bits,
+	   typename _UniformRandomNumberGenerator>
+    _RealType
+    generate_canonical(_UniformRandomNumberGenerator& __g);
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+  /*
+   * Implementation-space details.
+   */
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    template<typename _UIntType, size_t __w,
+	     bool = __w < static_cast<size_t>
+			  (std::numeric_limits<_UIntType>::digits)>
+      struct _Shift
+      { static const _UIntType __value = 0; };
+
+    template<typename _UIntType, size_t __w>
+      struct _Shift<_UIntType, __w, true>
+      { static const _UIntType __value = _UIntType(1) << __w; };
+
+    template<int __s,
+	     int __which = ((__s <= __CHAR_BIT__ * sizeof (int))
+			    + (__s <= __CHAR_BIT__ * sizeof (long))
+			    + (__s <= __CHAR_BIT__ * sizeof (long long))
+			    /* assume long long no bigger than __int128 */
+			    + (__s <= 128))>
+      struct _Select_uint_least_t
+      {
+	static_assert(__which < 0, /* needs to be dependent */
+		      "sorry, would be too much trouble for a slow result");
+      };
+
+    template<int __s>
+      struct _Select_uint_least_t<__s, 4>
+      { typedef unsigned int type; };
+
+    template<int __s>
+      struct _Select_uint_least_t<__s, 3>
+      { typedef unsigned long type; };
+
+    template<int __s>
+      struct _Select_uint_least_t<__s, 2>
+      { typedef unsigned long long type; };
+
+#ifdef _GLIBCXX_USE_INT128
+    template<int __s>
+      struct _Select_uint_least_t<__s, 1>
+      { typedef unsigned __int128 type; };
+#endif
+
+    // Assume a != 0, a < m, c < m, x < m.
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
+	     bool __big_enough = (!(__m & (__m - 1))
+				  || (_Tp(-1) - __c) / __a >= __m - 1),
+             bool __schrage_ok = __m % __a < __m / __a>
+      struct _Mod
+      {
+	typedef typename _Select_uint_least_t<std::__lg(__a)
+					      + std::__lg(__m) + 2>::type _Tp2;
+	static _Tp
+	__calc(_Tp __x)
+	{ return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); }
+      };
+
+    // Schrage.
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
+      struct _Mod<_Tp, __m, __a, __c, false, true>
+      {
+	static _Tp
+	__calc(_Tp __x);
+      };
+
+    // Special cases:
+    // - for m == 2^n or m == 0, unsigned integer overflow is safe.
+    // - a * (m - 1) + c fits in _Tp, there is no overflow.
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
+      struct _Mod<_Tp, __m, __a, __c, true, __s>
+      {
+	static _Tp
+	__calc(_Tp __x)
+	{
+	  _Tp __res = __a * __x + __c;
+	  if (__m)
+	    __res %= __m;
+	  return __res;
+	}
+      };
+
+    template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
+      inline _Tp
+      __mod(_Tp __x)
+      { return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
+
+    /* Determine whether number is a power of 2.  */
+    template<typename _Tp>
+      inline bool
+      _Power_of_2(_Tp __x)
+      {
+	return ((__x - 1) & __x) == 0;
+      };
+
+    /*
+     * An adaptor class for converting the output of any Generator into
+     * the input for a specific Distribution.
+     */
+    template<typename _Engine, typename _DInputType>
+      struct _Adaptor
+      {
+
+      public:
+	_Adaptor(_Engine& __g)
+	: _M_g(__g) { }
+
+	_DInputType
+	min() const
+	{ return _DInputType(0); }
+
+	_DInputType
+	max() const
+	{ return _DInputType(1); }
+
+	/*
+	 * Converts a value generated by the adapted random number generator
+	 * into a value in the input domain for the dependent random number
+	 * distribution.
+	 */
+	_DInputType
+	operator()()
+	{
+	  return std::generate_canonical<_DInputType,
+	                            std::numeric_limits<_DInputType>::digits,
+	                            _Engine>(_M_g);
+	}
+
+      private:
+	_Engine& _M_g;
+      };
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace __detail
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup random_generators Random Number Generators
+   * @ingroup random
+   *
+   * These classes define objects which provide random or pseudorandom
+   * numbers, either from a discrete or a continuous interval.  The
+   * random number generator supplied as a part of this library are
+   * all uniform random number generators which provide a sequence of
+   * random number uniformly distributed over their range.
+   *
+   * A number generator is a function object with an operator() that
+   * takes zero arguments and returns a number.
+   *
+   * A compliant random number generator must satisfy the following
+   * requirements.  <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Random Number Generator Requirements</caption>
+   * <tr><td>To be documented.</td></tr> </table>
+   *
+   * @{
+   */
+
+  /**
+   * @brief A model of a linear congruential random number generator.
+   *
+   * A random number generator that produces pseudorandom numbers via
+   * linear function:
+   * @f[
+   *     x_{i+1}\leftarrow(ax_{i} + c) \bmod m 
+   * @f]
+   *
+   * The template parameter @p _UIntType must be an unsigned integral type
+   * large enough to store values up to (__m-1). If the template parameter
+   * @p __m is 0, the modulus @p __m used is
+   * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
+   * parameters @p __a and @p __c must be less than @p __m.
+   *
+   * The size of the state is @f$1@f$.
+   */
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    class linear_congruential_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+		    "substituting _UIntType not an unsigned integral type");
+      static_assert(__m == 0u || (__a < __m && __c < __m),
+		    "template argument substituting __m out of bounds");
+
+    public:
+      /** The type of the generated random value. */
+      typedef _UIntType result_type;
+
+      /** The multiplier. */
+      static constexpr result_type multiplier   = __a;
+      /** An increment. */
+      static constexpr result_type increment    = __c;
+      /** The modulus. */
+      static constexpr result_type modulus      = __m;
+      static constexpr result_type default_seed = 1u;
+
+      /**
+       * @brief Constructs a %linear_congruential_engine random number
+       *        generator engine with seed @p __s.  The default seed value
+       *        is 1.
+       *
+       * @param __s The initial seed value.
+       */
+      explicit
+      linear_congruential_engine(result_type __s = default_seed)
+      { seed(__s); }
+
+      /**
+       * @brief Constructs a %linear_congruential_engine random number
+       *        generator engine seeded from the seed sequence @p __q.
+       *
+       * @param __q the seed sequence.
+       */
+      template<typename _Sseq, typename = typename
+	std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
+	       ::type>
+        explicit
+        linear_congruential_engine(_Sseq& __q)
+        { seed(__q); }
+
+      /**
+       * @brief Reseeds the %linear_congruential_engine random number generator
+       *        engine sequence to the seed @p __s.
+       *
+       * @param __s The new seed.
+       */
+      void
+      seed(result_type __s = default_seed);
+
+      /**
+       * @brief Reseeds the %linear_congruential_engine random number generator
+       *        engine
+       * sequence using values from the seed sequence @p __q.
+       *
+       * @param __q the seed sequence.
+       */
+      template<typename _Sseq>
+        typename std::enable_if<std::is_class<_Sseq>::value>::type
+        seed(_Sseq& __q);
+
+      /**
+       * @brief Gets the smallest possible value in the output range.
+       *
+       * The minimum depends on the @p __c parameter: if it is zero, the
+       * minimum generated must be > 0, otherwise 0 is allowed.
+       */
+      static constexpr result_type
+      min()
+      { return __c == 0u ? 1u : 0u; }
+
+      /**
+       * @brief Gets the largest possible value in the output range.
+       */
+      static constexpr result_type
+      max()
+      { return __m - 1u; }
+
+      /**
+       * @brief Discard a sequence of random numbers.
+       */
+      void
+      discard(unsigned long long __z)
+      {
+	for (; __z != 0ULL; --__z)
+	  (*this)();
+      }
+
+      /**
+       * @brief Gets the next random number in the sequence.
+       */
+      result_type
+      operator()()
+      {
+	_M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
+	return _M_x;
+      }
+
+      /**
+       * @brief Compares two linear congruential random number generator
+       * objects of the same type for equality.
+       *
+       * @param __lhs A linear congruential random number generator object.
+       * @param __rhs Another linear congruential random number generator
+       *              object.
+       *
+       * @returns true if the infinite sequences of generated values
+       *          would be equal, false otherwise.
+       */
+      friend bool
+      operator==(const linear_congruential_engine& __lhs,
+		 const linear_congruential_engine& __rhs)
+      { return __lhs._M_x == __rhs._M_x; }
+
+      /**
+       * @brief Writes the textual representation of the state x(i) of x to
+       *        @p __os.
+       *
+       * @param __os  The output stream.
+       * @param __lcr A % linear_congruential_engine random number generator.
+       * @returns __os.
+       */
+      template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+	       _UIntType1 __m1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::linear_congruential_engine<_UIntType1,
+		   __a1, __c1, __m1>& __lcr);
+
+      /**
+       * @brief Sets the state of the engine by reading its textual
+       *        representation from @p __is.
+       *
+       * The textual representation must have been previously written using
+       * an output stream whose imbued locale and whose type's template
+       * specialization arguments _CharT and _Traits were the same as those
+       * of @p __is.
+       *
+       * @param __is  The input stream.
+       * @param __lcr A % linear_congruential_engine random number generator.
+       * @returns __is.
+       */
+      template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+	       _UIntType1 __m1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::linear_congruential_engine<_UIntType1, __a1,
+		   __c1, __m1>& __lcr);
+
+    private:
+      _UIntType _M_x;
+    };
+
+  /**
+   * @brief Compares two linear congruential random number generator
+   * objects of the same type for inequality.
+   *
+   * @param __lhs A linear congruential random number generator object.
+   * @param __rhs Another linear congruential random number generator
+   *              object.
+   *
+   * @returns true if the infinite sequences of generated values
+   *          would be different, false otherwise.
+   */
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    inline bool
+    operator!=(const std::linear_congruential_engine<_UIntType, __a,
+	       __c, __m>& __lhs,
+	       const std::linear_congruential_engine<_UIntType, __a,
+	       __c, __m>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+  /**
+   * A generalized feedback shift register discrete random number generator.
+   *
+   * This algorithm avoids multiplication and division and is designed to be
+   * friendly to a pipelined architecture.  If the parameters are chosen
+   * correctly, this generator will produce numbers with a very long period and
+   * fairly good apparent entropy, although still not cryptographically strong.
+   *
+   * The best way to use this generator is with the predefined mt19937 class.
+   *
+   * This algorithm was originally invented by Makoto Matsumoto and
+   * Takuji Nishimura.
+   *
+   * @tparam __w  Word size, the number of bits in each element of 
+   *              the state vector.
+   * @tparam __n  The degree of recursion.
+   * @tparam __m  The period parameter.
+   * @tparam __r  The separation point bit index.
+   * @tparam __a  The last row of the twist matrix.
+   * @tparam __u  The first right-shift tempering matrix parameter.
+   * @tparam __d  The first right-shift tempering matrix mask.
+   * @tparam __s  The first left-shift tempering matrix parameter.
+   * @tparam __b  The first left-shift tempering matrix mask.
+   * @tparam __t  The second left-shift tempering matrix parameter.
+   * @tparam __c  The second left-shift tempering matrix mask.
+   * @tparam __l  The second right-shift tempering matrix parameter.
+   * @tparam __f  Initialization multiplier.
+   */
+  template<typename _UIntType, size_t __w,
+	   size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t,
+	   _UIntType __c, size_t __l, _UIntType __f>
+    class mersenne_twister_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+		    "substituting _UIntType not an unsigned integral type");
+      static_assert(1u <= __m && __m <= __n,
+		    "template argument substituting __m out of bounds");
+      static_assert(__r <= __w, "template argument substituting "
+		    "__r out of bound");
+      static_assert(__u <= __w, "template argument substituting "
+		    "__u out of bound");
+      static_assert(__s <= __w, "template argument substituting "
+		    "__s out of bound");
+      static_assert(__t <= __w, "template argument substituting "
+		    "__t out of bound");
+      static_assert(__l <= __w, "template argument substituting "
+		    "__l out of bound");
+      static_assert(__w <= std::numeric_limits<_UIntType>::digits,
+		    "template argument substituting __w out of bound");
+      static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+		    "template argument substituting __a out of bound");
+      static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+		    "template argument substituting __b out of bound");
+      static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+		    "template argument substituting __c out of bound");
+      static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+		    "template argument substituting __d out of bound");
+      static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+		    "template argument substituting __f out of bound");
+
+    public:
+      /** The type of the generated random value. */
+      typedef _UIntType result_type;
+
+      // parameter values
+      static constexpr size_t      word_size                 = __w;
+      static constexpr size_t      state_size                = __n;
+      static constexpr size_t      shift_size                = __m;
+      static constexpr size_t      mask_bits                 = __r;
+      static constexpr result_type xor_mask                  = __a;
+      static constexpr size_t      tempering_u               = __u;
+      static constexpr result_type tempering_d               = __d;
+      static constexpr size_t      tempering_s               = __s;
+      static constexpr result_type tempering_b               = __b;
+      static constexpr size_t      tempering_t               = __t;
+      static constexpr result_type tempering_c               = __c;
+      static constexpr size_t      tempering_l               = __l;
+      static constexpr result_type initialization_multiplier = __f;
+      static constexpr result_type default_seed = 5489u;
+
+      // constructors and member function
+      explicit
+      mersenne_twister_engine(result_type __sd = default_seed)
+      { seed(__sd); }
+
+      /**
+       * @brief Constructs a %mersenne_twister_engine random number generator
+       *        engine seeded from the seed sequence @p __q.
+       *
+       * @param __q the seed sequence.
+       */
+      template<typename _Sseq, typename = typename
+        std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
+	       ::type>
+        explicit
+        mersenne_twister_engine(_Sseq& __q)
+        { seed(__q); }
+
+      void
+      seed(result_type __sd = default_seed);
+
+      template<typename _Sseq>
+	typename std::enable_if<std::is_class<_Sseq>::value>::type
+        seed(_Sseq& __q);
+
+      /**
+       * @brief Gets the smallest possible value in the output range.
+       */
+      static constexpr result_type
+      min()
+      { return 0; };
+
+      /**
+       * @brief Gets the largest possible value in the output range.
+       */
+      static constexpr result_type
+      max()
+      { return __detail::_Shift<_UIntType, __w>::__value - 1; }
+
+      /**
+       * @brief Discard a sequence of random numbers.
+       */
+      void
+      discard(unsigned long long __z);
+
+      result_type
+      operator()();
+
+      /**
+       * @brief Compares two % mersenne_twister_engine random number generator
+       *        objects of the same type for equality.
+       *
+       * @param __lhs A % mersenne_twister_engine random number generator
+       *              object.
+       * @param __rhs Another % mersenne_twister_engine random number
+       *              generator object.
+       *
+       * @returns true if the infinite sequences of generated values
+       *          would be equal, false otherwise.
+       */
+      friend bool
+      operator==(const mersenne_twister_engine& __lhs,
+		 const mersenne_twister_engine& __rhs)
+      { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
+		&& __lhs._M_p == __rhs._M_p); }
+
+      /**
+       * @brief Inserts the current state of a % mersenne_twister_engine
+       *        random number generator engine @p __x into the output stream
+       *        @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % mersenne_twister_engine random number generator
+       *             engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _UIntType1,
+	       size_t __w1, size_t __n1,
+	       size_t __m1, size_t __r1,
+	       _UIntType1 __a1, size_t __u1,
+	       _UIntType1 __d1, size_t __s1,
+	       _UIntType1 __b1, size_t __t1,
+	       _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
+		   __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
+		   __l1, __f1>& __x);
+
+      /**
+       * @brief Extracts the current state of a % mersenne_twister_engine
+       *        random number generator engine @p __x from the input stream
+       *        @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % mersenne_twister_engine random number generator
+       *             engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _UIntType1,
+	       size_t __w1, size_t __n1,
+	       size_t __m1, size_t __r1,
+	       _UIntType1 __a1, size_t __u1,
+	       _UIntType1 __d1, size_t __s1,
+	       _UIntType1 __b1, size_t __t1,
+	       _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
+		   __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
+		   __l1, __f1>& __x);
+
+    private:
+      void _M_gen_rand();
+
+      _UIntType _M_x[state_size];
+      size_t    _M_p;
+    };
+
+  /**
+   * @brief Compares two % mersenne_twister_engine random number generator
+   *        objects of the same type for inequality.
+   *
+   * @param __lhs A % mersenne_twister_engine random number generator
+   *              object.
+   * @param __rhs Another % mersenne_twister_engine random number
+   *              generator object.
+   *
+   * @returns true if the infinite sequences of generated values
+   *          would be different, false otherwise.
+   */
+  template<typename _UIntType, size_t __w,
+	   size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t,
+	   _UIntType __c, size_t __l, _UIntType __f>
+    inline bool
+    operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+	       __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
+	       const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+	       __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+  /**
+   * @brief The Marsaglia-Zaman generator.
+   *
+   * This is a model of a Generalized Fibonacci discrete random number
+   * generator, sometimes referred to as the SWC generator.
+   *
+   * A discrete random number generator that produces pseudorandom
+   * numbers using:
+   * @f[
+   *     x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m 
+   * @f]
+   *
+   * The size of the state is @f$r@f$
+   * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
+   *
+   * @var _M_x     The state of the generator.  This is a ring buffer.
+   * @var _M_carry The carry.
+   * @var _M_p     Current index of x(i - r).
+   */
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    class subtract_with_carry_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+		    "substituting _UIntType not an unsigned integral type");
+      static_assert(0u < __s && __s < __r,
+		    "template argument substituting __s out of bounds");
+      static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
+		    "template argument substituting __w out of bounds");
+
+    public:
+      /** The type of the generated random value. */
+      typedef _UIntType result_type;
+
+      // parameter values
+      static constexpr size_t      word_size    = __w;
+      static constexpr size_t      short_lag    = __s;
+      static constexpr size_t      long_lag     = __r;
+      static constexpr result_type default_seed = 19780503u;
+
+      /**
+       * @brief Constructs an explicitly seeded % subtract_with_carry_engine
+       *        random number generator.
+       */
+      explicit
+      subtract_with_carry_engine(result_type __sd = default_seed)
+      { seed(__sd); }
+
+      /**
+       * @brief Constructs a %subtract_with_carry_engine random number engine
+       *        seeded from the seed sequence @p __q.
+       *
+       * @param __q the seed sequence.
+       */
+      template<typename _Sseq, typename = typename
+        std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
+	       ::type>
+        explicit
+        subtract_with_carry_engine(_Sseq& __q)
+        { seed(__q); }
+
+      /**
+       * @brief Seeds the initial state @f$x_0@f$ of the random number
+       *        generator.
+       *
+       * N1688[4.19] modifies this as follows.  If @p __value == 0,
+       * sets value to 19780503.  In any case, with a linear
+       * congruential generator lcg(i) having parameters @f$ m_{lcg} =
+       * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
+       * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
+       * \dots lcg(r) \bmod m @f$ respectively.  If @f$ x_{-1} = 0 @f$
+       * set carry to 1, otherwise sets carry to 0.
+       */
+      void
+      seed(result_type __sd = default_seed);
+
+      /**
+       * @brief Seeds the initial state @f$x_0@f$ of the
+       * % subtract_with_carry_engine random number generator.
+       */
+      template<typename _Sseq>
+	typename std::enable_if<std::is_class<_Sseq>::value>::type
+        seed(_Sseq& __q);
+
+      /**
+       * @brief Gets the inclusive minimum value of the range of random
+       * integers returned by this generator.
+       */
+      static constexpr result_type
+      min()
+      { return 0; }
+
+      /**
+       * @brief Gets the inclusive maximum value of the range of random
+       * integers returned by this generator.
+       */
+      static constexpr result_type
+      max()
+      { return __detail::_Shift<_UIntType, __w>::__value - 1; }
+
+      /**
+       * @brief Discard a sequence of random numbers.
+       */
+      void
+      discard(unsigned long long __z)
+      {
+	for (; __z != 0ULL; --__z)
+	  (*this)();
+      }
+
+      /**
+       * @brief Gets the next random number in the sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * @brief Compares two % subtract_with_carry_engine random number
+       *        generator objects of the same type for equality.
+       *
+       * @param __lhs A % subtract_with_carry_engine random number generator
+       *              object.
+       * @param __rhs Another % subtract_with_carry_engine random number
+       *              generator object.
+       *
+       * @returns true if the infinite sequences of generated values
+       *          would be equal, false otherwise.
+      */
+      friend bool
+      operator==(const subtract_with_carry_engine& __lhs,
+		 const subtract_with_carry_engine& __rhs)
+      { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
+		&& __lhs._M_carry == __rhs._M_carry
+		&& __lhs._M_p == __rhs._M_p); }
+
+      /**
+       * @brief Inserts the current state of a % subtract_with_carry_engine
+       *        random number generator engine @p __x into the output stream
+       *        @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % subtract_with_carry_engine random number generator
+       *             engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>&,
+		   const std::subtract_with_carry_engine<_UIntType1, __w1,
+		   __s1, __r1>&);
+
+      /**
+       * @brief Extracts the current state of a % subtract_with_carry_engine
+       *        random number generator engine @p __x from the input stream
+       *        @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % subtract_with_carry_engine random number generator
+       *             engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>&,
+		   std::subtract_with_carry_engine<_UIntType1, __w1,
+		   __s1, __r1>&);
+
+    private:
+      _UIntType  _M_x[long_lag];
+      _UIntType  _M_carry;
+      size_t     _M_p;
+    };
+
+  /**
+   * @brief Compares two % subtract_with_carry_engine random number
+   *        generator objects of the same type for inequality.
+   *
+   * @param __lhs A % subtract_with_carry_engine random number generator
+   *              object.
+   * @param __rhs Another % subtract_with_carry_engine random number
+   *              generator object.
+   *
+   * @returns true if the infinite sequences of generated values
+   *          would be different, false otherwise.
+   */
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    inline bool
+    operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
+	       __s, __r>& __lhs,
+	       const std::subtract_with_carry_engine<_UIntType, __w,
+	       __s, __r>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+  /**
+   * Produces random numbers from some base engine by discarding blocks of
+   * data.
+   *
+   * 0 <= @p __r <= @p __p
+   */
+  template<typename _RandomNumberEngine, size_t __p, size_t __r>
+    class discard_block_engine
+    {
+      static_assert(1 <= __r && __r <= __p,
+		    "template argument substituting __r out of bounds");
+
+    public:
+      /** The type of the generated random value. */
+      typedef typename _RandomNumberEngine::result_type result_type;
+
+      // parameter values
+      static constexpr size_t block_size = __p;
+      static constexpr size_t used_block = __r;
+
+      /**
+       * @brief Constructs a default %discard_block_engine engine.
+       *
+       * The underlying engine is default constructed as well.
+       */
+      discard_block_engine()
+      : _M_b(), _M_n(0) { }
+
+      /**
+       * @brief Copy constructs a %discard_block_engine engine.
+       *
+       * Copies an existing base class random number generator.
+       * @param __rng An existing (base class) engine object.
+       */
+      explicit
+      discard_block_engine(const _RandomNumberEngine& __rng)
+      : _M_b(__rng), _M_n(0) { }
+
+      /**
+       * @brief Move constructs a %discard_block_engine engine.
+       *
+       * Copies an existing base class random number generator.
+       * @param __rng An existing (base class) engine object.
+       */
+      explicit
+      discard_block_engine(_RandomNumberEngine&& __rng)
+      : _M_b(std::move(__rng)), _M_n(0) { }
+
+      /**
+       * @brief Seed constructs a %discard_block_engine engine.
+       *
+       * Constructs the underlying generator engine seeded with @p __s.
+       * @param __s A seed value for the base class engine.
+       */
+      explicit
+      discard_block_engine(result_type __s)
+      : _M_b(__s), _M_n(0) { }
+
+      /**
+       * @brief Generator construct a %discard_block_engine engine.
+       *
+       * @param __q A seed sequence.
+       */
+      template<typename _Sseq, typename = typename
+	std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
+		       && !std::is_same<_Sseq, _RandomNumberEngine>::value>
+	       ::type>
+        explicit
+        discard_block_engine(_Sseq& __q)
+	: _M_b(__q), _M_n(0)
+        { }
+
+      /**
+       * @brief Reseeds the %discard_block_engine object with the default
+       *        seed for the underlying base class generator engine.
+       */
+      void
+      seed()
+      {
+	_M_b.seed();
+	_M_n = 0;
+      }
+
+      /**
+       * @brief Reseeds the %discard_block_engine object with the default
+       *        seed for the underlying base class generator engine.
+       */
+      void
+      seed(result_type __s)
+      {
+	_M_b.seed(__s);
+	_M_n = 0;
+      }
+
+      /**
+       * @brief Reseeds the %discard_block_engine object with the given seed
+       *        sequence.
+       * @param __q A seed generator function.
+       */
+      template<typename _Sseq>
+        void
+        seed(_Sseq& __q)
+        {
+	  _M_b.seed(__q);
+	  _M_n = 0;
+	}
+
+      /**
+       * @brief Gets a const reference to the underlying generator engine
+       *        object.
+       */
+      const _RandomNumberEngine&
+      base() const noexcept
+      { return _M_b; }
+
+      /**
+       * @brief Gets the minimum value in the generated random number range.
+       */
+      static constexpr result_type
+      min()
+      { return _RandomNumberEngine::min(); }
+
+      /**
+       * @brief Gets the maximum value in the generated random number range.
+       */
+      static constexpr result_type
+      max()
+      { return _RandomNumberEngine::max(); }
+
+      /**
+       * @brief Discard a sequence of random numbers.
+       */
+      void
+      discard(unsigned long long __z)
+      {
+	for (; __z != 0ULL; --__z)
+	  (*this)();
+      }
+
+      /**
+       * @brief Gets the next value in the generated random number sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * @brief Compares two %discard_block_engine random number generator
+       *        objects of the same type for equality.
+       *
+       * @param __lhs A %discard_block_engine random number generator object.
+       * @param __rhs Another %discard_block_engine random number generator
+       *              object.
+       *
+       * @returns true if the infinite sequences of generated values
+       *          would be equal, false otherwise.
+       */
+      friend bool
+      operator==(const discard_block_engine& __lhs,
+		 const discard_block_engine& __rhs)
+      { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
+
+      /**
+       * @brief Inserts the current state of a %discard_block_engine random
+       *        number generator engine @p __x into the output stream
+       *        @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %discard_block_engine random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::discard_block_engine<_RandomNumberEngine1,
+		   __p1, __r1>& __x);
+
+      /**
+       * @brief Extracts the current state of a % subtract_with_carry_engine
+       *        random number generator engine @p __x from the input stream
+       *        @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %discard_block_engine random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::discard_block_engine<_RandomNumberEngine1,
+		   __p1, __r1>& __x);
+
+    private:
+      _RandomNumberEngine _M_b;
+      size_t _M_n;
+    };
+
+  /**
+   * @brief Compares two %discard_block_engine random number generator
+   *        objects of the same type for inequality.
+   *
+   * @param __lhs A %discard_block_engine random number generator object.
+   * @param __rhs Another %discard_block_engine random number generator
+   *              object.
+   *
+   * @returns true if the infinite sequences of generated values
+   *          would be different, false otherwise.
+   */
+  template<typename _RandomNumberEngine, size_t __p, size_t __r>
+    inline bool
+    operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
+	       __r>& __lhs,
+	       const std::discard_block_engine<_RandomNumberEngine, __p,
+	       __r>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+  /**
+   * Produces random numbers by combining random numbers from some base
+   * engine to produce random numbers with a specifies number of bits @p __w.
+   */
+  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
+    class independent_bits_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+		    "substituting _UIntType not an unsigned integral type");
+      static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
+		    "template argument substituting __w out of bounds");
+
+    public:
+      /** The type of the generated random value. */
+      typedef _UIntType result_type;
+
+      /**
+       * @brief Constructs a default %independent_bits_engine engine.
+       *
+       * The underlying engine is default constructed as well.
+       */
+      independent_bits_engine()
+      : _M_b() { }
+
+      /**
+       * @brief Copy constructs a %independent_bits_engine engine.
+       *
+       * Copies an existing base class random number generator.
+       * @param __rng An existing (base class) engine object.
+       */
+      explicit
+      independent_bits_engine(const _RandomNumberEngine& __rng)
+      : _M_b(__rng) { }
+
+      /**
+       * @brief Move constructs a %independent_bits_engine engine.
+       *
+       * Copies an existing base class random number generator.
+       * @param __rng An existing (base class) engine object.
+       */
+      explicit
+      independent_bits_engine(_RandomNumberEngine&& __rng)
+      : _M_b(std::move(__rng)) { }
+
+      /**
+       * @brief Seed constructs a %independent_bits_engine engine.
+       *
+       * Constructs the underlying generator engine seeded with @p __s.
+       * @param __s A seed value for the base class engine.
+       */
+      explicit
+      independent_bits_engine(result_type __s)
+      : _M_b(__s) { }
+
+      /**
+       * @brief Generator construct a %independent_bits_engine engine.
+       *
+       * @param __q A seed sequence.
+       */
+      template<typename _Sseq, typename = typename
+	std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
+		       && !std::is_same<_Sseq, _RandomNumberEngine>::value>
+               ::type>
+        explicit
+        independent_bits_engine(_Sseq& __q)
+        : _M_b(__q)
+        { }
+
+      /**
+       * @brief Reseeds the %independent_bits_engine object with the default
+       *        seed for the underlying base class generator engine.
+       */
+      void
+      seed()
+      { _M_b.seed(); }
+
+      /**
+       * @brief Reseeds the %independent_bits_engine object with the default
+       *        seed for the underlying base class generator engine.
+       */
+      void
+      seed(result_type __s)
+      { _M_b.seed(__s); }
+
+      /**
+       * @brief Reseeds the %independent_bits_engine object with the given
+       *        seed sequence.
+       * @param __q A seed generator function.
+       */
+      template<typename _Sseq>
+        void
+        seed(_Sseq& __q)
+        { _M_b.seed(__q); }
+
+      /**
+       * @brief Gets a const reference to the underlying generator engine
+       *        object.
+       */
+      const _RandomNumberEngine&
+      base() const noexcept
+      { return _M_b; }
+
+      /**
+       * @brief Gets the minimum value in the generated random number range.
+       */
+      static constexpr result_type
+      min()
+      { return 0U; }
+
+      /**
+       * @brief Gets the maximum value in the generated random number range.
+       */
+      static constexpr result_type
+      max()
+      { return __detail::_Shift<_UIntType, __w>::__value - 1; }
+
+      /**
+       * @brief Discard a sequence of random numbers.
+       */
+      void
+      discard(unsigned long long __z)
+      {
+	for (; __z != 0ULL; --__z)
+	  (*this)();
+      }
+
+      /**
+       * @brief Gets the next value in the generated random number sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * @brief Compares two %independent_bits_engine random number generator
+       * objects of the same type for equality.
+       *
+       * @param __lhs A %independent_bits_engine random number generator
+       *              object.
+       * @param __rhs Another %independent_bits_engine random number generator
+       *              object.
+       *
+       * @returns true if the infinite sequences of generated values
+       *          would be equal, false otherwise.
+       */
+      friend bool
+      operator==(const independent_bits_engine& __lhs,
+		 const independent_bits_engine& __rhs)
+      { return __lhs._M_b == __rhs._M_b; }
+
+      /**
+       * @brief Extracts the current state of a % subtract_with_carry_engine
+       *        random number generator engine @p __x from the input stream
+       *        @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %independent_bits_engine random number generator
+       *             engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       *          an error state.
+       */
+      template<typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::independent_bits_engine<_RandomNumberEngine,
+		   __w, _UIntType>& __x)
+	{
+	  __is >> __x._M_b;
+	  return __is;
+	}
+
+    private:
+      _RandomNumberEngine _M_b;
+    };
+
+  /**
+   * @brief Compares two %independent_bits_engine random number generator
+   * objects of the same type for inequality.
+   *
+   * @param __lhs A %independent_bits_engine random number generator
+   *              object.
+   * @param __rhs Another %independent_bits_engine random number generator
+   *              object.
+   *
+   * @returns true if the infinite sequences of generated values
+   *          would be different, false otherwise.
+   */
+  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
+    inline bool
+    operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
+	       _UIntType>& __lhs,
+	       const std::independent_bits_engine<_RandomNumberEngine, __w,
+	       _UIntType>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   * @brief Inserts the current state of a %independent_bits_engine random
+   *        number generator engine @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %independent_bits_engine random number generator engine.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   *          an error state.
+   */
+  template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const std::independent_bits_engine<_RandomNumberEngine,
+	       __w, _UIntType>& __x)
+    {
+      __os << __x.base();
+      return __os;
+    }
+
+
+  /**
+   * @brief Produces random numbers by combining random numbers from some
+   * base engine to produce random numbers with a specifies number of bits
+   * @p __w.
+   */
+  template<typename _RandomNumberEngine, size_t __k>
+    class shuffle_order_engine
+    {
+      static_assert(1u <= __k, "template argument substituting "
+		    "__k out of bound");
+
+    public:
+      /** The type of the generated random value. */
+      typedef typename _RandomNumberEngine::result_type result_type;
+
+      static constexpr size_t table_size = __k;
+
+      /**
+       * @brief Constructs a default %shuffle_order_engine engine.
+       *
+       * The underlying engine is default constructed as well.
+       */
+      shuffle_order_engine()
+      : _M_b()
+      { _M_initialize(); }
+
+      /**
+       * @brief Copy constructs a %shuffle_order_engine engine.
+       *
+       * Copies an existing base class random number generator.
+       * @param __rng An existing (base class) engine object.
+       */
+      explicit
+      shuffle_order_engine(const _RandomNumberEngine& __rng)
+      : _M_b(__rng)
+      { _M_initialize(); }
+
+      /**
+       * @brief Move constructs a %shuffle_order_engine engine.
+       *
+       * Copies an existing base class random number generator.
+       * @param __rng An existing (base class) engine object.
+       */
+      explicit
+      shuffle_order_engine(_RandomNumberEngine&& __rng)
+      : _M_b(std::move(__rng))
+      { _M_initialize(); }
+
+      /**
+       * @brief Seed constructs a %shuffle_order_engine engine.
+       *
+       * Constructs the underlying generator engine seeded with @p __s.
+       * @param __s A seed value for the base class engine.
+       */
+      explicit
+      shuffle_order_engine(result_type __s)
+      : _M_b(__s)
+      { _M_initialize(); }
+
+      /**
+       * @brief Generator construct a %shuffle_order_engine engine.
+       *
+       * @param __q A seed sequence.
+       */
+      template<typename _Sseq, typename = typename
+	std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
+		       && !std::is_same<_Sseq, _RandomNumberEngine>::value>
+	       ::type>
+        explicit
+        shuffle_order_engine(_Sseq& __q)
+        : _M_b(__q)
+        { _M_initialize(); }
+
+      /**
+       * @brief Reseeds the %shuffle_order_engine object with the default seed
+                for the underlying base class generator engine.
+       */
+      void
+      seed()
+      {
+	_M_b.seed();
+	_M_initialize();
+      }
+
+      /**
+       * @brief Reseeds the %shuffle_order_engine object with the default seed
+       *        for the underlying base class generator engine.
+       */
+      void
+      seed(result_type __s)
+      {
+	_M_b.seed(__s);
+	_M_initialize();
+      }
+
+      /**
+       * @brief Reseeds the %shuffle_order_engine object with the given seed
+       *        sequence.
+       * @param __q A seed generator function.
+       */
+      template<typename _Sseq>
+        void
+        seed(_Sseq& __q)
+        {
+	  _M_b.seed(__q);
+	  _M_initialize();
+	}
+
+      /**
+       * Gets a const reference to the underlying generator engine object.
+       */
+      const _RandomNumberEngine&
+      base() const noexcept
+      { return _M_b; }
+
+      /**
+       * Gets the minimum value in the generated random number range.
+       */
+      static constexpr result_type
+      min()
+      { return _RandomNumberEngine::min(); }
+
+      /**
+       * Gets the maximum value in the generated random number range.
+       */
+      static constexpr result_type
+      max()
+      { return _RandomNumberEngine::max(); }
+
+      /**
+       * Discard a sequence of random numbers.
+       */
+      void
+      discard(unsigned long long __z)
+      {
+	for (; __z != 0ULL; --__z)
+	  (*this)();
+      }
+
+      /**
+       * Gets the next value in the generated random number sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two %shuffle_order_engine random number generator objects
+       * of the same type for equality.
+       *
+       * @param __lhs A %shuffle_order_engine random number generator object.
+       * @param __rhs Another %shuffle_order_engine random number generator
+       *              object.
+       *
+       * @returns true if the infinite sequences of generated values
+       *          would be equal, false otherwise.
+      */
+      friend bool
+      operator==(const shuffle_order_engine& __lhs,
+		 const shuffle_order_engine& __rhs)
+      { return (__lhs._M_b == __rhs._M_b
+		&& std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
+		&& __lhs._M_y == __rhs._M_y); }
+
+      /**
+       * @brief Inserts the current state of a %shuffle_order_engine random
+       *        number generator engine @p __x into the output stream
+	@p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %shuffle_order_engine random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RandomNumberEngine1, size_t __k1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::shuffle_order_engine<_RandomNumberEngine1,
+		   __k1>& __x);
+
+      /**
+       * @brief Extracts the current state of a % subtract_with_carry_engine
+       *        random number generator engine @p __x from the input stream
+       *        @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %shuffle_order_engine random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _RandomNumberEngine1, size_t __k1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
+
+    private:
+      void _M_initialize()
+      {
+	for (size_t __i = 0; __i < __k; ++__i)
+	  _M_v[__i] = _M_b();
+	_M_y = _M_b();
+      }
+
+      _RandomNumberEngine _M_b;
+      result_type _M_v[__k];
+      result_type _M_y;
+    };
+
+  /**
+   * Compares two %shuffle_order_engine random number generator objects
+   * of the same type for inequality.
+   *
+   * @param __lhs A %shuffle_order_engine random number generator object.
+   * @param __rhs Another %shuffle_order_engine random number generator
+   *              object.
+   *
+   * @returns true if the infinite sequences of generated values
+   *          would be different, false otherwise.
+   */
+  template<typename _RandomNumberEngine, size_t __k>
+    inline bool
+    operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
+	       __k>& __lhs,
+	       const std::shuffle_order_engine<_RandomNumberEngine,
+	       __k>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+  /**
+   * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
+   */
+  typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
+  minstd_rand0;
+
+  /**
+   * An alternative LCR (Lehmer Generator function).
+   */
+  typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
+  minstd_rand;
+
+  /**
+   * The classic Mersenne Twister.
+   *
+   * Reference:
+   * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
+   * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
+   * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
+   */
+  typedef mersenne_twister_engine<
+    uint_fast32_t,
+    32, 624, 397, 31,
+    0x9908b0dfUL, 11,
+    0xffffffffUL, 7,
+    0x9d2c5680UL, 15,
+    0xefc60000UL, 18, 1812433253UL> mt19937;
+
+  /**
+   * An alternative Mersenne Twister.
+   */
+  typedef mersenne_twister_engine<
+    uint_fast64_t,
+    64, 312, 156, 31,
+    0xb5026f5aa96619e9ULL, 29,
+    0x5555555555555555ULL, 17,
+    0x71d67fffeda60000ULL, 37,
+    0xfff7eee000000000ULL, 43,
+    6364136223846793005ULL> mt19937_64;
+
+  typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
+    ranlux24_base;
+
+  typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
+    ranlux48_base;
+
+  typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
+
+  typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
+
+  typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
+
+  typedef minstd_rand0 default_random_engine;
+
+  /**
+   * A standard interface to a platform-specific non-deterministic
+   * random number generator (if any are available).
+   */
+  class random_device
+  {
+  public:
+    /** The type of the generated random value. */
+    typedef unsigned int result_type;
+
+    // constructors, destructors and member functions
+
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+
+    explicit
+    random_device(const std::string& __token = "default")
+    {
+      _M_init(__token);
+    }
+
+    ~random_device()
+    { _M_fini(); }
+
+#else
+
+    explicit
+    random_device(const std::string& __token = "mt19937")
+    { _M_init_pretr1(__token); }
+
+  public:
+
+#endif
+
+    static constexpr result_type
+    min()
+    { return std::numeric_limits<result_type>::min(); }
+
+    static constexpr result_type
+    max()
+    { return std::numeric_limits<result_type>::max(); }
+
+    double
+    entropy() const noexcept
+    { return 0.0; }
+
+    result_type
+    operator()()
+    {
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+      return this->_M_getval();
+#else
+      return this->_M_getval_pretr1();
+#endif
+    }
+
+    // No copy functions.
+    random_device(const random_device&) = delete;
+    void operator=(const random_device&) = delete;
+
+  private:
+
+    void _M_init(const std::string& __token);
+    void _M_init_pretr1(const std::string& __token);
+    void _M_fini();
+
+    result_type _M_getval();
+    result_type _M_getval_pretr1();
+
+    union
+    {
+      void*      _M_file;
+      mt19937    _M_mt;
+    };
+  };
+
+  /* @} */ // group random_generators
+
+  /**
+   * @addtogroup random_distributions Random Number Distributions
+   * @ingroup random
+   * @{
+   */
+
+  /**
+   * @addtogroup random_distributions_uniform Uniform Distributions
+   * @ingroup random_distributions
+   * @{
+   */
+
+  /**
+   * @brief Uniform discrete distribution for random numbers.
+   * A discrete random distribution on the range @f$[min, max]@f$ with equal
+   * probability throughout the range.
+   */
+  template<typename _IntType = int>
+    class uniform_int_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+		    "template argument not an integral type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _IntType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef uniform_int_distribution<_IntType> distribution_type;
+
+	explicit
+	param_type(_IntType __a = 0,
+		   _IntType __b = std::numeric_limits<_IntType>::max())
+	: _M_a(__a), _M_b(__b)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
+	}
+
+	result_type
+	a() const
+	{ return _M_a; }
+
+	result_type
+	b() const
+	{ return _M_b; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+      private:
+	_IntType _M_a;
+	_IntType _M_b;
+      };
+
+    public:
+      /**
+       * @brief Constructs a uniform distribution object.
+       */
+      explicit
+      uniform_int_distribution(_IntType __a = 0,
+			   _IntType __b = std::numeric_limits<_IntType>::max())
+      : _M_param(__a, __b)
+      { }
+
+      explicit
+      uniform_int_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       *
+       * Does nothing for the uniform integer distribution.
+       */
+      void
+      reset() { }
+
+      result_type
+      a() const
+      { return _M_param.a(); }
+
+      result_type
+      b() const
+      { return _M_param.b(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the inclusive lower bound of the distribution range.
+       */
+      result_type
+      min() const
+      { return this->a(); }
+
+      /**
+       * @brief Returns the inclusive upper bound of the distribution range.
+       */
+      result_type
+      max() const
+      { return this->b(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+        { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two uniform integer distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const uniform_int_distribution& __d1,
+		 const uniform_int_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two uniform integer distributions have
+   *        different parameters.
+   */
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::uniform_int_distribution<_IntType>& __d1,
+	       const std::uniform_int_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %uniform_int_distribution random number
+   *        distribution @p __x into the output stream @p os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %uniform_int_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   * an error state.
+   */
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>&,
+	       const std::uniform_int_distribution<_IntType>&);
+
+  /**
+   * @brief Extracts a %uniform_int_distribution random number distribution
+   * @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x  A %uniform_int_distribution random number generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>&,
+	       std::uniform_int_distribution<_IntType>&);
+
+
+  /**
+   * @brief Uniform continuous distribution for random numbers.
+   *
+   * A continuous random distribution on the range [min, max) with equal
+   * probability throughout the range.  The URNG should be real-valued and
+   * deliver number in the range [0, 1).
+   */
+  template<typename _RealType = double>
+    class uniform_real_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef uniform_real_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __a = _RealType(0),
+		   _RealType __b = _RealType(1))
+	: _M_a(__a), _M_b(__b)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
+	}
+
+	result_type
+	a() const
+	{ return _M_a; }
+
+	result_type
+	b() const
+	{ return _M_b; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+      private:
+	_RealType _M_a;
+	_RealType _M_b;
+      };
+
+    public:
+      /**
+       * @brief Constructs a uniform_real_distribution object.
+       *
+       * @param __a [IN]  The lower bound of the distribution.
+       * @param __b [IN]  The upper bound of the distribution.
+       */
+      explicit
+      uniform_real_distribution(_RealType __a = _RealType(0),
+				_RealType __b = _RealType(1))
+      : _M_param(__a, __b)
+      { }
+
+      explicit
+      uniform_real_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       *
+       * Does nothing for the uniform real distribution.
+       */
+      void
+      reset() { }
+
+      result_type
+      a() const
+      { return _M_param.a(); }
+
+      result_type
+      b() const
+      { return _M_param.b(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the inclusive lower bound of the distribution range.
+       */
+      result_type
+      min() const
+      { return this->a(); }
+
+      /**
+       * @brief Returns the inclusive upper bound of the distribution range.
+       */
+      result_type
+      max() const
+      { return this->b(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+        { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	    __aurng(__urng);
+	  return (__aurng() * (__p.b() - __p.a())) + __p.a();
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two uniform real distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const uniform_real_distribution& __d1,
+		 const uniform_real_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two uniform real distributions have
+   *        different parameters.
+   */
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::uniform_real_distribution<_IntType>& __d1,
+	       const std::uniform_real_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %uniform_real_distribution random number
+   *        distribution @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %uniform_real_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   *          an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>&,
+	       const std::uniform_real_distribution<_RealType>&);
+
+  /**
+   * @brief Extracts a %uniform_real_distribution random number distribution
+   * @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x  A %uniform_real_distribution random number generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>&,
+	       std::uniform_real_distribution<_RealType>&);
+
+  /* @} */ // group random_distributions_uniform
+
+  /**
+   * @addtogroup random_distributions_normal Normal Distributions
+   * @ingroup random_distributions
+   * @{
+   */
+
+  /**
+   * @brief A normal continuous distribution for random numbers.
+   *
+   * The formula for the normal probability density function is
+   * @f[
+   *     p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
+   *            e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} } 
+   * @f]
+   */
+  template<typename _RealType = double>
+    class normal_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef normal_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __mean = _RealType(0),
+		   _RealType __stddev = _RealType(1))
+	: _M_mean(__mean), _M_stddev(__stddev)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_stddev > _RealType(0));
+	}
+
+	_RealType
+	mean() const
+	{ return _M_mean; }
+
+	_RealType
+	stddev() const
+	{ return _M_stddev; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return (__p1._M_mean == __p2._M_mean
+		  && __p1._M_stddev == __p2._M_stddev); }
+
+      private:
+	_RealType _M_mean;
+	_RealType _M_stddev;
+      };
+
+    public:
+      /**
+       * Constructs a normal distribution with parameters @f$mean@f$ and
+       * standard deviation.
+       */
+      explicit
+      normal_distribution(result_type __mean = result_type(0),
+			  result_type __stddev = result_type(1))
+      : _M_param(__mean, __stddev), _M_saved_available(false)
+      { }
+
+      explicit
+      normal_distribution(const param_type& __p)
+      : _M_param(__p), _M_saved_available(false)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_saved_available = false; }
+
+      /**
+       * @brief Returns the mean of the distribution.
+       */
+      _RealType
+      mean() const
+      { return _M_param.mean(); }
+
+      /**
+       * @brief Returns the standard deviation of the distribution.
+       */
+      _RealType
+      stddev() const
+      { return _M_param.stddev(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return std::numeric_limits<result_type>::lowest(); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two normal distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      template<typename _RealType1>
+	friend bool
+        operator==(const std::normal_distribution<_RealType1>& __d1,
+		   const std::normal_distribution<_RealType1>& __d2);
+
+      /**
+       * @brief Inserts a %normal_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %normal_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::normal_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %normal_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %normal_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::normal_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type  _M_param;
+      result_type _M_saved;
+      bool        _M_saved_available;
+    };
+
+  /**
+   * @brief Return true if two normal distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::normal_distribution<_RealType>& __d1,
+	       const std::normal_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A lognormal_distribution random number distribution.
+   *
+   * The formula for the normal probability mass function is
+   * @f[
+   *     p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
+   *                \exp{-\frac{(\ln{x} - m)^2}{2s^2}} 
+   * @f]
+   */
+  template<typename _RealType = double>
+    class lognormal_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef lognormal_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __m = _RealType(0),
+		   _RealType __s = _RealType(1))
+	: _M_m(__m), _M_s(__s)
+	{ }
+
+	_RealType
+	m() const
+	{ return _M_m; }
+
+	_RealType
+	s() const
+	{ return _M_s; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
+
+      private:
+	_RealType _M_m;
+	_RealType _M_s;
+      };
+
+      explicit
+      lognormal_distribution(_RealType __m = _RealType(0),
+			     _RealType __s = _RealType(1))
+      : _M_param(__m, __s), _M_nd()
+      { }
+
+      explicit
+      lognormal_distribution(const param_type& __p)
+      : _M_param(__p), _M_nd()
+      { }
+
+      /**
+       * Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      /**
+       *
+       */
+      _RealType
+      m() const
+      { return _M_param.m(); }
+
+      _RealType
+      s() const
+      { return _M_param.s(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+        { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+        { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two lognormal distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const lognormal_distribution& __d1,
+		 const lognormal_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_nd == __d2._M_nd); }
+
+      /**
+       * @brief Inserts a %lognormal_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %lognormal_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::lognormal_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %lognormal_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %lognormal_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::lognormal_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::normal_distribution<result_type> _M_nd;
+    };
+
+  /**
+   * @brief Return true if two lognormal distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::lognormal_distribution<_RealType>& __d1,
+	       const std::lognormal_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A gamma continuous distribution for random numbers.
+   *
+   * The formula for the gamma probability density function is:
+   * @f[
+   *     p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
+   *                         (x/\beta)^{\alpha - 1} e^{-x/\beta} 
+   * @f]
+   */
+  template<typename _RealType = double>
+    class gamma_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef gamma_distribution<_RealType> distribution_type;
+	friend class gamma_distribution<_RealType>;
+
+	explicit
+	param_type(_RealType __alpha_val = _RealType(1),
+		   _RealType __beta_val = _RealType(1))
+	: _M_alpha(__alpha_val), _M_beta(__beta_val)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
+	  _M_initialize();
+	}
+
+	_RealType
+	alpha() const
+	{ return _M_alpha; }
+
+	_RealType
+	beta() const
+	{ return _M_beta; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return (__p1._M_alpha == __p2._M_alpha
+		  && __p1._M_beta == __p2._M_beta); }
+
+      private:
+	void
+	_M_initialize();
+
+	_RealType _M_alpha;
+	_RealType _M_beta;
+
+	_RealType _M_malpha, _M_a2;
+      };
+
+    public:
+      /**
+       * @brief Constructs a gamma distribution with parameters
+       * @f$\alpha@f$ and @f$\beta@f$.
+       */
+      explicit
+      gamma_distribution(_RealType __alpha_val = _RealType(1),
+			 _RealType __beta_val = _RealType(1))
+      : _M_param(__alpha_val, __beta_val), _M_nd()
+      { }
+
+      explicit
+      gamma_distribution(const param_type& __p)
+      : _M_param(__p), _M_nd()
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      /**
+       * @brief Returns the @f$\alpha@f$ of the distribution.
+       */
+      _RealType
+      alpha() const
+      { return _M_param.alpha(); }
+
+      /**
+       * @brief Returns the @f$\beta@f$ of the distribution.
+       */
+      _RealType
+      beta() const
+      { return _M_param.beta(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two gamma distributions have the same
+       *        parameters and the sequences that would be generated
+       *        are equal.
+       */
+      friend bool
+      operator==(const gamma_distribution& __d1,
+		 const gamma_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_nd == __d2._M_nd); }
+
+      /**
+       * @brief Inserts a %gamma_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %gamma_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::gamma_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %gamma_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %gamma_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::gamma_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::normal_distribution<result_type> _M_nd;
+    };
+
+  /**
+   * @brief Return true if two gamma distributions are different.
+   */
+   template<typename _RealType>
+     inline bool
+     operator!=(const std::gamma_distribution<_RealType>& __d1,
+		const std::gamma_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A chi_squared_distribution random number distribution.
+   *
+   * The formula for the normal probability mass function is
+   * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$
+   */
+  template<typename _RealType = double>
+    class chi_squared_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef chi_squared_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __n = _RealType(1))
+	: _M_n(__n)
+	{ }
+
+	_RealType
+	n() const
+	{ return _M_n; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_n == __p2._M_n; }
+
+      private:
+	_RealType _M_n;
+      };
+
+      explicit
+      chi_squared_distribution(_RealType __n = _RealType(1))
+      : _M_param(__n), _M_gd(__n / 2)
+      { }
+
+      explicit
+      chi_squared_distribution(const param_type& __p)
+      : _M_param(__p), _M_gd(__p.n() / 2)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_gd.reset(); }
+
+      /**
+       *
+       */
+      _RealType
+      n() const
+      { return _M_param.n(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return 2 * _M_gd(__urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+        {
+	  typedef typename std::gamma_distribution<result_type>::param_type
+	    param_type;
+	  return 2 * _M_gd(__urng, param_type(__p.n() / 2));
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+        { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ typename std::gamma_distribution<result_type>::param_type
+	    __p2(__p.n() / 2);
+	  this->__generate_impl(__f, __t, __urng, __p2); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng)
+        { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ typename std::gamma_distribution<result_type>::param_type
+	    __p2(__p.n() / 2);
+	  this->__generate_impl(__f, __t, __urng, __p2); }
+
+      /**
+       * @brief Return true if two Chi-squared distributions have
+       *        the same parameters and the sequences that would be
+       *        generated are equal.
+       */
+      friend bool
+      operator==(const chi_squared_distribution& __d1,
+		 const chi_squared_distribution& __d2)
+      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
+
+      /**
+       * @brief Inserts a %chi_squared_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %chi_squared_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::chi_squared_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %chi_squared_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %chi_squared_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::chi_squared_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const typename
+			std::gamma_distribution<result_type>::param_type& __p);
+
+      param_type _M_param;
+
+      std::gamma_distribution<result_type> _M_gd;
+    };
+
+  /**
+   * @brief Return true if two Chi-squared distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::chi_squared_distribution<_RealType>& __d1,
+	       const std::chi_squared_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A cauchy_distribution random number distribution.
+   *
+   * The formula for the normal probability mass function is
+   * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$
+   */
+  template<typename _RealType = double>
+    class cauchy_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef cauchy_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __a = _RealType(0),
+		   _RealType __b = _RealType(1))
+	: _M_a(__a), _M_b(__b)
+	{ }
+
+	_RealType
+	a() const
+	{ return _M_a; }
+
+	_RealType
+	b() const
+	{ return _M_b; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+      private:
+	_RealType _M_a;
+	_RealType _M_b;
+      };
+
+      explicit
+      cauchy_distribution(_RealType __a = _RealType(0),
+			  _RealType __b = _RealType(1))
+      : _M_param(__a, __b)
+      { }
+
+      explicit
+      cauchy_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       *
+       */
+      _RealType
+      a() const
+      { return _M_param.a(); }
+
+      _RealType
+      b() const
+      { return _M_param.b(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return std::numeric_limits<result_type>::lowest(); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Cauchy distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const cauchy_distribution& __d1,
+		 const cauchy_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two Cauchy distributions have
+   *        different parameters.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::cauchy_distribution<_RealType>& __d1,
+	       const std::cauchy_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %cauchy_distribution random number distribution
+   * @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %cauchy_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   * an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const std::cauchy_distribution<_RealType>& __x);
+
+  /**
+   * @brief Extracts a %cauchy_distribution random number distribution
+   * @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x A %cauchy_distribution random number
+   *            generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       std::cauchy_distribution<_RealType>& __x);
+
+
+  /**
+   * @brief A fisher_f_distribution random number distribution.
+   *
+   * The formula for the normal probability mass function is
+   * @f[
+   *     p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
+   *                (\frac{m}{n})^{m/2} x^{(m/2)-1}
+   *                (1 + \frac{mx}{n})^{-(m+n)/2} 
+   * @f]
+   */
+  template<typename _RealType = double>
+    class fisher_f_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef fisher_f_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __m = _RealType(1),
+		   _RealType __n = _RealType(1))
+	: _M_m(__m), _M_n(__n)
+	{ }
+
+	_RealType
+	m() const
+	{ return _M_m; }
+
+	_RealType
+	n() const
+	{ return _M_n; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
+
+      private:
+	_RealType _M_m;
+	_RealType _M_n;
+      };
+
+      explicit
+      fisher_f_distribution(_RealType __m = _RealType(1),
+			    _RealType __n = _RealType(1))
+      : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
+      { }
+
+      explicit
+      fisher_f_distribution(const param_type& __p)
+      : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      {
+	_M_gd_x.reset();
+	_M_gd_y.reset();
+      }
+
+      /**
+       *
+       */
+      _RealType
+      m() const
+      { return _M_param.m(); }
+
+      _RealType
+      n() const
+      { return _M_param.n(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+        {
+	  typedef typename std::gamma_distribution<result_type>::param_type
+	    param_type;
+	  return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
+		  / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Fisher f distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const fisher_f_distribution& __d1,
+		 const fisher_f_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_gd_x == __d2._M_gd_x
+		&& __d1._M_gd_y == __d2._M_gd_y); }
+
+      /**
+       * @brief Inserts a %fisher_f_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %fisher_f_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::fisher_f_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %fisher_f_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %fisher_f_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::fisher_f_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
+    };
+
+  /**
+   * @brief Return true if two Fisher f distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::fisher_f_distribution<_RealType>& __d1,
+	       const std::fisher_f_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief A student_t_distribution random number distribution.
+   *
+   * The formula for the normal probability mass function is:
+   * @f[
+   *     p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
+   *              (1 + \frac{x^2}{n}) ^{-(n+1)/2} 
+   * @f]
+   */
+  template<typename _RealType = double>
+    class student_t_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef student_t_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __n = _RealType(1))
+	: _M_n(__n)
+	{ }
+
+	_RealType
+	n() const
+	{ return _M_n; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_n == __p2._M_n; }
+
+      private:
+	_RealType _M_n;
+      };
+
+      explicit
+      student_t_distribution(_RealType __n = _RealType(1))
+      : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
+      { }
+
+      explicit
+      student_t_distribution(const param_type& __p)
+      : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      {
+	_M_nd.reset();
+	_M_gd.reset();
+      }
+
+      /**
+       *
+       */
+      _RealType
+      n() const
+      { return _M_param.n(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return std::numeric_limits<result_type>::lowest(); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+        operator()(_UniformRandomNumberGenerator& __urng)
+        { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+        {
+	  typedef typename std::gamma_distribution<result_type>::param_type
+	    param_type;
+	
+	  const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
+	  return _M_nd(__urng) * std::sqrt(__p.n() / __g);
+        }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Student t distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const student_t_distribution& __d1,
+		 const student_t_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
+
+      /**
+       * @brief Inserts a %student_t_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %student_t_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::student_t_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %student_t_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %student_t_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::student_t_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng);
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::normal_distribution<result_type> _M_nd;
+      std::gamma_distribution<result_type> _M_gd;
+    };
+
+  /**
+   * @brief Return true if two Student t distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::student_t_distribution<_RealType>& __d1,
+	       const std::student_t_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /* @} */ // group random_distributions_normal
+
+  /**
+   * @addtogroup random_distributions_bernoulli Bernoulli Distributions
+   * @ingroup random_distributions
+   * @{
+   */
+
+  /**
+   * @brief A Bernoulli random number distribution.
+   *
+   * Generates a sequence of true and false values with likelihood @f$p@f$
+   * that true will come up and @f$(1 - p)@f$ that false will appear.
+   */
+  class bernoulli_distribution
+  {
+  public:
+    /** The type of the range of the distribution. */
+    typedef bool result_type;
+    /** Parameter type. */
+    struct param_type
+    {
+      typedef bernoulli_distribution distribution_type;
+
+      explicit
+      param_type(double __p = 0.5)
+      : _M_p(__p)
+      {
+	_GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
+      }
+
+      double
+      p() const
+      { return _M_p; }
+
+      friend bool
+      operator==(const param_type& __p1, const param_type& __p2)
+      { return __p1._M_p == __p2._M_p; }
+
+    private:
+      double _M_p;
+    };
+
+  public:
+    /**
+     * @brief Constructs a Bernoulli distribution with likelihood @p p.
+     *
+     * @param __p  [IN]  The likelihood of a true result being returned.
+     *                   Must be in the interval @f$[0, 1]@f$.
+     */
+    explicit
+    bernoulli_distribution(double __p = 0.5)
+    : _M_param(__p)
+    { }
+
+    explicit
+    bernoulli_distribution(const param_type& __p)
+    : _M_param(__p)
+    { }
+
+    /**
+     * @brief Resets the distribution state.
+     *
+     * Does nothing for a Bernoulli distribution.
+     */
+    void
+    reset() { }
+
+    /**
+     * @brief Returns the @p p parameter of the distribution.
+     */
+    double
+    p() const
+    { return _M_param.p(); }
+
+    /**
+     * @brief Returns the parameter set of the distribution.
+     */
+    param_type
+    param() const
+    { return _M_param; }
+
+    /**
+     * @brief Sets the parameter set of the distribution.
+     * @param __param The new parameter set of the distribution.
+     */
+    void
+    param(const param_type& __param)
+    { _M_param = __param; }
+
+    /**
+     * @brief Returns the greatest lower bound value of the distribution.
+     */
+    result_type
+    min() const
+    { return std::numeric_limits<result_type>::min(); }
+
+    /**
+     * @brief Returns the least upper bound value of the distribution.
+     */
+    result_type
+    max() const
+    { return std::numeric_limits<result_type>::max(); }
+
+    /**
+     * @brief Generating functions.
+     */
+    template<typename _UniformRandomNumberGenerator>
+      result_type
+      operator()(_UniformRandomNumberGenerator& __urng)
+      { return this->operator()(__urng, _M_param); }
+
+    template<typename _UniformRandomNumberGenerator>
+      result_type
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+	if ((__aurng() - __aurng.min())
+	     < __p.p() * (__aurng.max() - __aurng.min()))
+	  return true;
+	return false;
+      }
+
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      __generate(_ForwardIterator __f, _ForwardIterator __t,
+		 _UniformRandomNumberGenerator& __urng)
+      { this->__generate(__f, __t, __urng, _M_param); }
+
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      __generate(_ForwardIterator __f, _ForwardIterator __t,
+		 _UniformRandomNumberGenerator& __urng, const param_type& __p)
+      { this->__generate_impl(__f, __t, __urng, __p); }
+
+    template<typename _UniformRandomNumberGenerator>
+      void
+      __generate(result_type* __f, result_type* __t,
+		 _UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      { this->__generate_impl(__f, __t, __urng, __p); }
+
+    /**
+     * @brief Return true if two Bernoulli distributions have
+     *        the same parameters.
+     */
+    friend bool
+    operator==(const bernoulli_distribution& __d1,
+	       const bernoulli_distribution& __d2)
+    { return __d1._M_param == __d2._M_param; }
+
+  private:
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p);
+
+    param_type _M_param;
+  };
+
+  /**
+   * @brief Return true if two Bernoulli distributions have
+   *        different parameters.
+   */
+  inline bool
+  operator!=(const std::bernoulli_distribution& __d1,
+	     const std::bernoulli_distribution& __d2)
+  { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %bernoulli_distribution random number distribution
+   * @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %bernoulli_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   * an error state.
+   */
+  template<typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const std::bernoulli_distribution& __x);
+
+  /**
+   * @brief Extracts a %bernoulli_distribution random number distribution
+   * @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x  A %bernoulli_distribution random number generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       std::bernoulli_distribution& __x)
+    {
+      double __p;
+      __is >> __p;
+      __x.param(bernoulli_distribution::param_type(__p));
+      return __is;
+    }
+
+
+  /**
+   * @brief A discrete binomial random number distribution.
+   *
+   * The formula for the binomial probability density function is
+   * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
+   * and @f$p@f$ are the parameters of the distribution.
+   */
+  template<typename _IntType = int>
+    class binomial_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+		    "template argument not an integral type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _IntType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef binomial_distribution<_IntType> distribution_type;
+	friend class binomial_distribution<_IntType>;
+
+	explicit
+	param_type(_IntType __t = _IntType(1), double __p = 0.5)
+	: _M_t(__t), _M_p(__p)
+	{
+	  _GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0))
+				&& (_M_p >= 0.0)
+				&& (_M_p <= 1.0));
+	  _M_initialize();
+	}
+
+	_IntType
+	t() const
+	{ return _M_t; }
+
+	double
+	p() const
+	{ return _M_p; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
+
+      private:
+	void
+	_M_initialize();
+
+	_IntType _M_t;
+	double _M_p;
+
+	double _M_q;
+#if _GLIBCXX_USE_C99_MATH_TR1
+	double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
+	       _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
+#endif
+	bool   _M_easy;
+      };
+
+      // constructors and member function
+      explicit
+      binomial_distribution(_IntType __t = _IntType(1),
+			    double __p = 0.5)
+      : _M_param(__t, __p), _M_nd()
+      { }
+
+      explicit
+      binomial_distribution(const param_type& __p)
+      : _M_param(__p), _M_nd()
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      /**
+       * @brief Returns the distribution @p t parameter.
+       */
+      _IntType
+      t() const
+      { return _M_param.t(); }
+
+      /**
+       * @brief Returns the distribution @p p parameter.
+       */
+      double
+      p() const
+      { return _M_param.p(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return 0; }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return _M_param.t(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two binomial distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+	friend bool
+        operator==(const binomial_distribution& __d1,
+		   const binomial_distribution& __d2)
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+	{ return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
+#else
+        { return __d1._M_param == __d2._M_param; }
+#endif
+
+      /**
+       * @brief Inserts a %binomial_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %binomial_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::binomial_distribution<_IntType1>& __x);
+
+      /**
+       * @brief Extracts a %binomial_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %binomial_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<typename _IntType1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::binomial_distribution<_IntType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	_M_waiting(_UniformRandomNumberGenerator& __urng,
+		   _IntType __t, double __q);
+
+      param_type _M_param;
+
+      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+      std::normal_distribution<double> _M_nd;
+    };
+
+  /**
+   * @brief Return true if two binomial distributions are different.
+   */
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::binomial_distribution<_IntType>& __d1,
+	       const std::binomial_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A discrete geometric random number distribution.
+   *
+   * The formula for the geometric probability density function is
+   * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
+   * distribution.
+   */
+  template<typename _IntType = int>
+    class geometric_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+		    "template argument not an integral type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _IntType  result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef geometric_distribution<_IntType> distribution_type;
+	friend class geometric_distribution<_IntType>;
+
+	explicit
+	param_type(double __p = 0.5)
+	: _M_p(__p)
+	{
+	  _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
+	  _M_initialize();
+	}
+
+	double
+	p() const
+	{ return _M_p; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_p == __p2._M_p; }
+
+      private:
+	void
+	_M_initialize()
+	{ _M_log_1_p = std::log(1.0 - _M_p); }
+
+	double _M_p;
+
+	double _M_log_1_p;
+      };
+
+      // constructors and member function
+      explicit
+      geometric_distribution(double __p = 0.5)
+      : _M_param(__p)
+      { }
+
+      explicit
+      geometric_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       *
+       * Does nothing for the geometric distribution.
+       */
+      void
+      reset() { }
+
+      /**
+       * @brief Returns the distribution parameter @p p.
+       */
+      double
+      p() const
+      { return _M_param.p(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return 0; }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two geometric distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const geometric_distribution& __d1,
+		 const geometric_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two geometric distributions have
+   *        different parameters.
+   */
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::geometric_distribution<_IntType>& __d1,
+	       const std::geometric_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %geometric_distribution random number distribution
+   * @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %geometric_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   * an error state.
+   */
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const std::geometric_distribution<_IntType>& __x);
+
+  /**
+   * @brief Extracts a %geometric_distribution random number distribution
+   * @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x  A %geometric_distribution random number generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       std::geometric_distribution<_IntType>& __x);
+
+
+  /**
+   * @brief A negative_binomial_distribution random number distribution.
+   *
+   * The formula for the negative binomial probability mass function is
+   * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
+   * and @f$p@f$ are the parameters of the distribution.
+   */
+  template<typename _IntType = int>
+    class negative_binomial_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+		    "template argument not an integral type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _IntType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef negative_binomial_distribution<_IntType> distribution_type;
+
+	explicit
+	param_type(_IntType __k = 1, double __p = 0.5)
+	: _M_k(__k), _M_p(__p)
+	{
+	  _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
+	}
+
+	_IntType
+	k() const
+	{ return _M_k; }
+
+	double
+	p() const
+	{ return _M_p; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
+
+      private:
+	_IntType _M_k;
+	double _M_p;
+      };
+
+      explicit
+      negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
+      : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
+      { }
+
+      explicit
+      negative_binomial_distribution(const param_type& __p)
+      : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_gd.reset(); }
+
+      /**
+       * @brief Return the @f$k@f$ parameter of the distribution.
+       */
+      _IntType
+      k() const
+      { return _M_param.k(); }
+
+      /**
+       * @brief Return the @f$p@f$ parameter of the distribution.
+       */
+      double
+      p() const
+      { return _M_param.p(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two negative binomial distributions have
+       *        the same parameters and the sequences that would be
+       *        generated are equal.
+       */
+      friend bool
+      operator==(const negative_binomial_distribution& __d1,
+		 const negative_binomial_distribution& __d2)
+      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
+
+      /**
+       * @brief Inserts a %negative_binomial_distribution random
+       *        number distribution @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %negative_binomial_distribution random number
+       *             distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       *          an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::negative_binomial_distribution<_IntType1>& __x);
+
+      /**
+       * @brief Extracts a %negative_binomial_distribution random number
+       *        distribution @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %negative_binomial_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::negative_binomial_distribution<_IntType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng);
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::gamma_distribution<double> _M_gd;
+    };
+
+  /**
+   * @brief Return true if two negative binomial distributions are different.
+   */
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
+	       const std::negative_binomial_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /* @} */ // group random_distributions_bernoulli
+
+  /**
+   * @addtogroup random_distributions_poisson Poisson Distributions
+   * @ingroup random_distributions
+   * @{
+   */
+
+  /**
+   * @brief A discrete Poisson random number distribution.
+   *
+   * The formula for the Poisson probability density function is
+   * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
+   * parameter of the distribution.
+   */
+  template<typename _IntType = int>
+    class poisson_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+		    "template argument not an integral type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _IntType  result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef poisson_distribution<_IntType> distribution_type;
+	friend class poisson_distribution<_IntType>;
+
+	explicit
+	param_type(double __mean = 1.0)
+	: _M_mean(__mean)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
+	  _M_initialize();
+	}
+
+	double
+	mean() const
+	{ return _M_mean; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_mean == __p2._M_mean; }
+
+      private:
+	// Hosts either log(mean) or the threshold of the simple method.
+	void
+	_M_initialize();
+
+	double _M_mean;
+
+	double _M_lm_thr;
+#if _GLIBCXX_USE_C99_MATH_TR1
+	double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
+#endif
+      };
+
+      // constructors and member function
+      explicit
+      poisson_distribution(double __mean = 1.0)
+      : _M_param(__mean), _M_nd()
+      { }
+
+      explicit
+      poisson_distribution(const param_type& __p)
+      : _M_param(__p), _M_nd()
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      /**
+       * @brief Returns the distribution parameter @p mean.
+       */
+      double
+      mean() const
+      { return _M_param.mean(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return 0; }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+       /**
+	* @brief Return true if two Poisson distributions have the same
+	*        parameters and the sequences that would be generated
+	*        are equal.
+	*/
+      friend bool
+      operator==(const poisson_distribution& __d1,
+		 const poisson_distribution& __d2)
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+      { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
+#else
+      { return __d1._M_param == __d2._M_param; }
+#endif
+
+      /**
+       * @brief Inserts a %poisson_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %poisson_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::poisson_distribution<_IntType1>& __x);
+
+      /**
+       * @brief Extracts a %poisson_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %poisson_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::poisson_distribution<_IntType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+      std::normal_distribution<double> _M_nd;
+    };
+
+  /**
+   * @brief Return true if two Poisson distributions are different.
+   */
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::poisson_distribution<_IntType>& __d1,
+	       const std::poisson_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief An exponential continuous distribution for random numbers.
+   *
+   * The formula for the exponential probability density function is
+   * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
+   * <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr>
+   * <tr><td>Mode</td><td>@f$zero@f$</td></tr>
+   * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
+   * <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class exponential_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef exponential_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __lambda = _RealType(1))
+	: _M_lambda(__lambda)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0));
+	}
+
+	_RealType
+	lambda() const
+	{ return _M_lambda; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_lambda == __p2._M_lambda; }
+
+      private:
+	_RealType _M_lambda;
+      };
+
+    public:
+      /**
+       * @brief Constructs an exponential distribution with inverse scale
+       *        parameter @f$\lambda@f$.
+       */
+      explicit
+      exponential_distribution(const result_type& __lambda = result_type(1))
+      : _M_param(__lambda)
+      { }
+
+      explicit
+      exponential_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       *
+       * Has no effect on exponential distributions.
+       */
+      void
+      reset() { }
+
+      /**
+       * @brief Returns the inverse scale parameter of the distribution.
+       */
+      _RealType
+      lambda() const
+      { return _M_param.lambda(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+        { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	    __aurng(__urng);
+	  return -std::log(result_type(1) - __aurng()) / __p.lambda();
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two exponential distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const exponential_distribution& __d1,
+		 const exponential_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two exponential distributions have different
+   *        parameters.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::exponential_distribution<_RealType>& __d1,
+	       const std::exponential_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %exponential_distribution random number distribution
+   * @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %exponential_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   * an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const std::exponential_distribution<_RealType>& __x);
+
+  /**
+   * @brief Extracts a %exponential_distribution random number distribution
+   * @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x A %exponential_distribution random number
+   *            generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       std::exponential_distribution<_RealType>& __x);
+
+
+  /**
+   * @brief A weibull_distribution random number distribution.
+   *
+   * The formula for the normal probability density function is:
+   * @f[
+   *     p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
+   *                         \exp{(-(\frac{x}{\beta})^\alpha)} 
+   * @f]
+   */
+  template<typename _RealType = double>
+    class weibull_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef weibull_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __a = _RealType(1),
+		   _RealType __b = _RealType(1))
+	: _M_a(__a), _M_b(__b)
+	{ }
+
+	_RealType
+	a() const
+	{ return _M_a; }
+
+	_RealType
+	b() const
+	{ return _M_b; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+      private:
+	_RealType _M_a;
+	_RealType _M_b;
+      };
+
+      explicit
+      weibull_distribution(_RealType __a = _RealType(1),
+			   _RealType __b = _RealType(1))
+      : _M_param(__a, __b)
+      { }
+
+      explicit
+      weibull_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Return the @f$a@f$ parameter of the distribution.
+       */
+      _RealType
+      a() const
+      { return _M_param.a(); }
+
+      /**
+       * @brief Return the @f$b@f$ parameter of the distribution.
+       */
+      _RealType
+      b() const
+      { return _M_param.b(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Weibull distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const weibull_distribution& __d1,
+		 const weibull_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+   /**
+    * @brief Return true if two Weibull distributions have different
+    *        parameters.
+    */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::weibull_distribution<_RealType>& __d1,
+	       const std::weibull_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %weibull_distribution random number distribution
+   * @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %weibull_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   * an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const std::weibull_distribution<_RealType>& __x);
+
+  /**
+   * @brief Extracts a %weibull_distribution random number distribution
+   * @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x A %weibull_distribution random number
+   *            generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       std::weibull_distribution<_RealType>& __x);
+
+
+  /**
+   * @brief A extreme_value_distribution random number distribution.
+   *
+   * The formula for the normal probability mass function is
+   * @f[
+   *     p(x|a,b) = \frac{1}{b}
+   *                \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b})) 
+   * @f]
+   */
+  template<typename _RealType = double>
+    class extreme_value_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef extreme_value_distribution<_RealType> distribution_type;
+
+	explicit
+	param_type(_RealType __a = _RealType(0),
+		   _RealType __b = _RealType(1))
+	: _M_a(__a), _M_b(__b)
+	{ }
+
+	_RealType
+	a() const
+	{ return _M_a; }
+
+	_RealType
+	b() const
+	{ return _M_b; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+      private:
+	_RealType _M_a;
+	_RealType _M_b;
+      };
+
+      explicit
+      extreme_value_distribution(_RealType __a = _RealType(0),
+				 _RealType __b = _RealType(1))
+      : _M_param(__a, __b)
+      { }
+
+      explicit
+      extreme_value_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Return the @f$a@f$ parameter of the distribution.
+       */
+      _RealType
+      a() const
+      { return _M_param.a(); }
+
+      /**
+       * @brief Return the @f$b@f$ parameter of the distribution.
+       */
+      _RealType
+      b() const
+      { return _M_param.b(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return std::numeric_limits<result_type>::lowest(); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two extreme value distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const extreme_value_distribution& __d1,
+		 const extreme_value_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+    * @brief Return true if two extreme value distributions have different
+    *        parameters.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::extreme_value_distribution<_RealType>& __d1,
+	       const std::extreme_value_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+  /**
+   * @brief Inserts a %extreme_value_distribution random number distribution
+   * @p __x into the output stream @p __os.
+   *
+   * @param __os An output stream.
+   * @param __x  A %extreme_value_distribution random number distribution.
+   *
+   * @returns The output stream with the state of @p __x inserted or in
+   * an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const std::extreme_value_distribution<_RealType>& __x);
+
+  /**
+   * @brief Extracts a %extreme_value_distribution random number
+   *        distribution @p __x from the input stream @p __is.
+   *
+   * @param __is An input stream.
+   * @param __x A %extreme_value_distribution random number
+   *            generator engine.
+   *
+   * @returns The input stream with @p __x extracted or in an error state.
+   */
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       std::extreme_value_distribution<_RealType>& __x);
+
+
+  /**
+   * @brief A discrete_distribution random number distribution.
+   *
+   * The formula for the discrete probability mass function is
+   *
+   */
+  template<typename _IntType = int>
+    class discrete_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+		    "template argument not an integral type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _IntType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef discrete_distribution<_IntType> distribution_type;
+	friend class discrete_distribution<_IntType>;
+
+	param_type()
+	: _M_prob(), _M_cp()
+	{ }
+
+	template<typename _InputIterator>
+	  param_type(_InputIterator __wbegin,
+		     _InputIterator __wend)
+	  : _M_prob(__wbegin, __wend), _M_cp()
+	  { _M_initialize(); }
+
+	param_type(initializer_list<double> __wil)
+	: _M_prob(__wil.begin(), __wil.end()), _M_cp()
+	{ _M_initialize(); }
+
+	template<typename _Func>
+	  param_type(size_t __nw, double __xmin, double __xmax,
+		     _Func __fw);
+
+	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
+	param_type(const param_type&) = default;
+	param_type& operator=(const param_type&) = default;
+
+	std::vector<double>
+	probabilities() const
+	{ return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_prob == __p2._M_prob; }
+
+      private:
+	void
+	_M_initialize();
+
+	std::vector<double> _M_prob;
+	std::vector<double> _M_cp;
+      };
+
+      discrete_distribution()
+      : _M_param()
+      { }
+
+      template<typename _InputIterator>
+	discrete_distribution(_InputIterator __wbegin,
+			      _InputIterator __wend)
+	: _M_param(__wbegin, __wend)
+	{ }
+
+      discrete_distribution(initializer_list<double> __wl)
+      : _M_param(__wl)
+      { }
+
+      template<typename _Func>
+	discrete_distribution(size_t __nw, double __xmin, double __xmax,
+			      _Func __fw)
+	: _M_param(__nw, __xmin, __xmax, __fw)
+	{ }
+
+      explicit
+      discrete_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Returns the probabilities of the distribution.
+       */
+      std::vector<double>
+      probabilities() const
+      {
+	return _M_param._M_prob.empty()
+	  ? std::vector<double>(1, 1.0) : _M_param._M_prob;
+      }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      {
+	return _M_param._M_prob.empty()
+	  ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
+      }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two discrete distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const discrete_distribution& __d1,
+		 const discrete_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
+       * @brief Inserts a %discrete_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %discrete_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::discrete_distribution<_IntType1>& __x);
+
+      /**
+       * @brief Extracts a %discrete_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %discrete_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::discrete_distribution<_IntType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+    * @brief Return true if two discrete distributions have different
+    *        parameters.
+    */
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::discrete_distribution<_IntType>& __d1,
+	       const std::discrete_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A piecewise_constant_distribution random number distribution.
+   *
+   * The formula for the piecewise constant probability mass function is
+   *
+   */
+  template<typename _RealType = double>
+    class piecewise_constant_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef piecewise_constant_distribution<_RealType> distribution_type;
+	friend class piecewise_constant_distribution<_RealType>;
+
+	param_type()
+	: _M_int(), _M_den(), _M_cp()
+	{ }
+
+	template<typename _InputIteratorB, typename _InputIteratorW>
+	  param_type(_InputIteratorB __bfirst,
+		     _InputIteratorB __bend,
+		     _InputIteratorW __wbegin);
+
+	template<typename _Func>
+	  param_type(initializer_list<_RealType> __bi, _Func __fw);
+
+	template<typename _Func>
+	  param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
+		     _Func __fw);
+
+	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
+	param_type(const param_type&) = default;
+	param_type& operator=(const param_type&) = default;
+
+	std::vector<_RealType>
+	intervals() const
+	{
+	  if (_M_int.empty())
+	    {
+	      std::vector<_RealType> __tmp(2);
+	      __tmp[1] = _RealType(1);
+	      return __tmp;
+	    }
+	  else
+	    return _M_int;
+	}
+
+	std::vector<double>
+	densities() const
+	{ return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
+
+      private:
+	void
+	_M_initialize();
+
+	std::vector<_RealType> _M_int;
+	std::vector<double> _M_den;
+	std::vector<double> _M_cp;
+      };
+
+      explicit
+      piecewise_constant_distribution()
+      : _M_param()
+      { }
+
+      template<typename _InputIteratorB, typename _InputIteratorW>
+	piecewise_constant_distribution(_InputIteratorB __bfirst,
+					_InputIteratorB __bend,
+					_InputIteratorW __wbegin)
+	: _M_param(__bfirst, __bend, __wbegin)
+	{ }
+
+      template<typename _Func>
+	piecewise_constant_distribution(initializer_list<_RealType> __bl,
+					_Func __fw)
+	: _M_param(__bl, __fw)
+	{ }
+
+      template<typename _Func>
+	piecewise_constant_distribution(size_t __nw,
+					_RealType __xmin, _RealType __xmax,
+					_Func __fw)
+	: _M_param(__nw, __xmin, __xmax, __fw)
+	{ }
+
+      explicit
+      piecewise_constant_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Returns a vector of the intervals.
+       */
+      std::vector<_RealType>
+      intervals() const
+      {
+	if (_M_param._M_int.empty())
+	  {
+	    std::vector<_RealType> __tmp(2);
+	    __tmp[1] = _RealType(1);
+	    return __tmp;
+	  }
+	else
+	  return _M_param._M_int;
+      }
+
+      /**
+       * @brief Returns a vector of the probability densities.
+       */
+      std::vector<double>
+      densities() const
+      {
+	return _M_param._M_den.empty()
+	  ? std::vector<double>(1, 1.0) : _M_param._M_den;
+      }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      {
+	return _M_param._M_int.empty()
+	  ? result_type(0) : _M_param._M_int.front();
+      }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      {
+	return _M_param._M_int.empty()
+	  ? result_type(1) : _M_param._M_int.back();
+      }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two piecewise constant distributions have the
+       *        same parameters.
+       */
+      friend bool
+      operator==(const piecewise_constant_distribution& __d1,
+		 const piecewise_constant_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
+       * @brief Inserts a %piecewise_constant_distribution random
+       *        number distribution @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %piecewise_constant_distribution random number
+       *             distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::piecewise_constant_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %piecewise_constant_distribution random
+       *        number distribution @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %piecewise_constant_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::piecewise_constant_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+    * @brief Return true if two piecewise constant distributions have 
+    *        different parameters.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
+	       const std::piecewise_constant_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A piecewise_linear_distribution random number distribution.
+   *
+   * The formula for the piecewise linear probability mass function is
+   *
+   */
+  template<typename _RealType = double>
+    class piecewise_linear_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef piecewise_linear_distribution<_RealType> distribution_type;
+	friend class piecewise_linear_distribution<_RealType>;
+
+	param_type()
+	: _M_int(), _M_den(), _M_cp(), _M_m()
+	{ }
+
+	template<typename _InputIteratorB, typename _InputIteratorW>
+	  param_type(_InputIteratorB __bfirst,
+		     _InputIteratorB __bend,
+		     _InputIteratorW __wbegin);
+
+	template<typename _Func>
+	  param_type(initializer_list<_RealType> __bl, _Func __fw);
+
+	template<typename _Func>
+	  param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
+		     _Func __fw);
+
+	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
+	param_type(const param_type&) = default;
+	param_type& operator=(const param_type&) = default;
+
+	std::vector<_RealType>
+	intervals() const
+	{
+	  if (_M_int.empty())
+	    {
+	      std::vector<_RealType> __tmp(2);
+	      __tmp[1] = _RealType(1);
+	      return __tmp;
+	    }
+	  else
+	    return _M_int;
+	}
+
+	std::vector<double>
+	densities() const
+	{ return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return (__p1._M_int == __p2._M_int
+		  && __p1._M_den == __p2._M_den); }
+
+      private:
+	void
+	_M_initialize();
+
+	std::vector<_RealType> _M_int;
+	std::vector<double> _M_den;
+	std::vector<double> _M_cp;
+	std::vector<double> _M_m;
+      };
+
+      explicit
+      piecewise_linear_distribution()
+      : _M_param()
+      { }
+
+      template<typename _InputIteratorB, typename _InputIteratorW>
+	piecewise_linear_distribution(_InputIteratorB __bfirst,
+				      _InputIteratorB __bend,
+				      _InputIteratorW __wbegin)
+	: _M_param(__bfirst, __bend, __wbegin)
+	{ }
+
+      template<typename _Func>
+	piecewise_linear_distribution(initializer_list<_RealType> __bl,
+				      _Func __fw)
+	: _M_param(__bl, __fw)
+	{ }
+
+      template<typename _Func>
+	piecewise_linear_distribution(size_t __nw,
+				      _RealType __xmin, _RealType __xmax,
+				      _Func __fw)
+	: _M_param(__nw, __xmin, __xmax, __fw)
+	{ }
+
+      explicit
+      piecewise_linear_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Return the intervals of the distribution.
+       */
+      std::vector<_RealType>
+      intervals() const
+      {
+	if (_M_param._M_int.empty())
+	  {
+	    std::vector<_RealType> __tmp(2);
+	    __tmp[1] = _RealType(1);
+	    return __tmp;
+	  }
+	else
+	  return _M_param._M_int;
+      }
+
+      /**
+       * @brief Return a vector of the probability densities of the
+       *        distribution.
+       */
+      std::vector<double>
+      densities() const
+      {
+	return _M_param._M_den.empty()
+	  ? std::vector<double>(2, 1.0) : _M_param._M_den;
+      }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      {
+	return _M_param._M_int.empty()
+	  ? result_type(0) : _M_param._M_int.front();
+      }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      {
+	return _M_param._M_int.empty()
+	  ? result_type(1) : _M_param._M_int.back();
+      }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two piecewise linear distributions have the
+       *        same parameters.
+       */
+      friend bool
+      operator==(const piecewise_linear_distribution& __d1,
+		 const piecewise_linear_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
+       * @brief Inserts a %piecewise_linear_distribution random number
+       *        distribution @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %piecewise_linear_distribution random number
+       *             distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       *          an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const std::piecewise_linear_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %piecewise_linear_distribution random number
+       *        distribution @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %piecewise_linear_distribution random number
+       *             generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   std::piecewise_linear_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+    * @brief Return true if two piecewise linear distributions have
+    *        different parameters.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
+	       const std::piecewise_linear_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /* @} */ // group random_distributions_poisson
+
+  /* @} */ // group random_distributions
+
+  /**
+   * @addtogroup random_utilities Random Number Utilities
+   * @ingroup random
+   * @{
+   */
+
+  /**
+   * @brief The seed_seq class generates sequences of seeds for random
+   *        number generators.
+   */
+  class seed_seq
+  {
+
+  public:
+    /** The type of the seed vales. */
+    typedef uint_least32_t result_type;
+
+    /** Default constructor. */
+    seed_seq()
+    : _M_v()
+    { }
+
+    template<typename _IntType>
+      seed_seq(std::initializer_list<_IntType> il);
+
+    template<typename _InputIterator>
+      seed_seq(_InputIterator __begin, _InputIterator __end);
+
+    // generating functions
+    template<typename _RandomAccessIterator>
+      void
+      generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
+
+    // property functions
+    size_t size() const
+    { return _M_v.size(); }
+
+    template<typename OutputIterator>
+      void
+      param(OutputIterator __dest) const
+      { std::copy(_M_v.begin(), _M_v.end(), __dest); }
+
+  private:
+    ///
+    std::vector<result_type> _M_v;
+  };
+
+  /* @} */ // group random_utilities
+
+  /* @} */ // group random
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/random.tcc b/gcc-4.9/libstdc++-v3/include/bits/random.tcc
new file mode 100644
index 0000000..0eda287
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/random.tcc
@@ -0,0 +1,3486 @@
+// random number generation (out of line) -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/random.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{random}
+ */
+
+#ifndef _RANDOM_TCC
+#define _RANDOM_TCC 1
+
+#include <numeric> // std::accumulate and std::partial_sum
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  /*
+   * (Further) implementation-space details.
+   */
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    // General case for x = (ax + c) mod m -- use Schrage's algorithm
+    // to avoid integer overflow.
+    //
+    // Preconditions:  a > 0, m > 0.
+    //
+    // Note: only works correctly for __m % __a < __m / __a.
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
+      _Tp
+      _Mod<_Tp, __m, __a, __c, false, true>::
+      __calc(_Tp __x)
+      {
+	if (__a == 1)
+	  __x %= __m;
+	else
+	  {
+	    static const _Tp __q = __m / __a;
+	    static const _Tp __r = __m % __a;
+
+	    _Tp __t1 = __a * (__x % __q);
+	    _Tp __t2 = __r * (__x / __q);
+	    if (__t1 >= __t2)
+	      __x = __t1 - __t2;
+	    else
+	      __x = __m - __t2 + __t1;
+	  }
+
+	if (__c != 0)
+	  {
+	    const _Tp __d = __m - __x;
+	    if (__d > __c)
+	      __x += __c;
+	    else
+	      __x = __c - __d;
+	  }
+	return __x;
+      }
+
+    template<typename _InputIterator, typename _OutputIterator,
+	     typename _Tp>
+      _OutputIterator
+      __normalize(_InputIterator __first, _InputIterator __last,
+		  _OutputIterator __result, const _Tp& __factor)
+      {
+	for (; __first != __last; ++__first, ++__result)
+	  *__result = *__first / __factor;
+	return __result;
+      }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace __detail
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    constexpr _UIntType
+    linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
+
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    constexpr _UIntType
+    linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
+
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    constexpr _UIntType
+    linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
+
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    constexpr _UIntType
+    linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
+
+  /**
+   * Seeds the LCR with integral value @p __s, adjusted so that the
+   * ring identity is never a member of the convergence set.
+   */
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    void
+    linear_congruential_engine<_UIntType, __a, __c, __m>::
+    seed(result_type __s)
+    {
+      if ((__detail::__mod<_UIntType, __m>(__c) == 0)
+	  && (__detail::__mod<_UIntType, __m>(__s) == 0))
+	_M_x = 1;
+      else
+	_M_x = __detail::__mod<_UIntType, __m>(__s);
+    }
+
+  /**
+   * Seeds the LCR engine with a value generated by @p __q.
+   */
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    template<typename _Sseq>
+      typename std::enable_if<std::is_class<_Sseq>::value>::type
+      linear_congruential_engine<_UIntType, __a, __c, __m>::
+      seed(_Sseq& __q)
+      {
+	const _UIntType __k0 = __m == 0 ? std::numeric_limits<_UIntType>::digits
+	                                : std::__lg(__m);
+	const _UIntType __k = (__k0 + 31) / 32;
+	uint_least32_t __arr[__k + 3];
+	__q.generate(__arr + 0, __arr + __k + 3);
+	_UIntType __factor = 1u;
+	_UIntType __sum = 0u;
+	for (size_t __j = 0; __j < __k; ++__j)
+	  {
+	    __sum += __arr[__j + 3] * __factor;
+	    __factor *= __detail::_Shift<_UIntType, 32>::__value;
+	  }
+	seed(__sum);
+      }
+
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const linear_congruential_engine<_UIntType,
+						__a, __c, __m>& __lcr)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__os.widen(' '));
+
+      __os << __lcr._M_x;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec);
+
+      __is >> __lcr._M_x;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::word_size;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::state_size;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::shift_size;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::mask_bits;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr _UIntType
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::xor_mask;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::tempering_u;
+   
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr _UIntType
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::tempering_d;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::tempering_s;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr _UIntType
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::tempering_b;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::tempering_t;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr _UIntType
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::tempering_c;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr size_t
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::tempering_l;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr _UIntType
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::
+                                              initialization_multiplier;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    constexpr _UIntType
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::default_seed;
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    void
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::
+    seed(result_type __sd)
+    {
+      _M_x[0] = __detail::__mod<_UIntType,
+	__detail::_Shift<_UIntType, __w>::__value>(__sd);
+
+      for (size_t __i = 1; __i < state_size; ++__i)
+	{
+	  _UIntType __x = _M_x[__i - 1];
+	  __x ^= __x >> (__w - 2);
+	  __x *= __f;
+	  __x += __detail::__mod<_UIntType, __n>(__i);
+	  _M_x[__i] = __detail::__mod<_UIntType,
+	    __detail::_Shift<_UIntType, __w>::__value>(__x);
+	}
+      _M_p = state_size;
+    }
+
+  template<typename _UIntType,
+	   size_t __w, size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    template<typename _Sseq>
+      typename std::enable_if<std::is_class<_Sseq>::value>::type
+      mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			      __s, __b, __t, __c, __l, __f>::
+      seed(_Sseq& __q)
+      {
+	const _UIntType __upper_mask = (~_UIntType()) << __r;
+	const size_t __k = (__w + 31) / 32;
+	uint_least32_t __arr[__n * __k];
+	__q.generate(__arr + 0, __arr + __n * __k);
+
+	bool __zero = true;
+	for (size_t __i = 0; __i < state_size; ++__i)
+	  {
+	    _UIntType __factor = 1u;
+	    _UIntType __sum = 0u;
+	    for (size_t __j = 0; __j < __k; ++__j)
+	      {
+		__sum += __arr[__k * __i + __j] * __factor;
+		__factor *= __detail::_Shift<_UIntType, 32>::__value;
+	      }
+	    _M_x[__i] = __detail::__mod<_UIntType,
+	      __detail::_Shift<_UIntType, __w>::__value>(__sum);
+
+	    if (__zero)
+	      {
+		if (__i == 0)
+		  {
+		    if ((_M_x[0] & __upper_mask) != 0u)
+		      __zero = false;
+		  }
+		else if (_M_x[__i] != 0u)
+		  __zero = false;
+	      }
+	  }
+        if (__zero)
+          _M_x[0] = __detail::_Shift<_UIntType, __w - 1>::__value;
+	_M_p = state_size;
+      }
+
+  template<typename _UIntType, size_t __w,
+	   size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    void
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::
+    _M_gen_rand(void)
+    {
+      const _UIntType __upper_mask = (~_UIntType()) << __r;
+      const _UIntType __lower_mask = ~__upper_mask;
+
+      for (size_t __k = 0; __k < (__n - __m); ++__k)
+        {
+	  _UIntType __y = ((_M_x[__k] & __upper_mask)
+			   | (_M_x[__k + 1] & __lower_mask));
+	  _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
+		       ^ ((__y & 0x01) ? __a : 0));
+        }
+
+      for (size_t __k = (__n - __m); __k < (__n - 1); ++__k)
+	{
+	  _UIntType __y = ((_M_x[__k] & __upper_mask)
+			   | (_M_x[__k + 1] & __lower_mask));
+	  _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
+		       ^ ((__y & 0x01) ? __a : 0));
+	}
+
+      _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
+		       | (_M_x[0] & __lower_mask));
+      _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
+		       ^ ((__y & 0x01) ? __a : 0));
+      _M_p = 0;
+    }
+
+  template<typename _UIntType, size_t __w,
+	   size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    void
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::
+    discard(unsigned long long __z)
+    {
+      while (__z > state_size - _M_p)
+	{
+	  __z -= state_size - _M_p;
+	  _M_gen_rand();
+	}
+      _M_p += __z;
+    }
+
+  template<typename _UIntType, size_t __w,
+	   size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f>
+    typename
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+			    __s, __b, __t, __c, __l, __f>::
+    operator()()
+    {
+      // Reload the vector - cost is O(n) amortized over n calls.
+      if (_M_p >= state_size)
+	_M_gen_rand();
+
+      // Calculate o(x(i)).
+      result_type __z = _M_x[_M_p++];
+      __z ^= (__z >> __u) & __d;
+      __z ^= (__z << __s) & __b;
+      __z ^= (__z << __t) & __c;
+      __z ^= (__z >> __l);
+
+      return __z;
+    }
+
+  template<typename _UIntType, size_t __w,
+	   size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const mersenne_twister_engine<_UIntType, __w, __n, __m,
+	       __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      for (size_t __i = 0; __i < __n; ++__i)
+	__os << __x._M_x[__i] << __space;
+      __os << __x._M_p;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _UIntType, size_t __w,
+	   size_t __n, size_t __m, size_t __r,
+	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+	   _UIntType __b, size_t __t, _UIntType __c, size_t __l,
+	   _UIntType __f, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       mersenne_twister_engine<_UIntType, __w, __n, __m,
+	       __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      for (size_t __i = 0; __i < __n; ++__i)
+	__is >> __x._M_x[__i];
+      __is >> __x._M_p;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    constexpr size_t
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    constexpr size_t
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    constexpr size_t
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    constexpr _UIntType
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    void
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::
+    seed(result_type __value)
+    {
+      std::linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
+	__lcg(__value == 0u ? default_seed : __value);
+
+      const size_t __n = (__w + 31) / 32;
+
+      for (size_t __i = 0; __i < long_lag; ++__i)
+	{
+	  _UIntType __sum = 0u;
+	  _UIntType __factor = 1u;
+	  for (size_t __j = 0; __j < __n; ++__j)
+	    {
+	      __sum += __detail::__mod<uint_least32_t,
+		       __detail::_Shift<uint_least32_t, 32>::__value>
+			 (__lcg()) * __factor;
+	      __factor *= __detail::_Shift<_UIntType, 32>::__value;
+	    }
+	  _M_x[__i] = __detail::__mod<_UIntType,
+	    __detail::_Shift<_UIntType, __w>::__value>(__sum);
+	}
+      _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
+      _M_p = 0;
+    }
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    template<typename _Sseq>
+      typename std::enable_if<std::is_class<_Sseq>::value>::type
+      subtract_with_carry_engine<_UIntType, __w, __s, __r>::
+      seed(_Sseq& __q)
+      {
+	const size_t __k = (__w + 31) / 32;
+	uint_least32_t __arr[__r * __k];
+	__q.generate(__arr + 0, __arr + __r * __k);
+
+	for (size_t __i = 0; __i < long_lag; ++__i)
+	  {
+	    _UIntType __sum = 0u;
+	    _UIntType __factor = 1u;
+	    for (size_t __j = 0; __j < __k; ++__j)
+	      {
+		__sum += __arr[__k * __i + __j] * __factor;
+		__factor *= __detail::_Shift<_UIntType, 32>::__value;
+	      }
+	    _M_x[__i] = __detail::__mod<_UIntType,
+	      __detail::_Shift<_UIntType, __w>::__value>(__sum);
+	  }
+	_M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
+	_M_p = 0;
+      }
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::
+	     result_type
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::
+    operator()()
+    {
+      // Derive short lag index from current index.
+      long __ps = _M_p - short_lag;
+      if (__ps < 0)
+	__ps += long_lag;
+
+      // Calculate new x(i) without overflow or division.
+      // NB: Thanks to the requirements for _UIntType, _M_x[_M_p] + _M_carry
+      // cannot overflow.
+      _UIntType __xi;
+      if (_M_x[__ps] >= _M_x[_M_p] + _M_carry)
+	{
+	  __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry;
+	  _M_carry = 0;
+	}
+      else
+	{
+	  __xi = (__detail::_Shift<_UIntType, __w>::__value
+		  - _M_x[_M_p] - _M_carry + _M_x[__ps]);
+	  _M_carry = 1;
+	}
+      _M_x[_M_p] = __xi;
+
+      // Adjust current index to loop around in ring buffer.
+      if (++_M_p >= long_lag)
+	_M_p = 0;
+
+      return __xi;
+    }
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const subtract_with_carry_engine<_UIntType,
+						__w, __s, __r>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      for (size_t __i = 0; __i < __r; ++__i)
+	__os << __x._M_x[__i] << __space;
+      __os << __x._M_carry << __space << __x._M_p;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      for (size_t __i = 0; __i < __r; ++__i)
+	__is >> __x._M_x[__i];
+      __is >> __x._M_carry;
+      __is >> __x._M_p;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RandomNumberEngine, size_t __p, size_t __r>
+    constexpr size_t
+    discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;
+
+  template<typename _RandomNumberEngine, size_t __p, size_t __r>
+    constexpr size_t
+    discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;
+
+  template<typename _RandomNumberEngine, size_t __p, size_t __r>
+    typename discard_block_engine<_RandomNumberEngine,
+			   __p, __r>::result_type
+    discard_block_engine<_RandomNumberEngine, __p, __r>::
+    operator()()
+    {
+      if (_M_n >= used_block)
+	{
+	  _M_b.discard(block_size - _M_n);
+	  _M_n = 0;
+	}
+      ++_M_n;
+      return _M_b();
+    }
+
+  template<typename _RandomNumberEngine, size_t __p, size_t __r,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const discard_block_engine<_RandomNumberEngine,
+	       __p, __r>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      __os << __x.base() << __space << __x._M_n;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _RandomNumberEngine, size_t __p, size_t __r,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      __is >> __x._M_b >> __x._M_n;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
+    typename independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
+      result_type
+    independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
+    operator()()
+    {
+      typedef typename _RandomNumberEngine::result_type _Eresult_type;
+      const _Eresult_type __r
+	= (_M_b.max() - _M_b.min() < std::numeric_limits<_Eresult_type>::max()
+	   ? _M_b.max() - _M_b.min() + 1 : 0);
+      const unsigned __edig = std::numeric_limits<_Eresult_type>::digits;
+      const unsigned __m = __r ? std::__lg(__r) : __edig;
+
+      typedef typename std::common_type<_Eresult_type, result_type>::type
+	__ctype;
+      const unsigned __cdig = std::numeric_limits<__ctype>::digits;
+
+      unsigned __n, __n0;
+      __ctype __s0, __s1, __y0, __y1;
+
+      for (size_t __i = 0; __i < 2; ++__i)
+	{
+	  __n = (__w + __m - 1) / __m + __i;
+	  __n0 = __n - __w % __n;
+	  const unsigned __w0 = __w / __n;  // __w0 <= __m
+
+	  __s0 = 0;
+	  __s1 = 0;
+	  if (__w0 < __cdig)
+	    {
+	      __s0 = __ctype(1) << __w0;
+	      __s1 = __s0 << 1;
+	    }
+
+	  __y0 = 0;
+	  __y1 = 0;
+	  if (__r)
+	    {
+	      __y0 = __s0 * (__r / __s0);
+	      if (__s1)
+		__y1 = __s1 * (__r / __s1);
+
+	      if (__r - __y0 <= __y0 / __n)
+		break;
+	    }
+	  else
+	    break;
+	}
+
+      result_type __sum = 0;
+      for (size_t __k = 0; __k < __n0; ++__k)
+	{
+	  __ctype __u;
+	  do
+	    __u = _M_b() - _M_b.min();
+	  while (__y0 && __u >= __y0);
+	  __sum = __s0 * __sum + (__s0 ? __u % __s0 : __u);
+	}
+      for (size_t __k = __n0; __k < __n; ++__k)
+	{
+	  __ctype __u;
+	  do
+	    __u = _M_b() - _M_b.min();
+	  while (__y1 && __u >= __y1);
+	  __sum = __s1 * __sum + (__s1 ? __u % __s1 : __u);
+	}
+      return __sum;
+    }
+
+
+  template<typename _RandomNumberEngine, size_t __k>
+    constexpr size_t
+    shuffle_order_engine<_RandomNumberEngine, __k>::table_size;
+
+  template<typename _RandomNumberEngine, size_t __k>
+    typename shuffle_order_engine<_RandomNumberEngine, __k>::result_type
+    shuffle_order_engine<_RandomNumberEngine, __k>::
+    operator()()
+    {
+      size_t __j = __k * ((_M_y - _M_b.min())
+			  / (_M_b.max() - _M_b.min() + 1.0L));
+      _M_y = _M_v[__j];
+      _M_v[__j] = _M_b();
+
+      return _M_y;
+    }
+
+  template<typename _RandomNumberEngine, size_t __k,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const shuffle_order_engine<_RandomNumberEngine, __k>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      __os << __x.base();
+      for (size_t __i = 0; __i < __k; ++__i)
+	__os << __space << __x._M_v[__i];
+      __os << __space << __x._M_y;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _RandomNumberEngine, size_t __k,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       shuffle_order_engine<_RandomNumberEngine, __k>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      __is >> __x._M_b;
+      for (size_t __i = 0; __i < __k; ++__i)
+	__is >> __x._M_v[__i];
+      __is >> __x._M_y;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename uniform_int_distribution<_IntType>::result_type
+      uniform_int_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	typedef typename _UniformRandomNumberGenerator::result_type
+	  _Gresult_type;
+	typedef typename std::make_unsigned<result_type>::type __utype;
+	typedef typename std::common_type<_Gresult_type, __utype>::type
+	  __uctype;
+
+	const __uctype __urngmin = __urng.min();
+	const __uctype __urngmax = __urng.max();
+	const __uctype __urngrange = __urngmax - __urngmin;
+	const __uctype __urange
+	  = __uctype(__param.b()) - __uctype(__param.a());
+
+	__uctype __ret;
+
+	if (__urngrange > __urange)
+	  {
+	    // downscaling
+	    const __uctype __uerange = __urange + 1; // __urange can be zero
+	    const __uctype __scaling = __urngrange / __uerange;
+	    const __uctype __past = __uerange * __scaling;
+	    do
+	      __ret = __uctype(__urng()) - __urngmin;
+	    while (__ret >= __past);
+	    __ret /= __scaling;
+	  }
+	else if (__urngrange < __urange)
+	  {
+	    // upscaling
+	    /*
+	      Note that every value in [0, urange]
+	      can be written uniquely as
+
+	      (urngrange + 1) * high + low
+
+	      where
+
+	      high in [0, urange / (urngrange + 1)]
+
+	      and
+	
+	      low in [0, urngrange].
+	    */
+	    __uctype __tmp; // wraparound control
+	    do
+	      {
+		const __uctype __uerngrange = __urngrange + 1;
+		__tmp = (__uerngrange * operator()
+			 (__urng, param_type(0, __urange / __uerngrange)));
+		__ret = __tmp + (__uctype(__urng()) - __urngmin);
+	      }
+	    while (__ret > __urange || __ret < __tmp);
+	  }
+	else
+	  __ret = __uctype(__urng()) - __urngmin;
+
+	return __ret + __param.a();
+      }
+
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      uniform_int_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	typedef typename _UniformRandomNumberGenerator::result_type
+	  _Gresult_type;
+	typedef typename std::make_unsigned<result_type>::type __utype;
+	typedef typename std::common_type<_Gresult_type, __utype>::type
+	  __uctype;
+
+	const __uctype __urngmin = __urng.min();
+	const __uctype __urngmax = __urng.max();
+	const __uctype __urngrange = __urngmax - __urngmin;
+	const __uctype __urange
+	  = __uctype(__param.b()) - __uctype(__param.a());
+
+	__uctype __ret;
+
+	if (__urngrange > __urange)
+	  {
+	    if (__detail::_Power_of_2(__urngrange + 1)
+		&& __detail::_Power_of_2(__urange + 1))
+	      {
+		while (__f != __t)
+		  {
+		    __ret = __uctype(__urng()) - __urngmin;
+		    *__f++ = (__ret & __urange) + __param.a();
+		  }
+	      }
+	    else
+	      {
+		// downscaling
+		const __uctype __uerange = __urange + 1; // __urange can be zero
+		const __uctype __scaling = __urngrange / __uerange;
+		const __uctype __past = __uerange * __scaling;
+		while (__f != __t)
+		  {
+		    do
+		      __ret = __uctype(__urng()) - __urngmin;
+		    while (__ret >= __past);
+		    *__f++ = __ret / __scaling + __param.a();
+		  }
+	      }
+	  }
+	else if (__urngrange < __urange)
+	  {
+	    // upscaling
+	    /*
+	      Note that every value in [0, urange]
+	      can be written uniquely as
+
+	      (urngrange + 1) * high + low
+
+	      where
+
+	      high in [0, urange / (urngrange + 1)]
+
+	      and
+
+	      low in [0, urngrange].
+	    */
+	    __uctype __tmp; // wraparound control
+	    while (__f != __t)
+	      {
+		do
+		  {
+		    const __uctype __uerngrange = __urngrange + 1;
+		    __tmp = (__uerngrange * operator()
+			     (__urng, param_type(0, __urange / __uerngrange)));
+		    __ret = __tmp + (__uctype(__urng()) - __urngmin);
+		  }
+		while (__ret > __urange || __ret < __tmp);
+		*__f++ = __ret;
+	      }
+	  }
+	else
+	  while (__f != __t)
+	    *__f++ = __uctype(__urng()) - __urngmin + __param.a();
+      }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const uniform_int_distribution<_IntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+
+      __os << __x.a() << __space << __x.b();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       uniform_int_distribution<_IntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _IntType __a, __b;
+      __is >> __a >> __b;
+      __x.param(typename uniform_int_distribution<_IntType>::
+		param_type(__a, __b));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      uniform_real_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+	auto __range = __p.b() - __p.a();
+	while (__f != __t)
+	  *__f++ = __aurng() * __range + __p.a();
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const uniform_real_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.a() << __space << __x.b();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       uniform_real_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      _RealType __a, __b;
+      __is >> __a >> __b;
+      __x.param(typename uniform_real_distribution<_RealType>::
+		param_type(__a, __b));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _ForwardIterator,
+	   typename _UniformRandomNumberGenerator>
+    void
+    std::bernoulli_distribution::
+    __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		    _UniformRandomNumberGenerator& __urng,
+		    const param_type& __p)
+    {
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	__aurng(__urng);
+      auto __limit = __p.p() * (__aurng.max() - __aurng.min());
+
+      while (__f != __t)
+	*__f++ = (__aurng() - __aurng.min()) < __limit;
+    }
+
+  template<typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const bernoulli_distribution& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(std::numeric_limits<double>::max_digits10);
+
+      __os << __x.p();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename geometric_distribution<_IntType>::result_type
+      geometric_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	// About the epsilon thing see this thread:
+	// http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html
+	const double __naf =
+	  (1 - std::numeric_limits<double>::epsilon()) / 2;
+	// The largest _RealType convertible to _IntType.
+	const double __thr =
+	  std::numeric_limits<_IntType>::max() + __naf;
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	double __cand;
+	do
+	  __cand = std::floor(std::log(1.0 - __aurng()) / __param._M_log_1_p);
+	while (__cand >= __thr);
+
+	return result_type(__cand + __naf);
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      geometric_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	// About the epsilon thing see this thread:
+	// http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html
+	const double __naf =
+	  (1 - std::numeric_limits<double>::epsilon()) / 2;
+	// The largest _RealType convertible to _IntType.
+	const double __thr =
+	  std::numeric_limits<_IntType>::max() + __naf;
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	while (__f != __t)
+	  {
+	    double __cand;
+	    do
+	      __cand = std::floor(std::log(1.0 - __aurng())
+				  / __param._M_log_1_p);
+	    while (__cand >= __thr);
+
+	    *__f++ = __cand + __naf;
+	  }
+      }
+
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const geometric_distribution<_IntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(std::numeric_limits<double>::max_digits10);
+
+      __os << __x.p();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       geometric_distribution<_IntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      double __p;
+      __is >> __p;
+      __x.param(typename geometric_distribution<_IntType>::param_type(__p));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+  // This is Leger's algorithm, also in Devroye, Ch. X, Example 1.5.
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename negative_binomial_distribution<_IntType>::result_type
+      negative_binomial_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	const double __y = _M_gd(__urng);
+
+	// XXX Is the constructor too slow?
+	std::poisson_distribution<result_type> __poisson(__y);
+	return __poisson(__urng);
+      }
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename negative_binomial_distribution<_IntType>::result_type
+      negative_binomial_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      {
+	typedef typename std::gamma_distribution<double>::param_type
+	  param_type;
+	
+	const double __y =
+	  _M_gd(__urng, param_type(__p.k(), (1.0 - __p.p()) / __p.p()));
+
+	std::poisson_distribution<result_type> __poisson(__y);
+	return __poisson(__urng);
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      negative_binomial_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	while (__f != __t)
+	  {
+	    const double __y = _M_gd(__urng);
+
+	    // XXX Is the constructor too slow?
+	    std::poisson_distribution<result_type> __poisson(__y);
+	    *__f++ = __poisson(__urng);
+	  }
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      negative_binomial_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	typename std::gamma_distribution<result_type>::param_type
+	  __p2(__p.k(), (1.0 - __p.p()) / __p.p());
+
+	while (__f != __t)
+	  {
+	    const double __y = _M_gd(__urng, __p2);
+
+	    std::poisson_distribution<result_type> __poisson(__y);
+	    *__f++ = __poisson(__urng);
+	  }
+      }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const negative_binomial_distribution<_IntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(std::numeric_limits<double>::max_digits10);
+
+      __os << __x.k() << __space << __x.p()
+	   << __space << __x._M_gd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       negative_binomial_distribution<_IntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      _IntType __k;
+      double __p;
+      __is >> __k >> __p >> __x._M_gd;
+      __x.param(typename negative_binomial_distribution<_IntType>::
+		param_type(__k, __p));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType>
+    void
+    poisson_distribution<_IntType>::param_type::
+    _M_initialize()
+    {
+#if _GLIBCXX_USE_C99_MATH_TR1
+      if (_M_mean >= 12)
+	{
+	  const double __m = std::floor(_M_mean);
+	  _M_lm_thr = std::log(_M_mean);
+	  _M_lfm = std::lgamma(__m + 1);
+	  _M_sm = std::sqrt(__m);
+
+	  const double __pi_4 = 0.7853981633974483096156608458198757L;
+	  const double __dx = std::sqrt(2 * __m * std::log(32 * __m
+							      / __pi_4));
+	  _M_d = std::round(std::max(6.0, std::min(__m, __dx)));
+	  const double __cx = 2 * __m + _M_d;
+	  _M_scx = std::sqrt(__cx / 2);
+	  _M_1cx = 1 / __cx;
+
+	  _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx);
+	  _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2))
+		/ _M_d;
+	}
+      else
+#endif
+	_M_lm_thr = std::exp(-_M_mean);
+      }
+
+  /**
+   * A rejection algorithm when mean >= 12 and a simple method based
+   * upon the multiplication of uniform random variates otherwise.
+   * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
+   * is defined.
+   *
+   * Reference:
+   * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+   * New York, 1986, Ch. X, Sects. 3.3 & 3.4 (+ Errata!).
+   */
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename poisson_distribution<_IntType>::result_type
+      poisson_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+#if _GLIBCXX_USE_C99_MATH_TR1
+	if (__param.mean() >= 12)
+	  {
+	    double __x;
+
+	    // See comments above...
+	    const double __naf =
+	      (1 - std::numeric_limits<double>::epsilon()) / 2;
+	    const double __thr =
+	      std::numeric_limits<_IntType>::max() + __naf;
+
+	    const double __m = std::floor(__param.mean());
+	    // sqrt(pi / 2)
+	    const double __spi_2 = 1.2533141373155002512078826424055226L;
+	    const double __c1 = __param._M_sm * __spi_2;
+	    const double __c2 = __param._M_c2b + __c1;
+	    const double __c3 = __c2 + 1;
+	    const double __c4 = __c3 + 1;
+	    // e^(1 / 78)
+	    const double __e178 = 1.0129030479320018583185514777512983L;
+	    const double __c5 = __c4 + __e178;
+	    const double __c = __param._M_cb + __c5;
+	    const double __2cx = 2 * (2 * __m + __param._M_d);
+
+	    bool __reject = true;
+	    do
+	      {
+		const double __u = __c * __aurng();
+		const double __e = -std::log(1.0 - __aurng());
+
+		double __w = 0.0;
+
+		if (__u <= __c1)
+		  {
+		    const double __n = _M_nd(__urng);
+		    const double __y = -std::abs(__n) * __param._M_sm - 1;
+		    __x = std::floor(__y);
+		    __w = -__n * __n / 2;
+		    if (__x < -__m)
+		      continue;
+		  }
+		else if (__u <= __c2)
+		  {
+		    const double __n = _M_nd(__urng);
+		    const double __y = 1 + std::abs(__n) * __param._M_scx;
+		    __x = std::ceil(__y);
+		    __w = __y * (2 - __y) * __param._M_1cx;
+		    if (__x > __param._M_d)
+		      continue;
+		  }
+		else if (__u <= __c3)
+		  // NB: This case not in the book, nor in the Errata,
+		  // but should be ok...
+		  __x = -1;
+		else if (__u <= __c4)
+		  __x = 0;
+		else if (__u <= __c5)
+		  __x = 1;
+		else
+		  {
+		    const double __v = -std::log(1.0 - __aurng());
+		    const double __y = __param._M_d
+				     + __v * __2cx / __param._M_d;
+		    __x = std::ceil(__y);
+		    __w = -__param._M_d * __param._M_1cx * (1 + __y / 2);
+		  }
+
+		__reject = (__w - __e - __x * __param._M_lm_thr
+			    > __param._M_lfm - std::lgamma(__x + __m + 1));
+
+		__reject |= __x + __m >= __thr;
+
+	      } while (__reject);
+
+	    return result_type(__x + __m + __naf);
+	  }
+	else
+#endif
+	  {
+	    _IntType     __x = 0;
+	    double __prod = 1.0;
+
+	    do
+	      {
+		__prod *= __aurng();
+		__x += 1;
+	      }
+	    while (__prod > __param._M_lm_thr);
+
+	    return __x - 1;
+	  }
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      poisson_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	// We could duplicate everything from operator()...
+	while (__f != __t)
+	  *__f++ = this->operator()(__urng, __param);
+      }
+
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const poisson_distribution<_IntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<double>::max_digits10);
+
+      __os << __x.mean() << __space << __x._M_nd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       poisson_distribution<_IntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      double __mean;
+      __is >> __mean >> __x._M_nd;
+      __x.param(typename poisson_distribution<_IntType>::param_type(__mean));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType>
+    void
+    binomial_distribution<_IntType>::param_type::
+    _M_initialize()
+    {
+      const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
+
+      _M_easy = true;
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+      if (_M_t * __p12 >= 8)
+	{
+	  _M_easy = false;
+	  const double __np = std::floor(_M_t * __p12);
+	  const double __pa = __np / _M_t;
+	  const double __1p = 1 - __pa;
+
+	  const double __pi_4 = 0.7853981633974483096156608458198757L;
+	  const double __d1x =
+	    std::sqrt(__np * __1p * std::log(32 * __np
+					     / (81 * __pi_4 * __1p)));
+	  _M_d1 = std::round(std::max(1.0, __d1x));
+	  const double __d2x =
+	    std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
+					     / (__pi_4 * __pa)));
+	  _M_d2 = std::round(std::max(1.0, __d2x));
+
+	  // sqrt(pi / 2)
+	  const double __spi_2 = 1.2533141373155002512078826424055226L;
+	  _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np));
+	  _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p));
+	  _M_c = 2 * _M_d1 / __np;
+	  _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2;
+	  const double __a12 = _M_a1 + _M_s2 * __spi_2;
+	  const double __s1s = _M_s1 * _M_s1;
+	  _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p))
+			     * 2 * __s1s / _M_d1
+			     * std::exp(-_M_d1 * _M_d1 / (2 * __s1s)));
+	  const double __s2s = _M_s2 * _M_s2;
+	  _M_s = (_M_a123 + 2 * __s2s / _M_d2
+		  * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
+	  _M_lf = (std::lgamma(__np + 1)
+		   + std::lgamma(_M_t - __np + 1));
+	  _M_lp1p = std::log(__pa / __1p);
+
+	  _M_q = -std::log(1 - (__p12 - __pa) / __1p);
+	}
+      else
+#endif
+	_M_q = -std::log(1 - __p12);
+    }
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename binomial_distribution<_IntType>::result_type
+      binomial_distribution<_IntType>::
+      _M_waiting(_UniformRandomNumberGenerator& __urng,
+		 _IntType __t, double __q)
+      {
+	_IntType __x = 0;
+	double __sum = 0.0;
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	do
+	  {
+	    if (__t == __x)
+	      return __x;
+	    const double __e = -std::log(1.0 - __aurng());
+	    __sum += __e / (__t - __x);
+	    __x += 1;
+	  }
+	while (__sum <= __q);
+
+	return __x - 1;
+      }
+
+  /**
+   * A rejection algorithm when t * p >= 8 and a simple waiting time
+   * method - the second in the referenced book - otherwise.
+   * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
+   * is defined.
+   *
+   * Reference:
+   * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+   * New York, 1986, Ch. X, Sect. 4 (+ Errata!).
+   */
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename binomial_distribution<_IntType>::result_type
+      binomial_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	result_type __ret;
+	const _IntType __t = __param.t();
+	const double __p = __param.p();
+	const double __p12 = __p <= 0.5 ? __p : 1.0 - __p;
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+	if (!__param._M_easy)
+	  {
+	    double __x;
+
+	    // See comments above...
+	    const double __naf =
+	      (1 - std::numeric_limits<double>::epsilon()) / 2;
+	    const double __thr =
+	      std::numeric_limits<_IntType>::max() + __naf;
+
+	    const double __np = std::floor(__t * __p12);
+
+	    // sqrt(pi / 2)
+	    const double __spi_2 = 1.2533141373155002512078826424055226L;
+	    const double __a1 = __param._M_a1;
+	    const double __a12 = __a1 + __param._M_s2 * __spi_2;
+	    const double __a123 = __param._M_a123;
+	    const double __s1s = __param._M_s1 * __param._M_s1;
+	    const double __s2s = __param._M_s2 * __param._M_s2;
+
+	    bool __reject;
+	    do
+	      {
+		const double __u = __param._M_s * __aurng();
+
+		double __v;
+
+		if (__u <= __a1)
+		  {
+		    const double __n = _M_nd(__urng);
+		    const double __y = __param._M_s1 * std::abs(__n);
+		    __reject = __y >= __param._M_d1;
+		    if (!__reject)
+		      {
+			const double __e = -std::log(1.0 - __aurng());
+			__x = std::floor(__y);
+			__v = -__e - __n * __n / 2 + __param._M_c;
+		      }
+		  }
+		else if (__u <= __a12)
+		  {
+		    const double __n = _M_nd(__urng);
+		    const double __y = __param._M_s2 * std::abs(__n);
+		    __reject = __y >= __param._M_d2;
+		    if (!__reject)
+		      {
+			const double __e = -std::log(1.0 - __aurng());
+			__x = std::floor(-__y);
+			__v = -__e - __n * __n / 2;
+		      }
+		  }
+		else if (__u <= __a123)
+		  {
+		    const double __e1 = -std::log(1.0 - __aurng());
+		    const double __e2 = -std::log(1.0 - __aurng());
+
+		    const double __y = __param._M_d1
+				     + 2 * __s1s * __e1 / __param._M_d1;
+		    __x = std::floor(__y);
+		    __v = (-__e2 + __param._M_d1 * (1 / (__t - __np)
+						    -__y / (2 * __s1s)));
+		    __reject = false;
+		  }
+		else
+		  {
+		    const double __e1 = -std::log(1.0 - __aurng());
+		    const double __e2 = -std::log(1.0 - __aurng());
+
+		    const double __y = __param._M_d2
+				     + 2 * __s2s * __e1 / __param._M_d2;
+		    __x = std::floor(-__y);
+		    __v = -__e2 - __param._M_d2 * __y / (2 * __s2s);
+		    __reject = false;
+		  }
+
+		__reject = __reject || __x < -__np || __x > __t - __np;
+		if (!__reject)
+		  {
+		    const double __lfx =
+		      std::lgamma(__np + __x + 1)
+		      + std::lgamma(__t - (__np + __x) + 1);
+		    __reject = __v > __param._M_lf - __lfx
+			     + __x * __param._M_lp1p;
+		  }
+
+		__reject |= __x + __np >= __thr;
+	      }
+	    while (__reject);
+
+	    __x += __np + __naf;
+
+	    const _IntType __z = _M_waiting(__urng, __t - _IntType(__x),
+					    __param._M_q);
+	    __ret = _IntType(__x) + __z;
+	  }
+	else
+#endif
+	  __ret = _M_waiting(__urng, __t, __param._M_q);
+
+	if (__p12 != __p)
+	  __ret = __t - __ret;
+	return __ret;
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      binomial_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	// We could duplicate everything from operator()...
+	while (__f != __t)
+	  *__f++ = this->operator()(__urng, __param);
+      }
+
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const binomial_distribution<_IntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<double>::max_digits10);
+
+      __os << __x.t() << __space << __x.p()
+	   << __space << __x._M_nd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _IntType,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       binomial_distribution<_IntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _IntType __t;
+      double __p;
+      __is >> __t >> __p >> __x._M_nd;
+      __x.param(typename binomial_distribution<_IntType>::
+		param_type(__t, __p));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      std::exponential_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+	while (__f != __t)
+	  *__f++ = -std::log(result_type(1) - __aurng()) / __p.lambda();
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const exponential_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.lambda();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       exponential_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __lambda;
+      __is >> __lambda;
+      __x.param(typename exponential_distribution<_RealType>::
+		param_type(__lambda));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  /**
+   * Polar method due to Marsaglia.
+   *
+   * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+   * New York, 1986, Ch. V, Sect. 4.4.
+   */
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename normal_distribution<_RealType>::result_type
+      normal_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	result_type __ret;
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	if (_M_saved_available)
+	  {
+	    _M_saved_available = false;
+	    __ret = _M_saved;
+	  }
+	else
+	  {
+	    result_type __x, __y, __r2;
+	    do
+	      {
+		__x = result_type(2.0) * __aurng() - 1.0;
+		__y = result_type(2.0) * __aurng() - 1.0;
+		__r2 = __x * __x + __y * __y;
+	      }
+	    while (__r2 > 1.0 || __r2 == 0.0);
+
+	    const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
+	    _M_saved = __x * __mult;
+	    _M_saved_available = true;
+	    __ret = __y * __mult;
+	  }
+
+	__ret = __ret * __param.stddev() + __param.mean();
+	return __ret;
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      normal_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+
+	if (__f == __t)
+	  return;
+
+	if (_M_saved_available)
+	  {
+	    _M_saved_available = false;
+	    *__f++ = _M_saved * __param.stddev() + __param.mean();
+
+	    if (__f == __t)
+	      return;
+	  }
+
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	while (__f + 1 < __t)
+	  {
+	    result_type __x, __y, __r2;
+	    do
+	      {
+		__x = result_type(2.0) * __aurng() - 1.0;
+		__y = result_type(2.0) * __aurng() - 1.0;
+		__r2 = __x * __x + __y * __y;
+	      }
+	    while (__r2 > 1.0 || __r2 == 0.0);
+
+	    const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
+	    *__f++ = __y * __mult * __param.stddev() + __param.mean();
+	    *__f++ = __x * __mult * __param.stddev() + __param.mean();
+	  }
+
+	if (__f != __t)
+	  {
+	    result_type __x, __y, __r2;
+	    do
+	      {
+		__x = result_type(2.0) * __aurng() - 1.0;
+		__y = result_type(2.0) * __aurng() - 1.0;
+		__r2 = __x * __x + __y * __y;
+	      }
+	    while (__r2 > 1.0 || __r2 == 0.0);
+
+	    const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
+	    _M_saved = __x * __mult;
+	    _M_saved_available = true;
+	    *__f = __y * __mult * __param.stddev() + __param.mean();
+	  }
+      }
+
+  template<typename _RealType>
+    bool
+    operator==(const std::normal_distribution<_RealType>& __d1,
+	       const std::normal_distribution<_RealType>& __d2)
+    {
+      if (__d1._M_param == __d2._M_param
+	  && __d1._M_saved_available == __d2._M_saved_available)
+	{
+	  if (__d1._M_saved_available
+	      && __d1._M_saved == __d2._M_saved)
+	    return true;
+	  else if(!__d1._M_saved_available)
+	    return true;
+	  else
+	    return false;
+	}
+      else
+	return false;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const normal_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.mean() << __space << __x.stddev()
+	   << __space << __x._M_saved_available;
+      if (__x._M_saved_available)
+	__os << __space << __x._M_saved;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       normal_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      double __mean, __stddev;
+      __is >> __mean >> __stddev
+	   >> __x._M_saved_available;
+      if (__x._M_saved_available)
+	__is >> __x._M_saved;
+      __x.param(typename normal_distribution<_RealType>::
+		param_type(__mean, __stddev));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      lognormal_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	  while (__f != __t)
+	    *__f++ = std::exp(__p.s() * _M_nd(__urng) + __p.m());
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const lognormal_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.m() << __space << __x.s()
+	   << __space << __x._M_nd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       lognormal_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __m, __s;
+      __is >> __m >> __s >> __x._M_nd;
+      __x.param(typename lognormal_distribution<_RealType>::
+		param_type(__m, __s));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      std::chi_squared_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	while (__f != __t)
+	  *__f++ = 2 * _M_gd(__urng);
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      std::chi_squared_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const typename
+		      std::gamma_distribution<result_type>::param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	while (__f != __t)
+	  *__f++ = 2 * _M_gd(__urng, __p);
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const chi_squared_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.n() << __space << __x._M_gd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       chi_squared_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __n;
+      __is >> __n >> __x._M_gd;
+      __x.param(typename chi_squared_distribution<_RealType>::
+		param_type(__n));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename cauchy_distribution<_RealType>::result_type
+      cauchy_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+	_RealType __u;
+	do
+	  __u = __aurng();
+	while (__u == 0.5);
+
+	const _RealType __pi = 3.1415926535897932384626433832795029L;
+	return __p.a() + __p.b() * std::tan(__pi * __u);
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      cauchy_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	const _RealType __pi = 3.1415926535897932384626433832795029L;
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+	while (__f != __t)
+	  {
+	    _RealType __u;
+	    do
+	      __u = __aurng();
+	    while (__u == 0.5);
+
+	    *__f++ = __p.a() + __p.b() * std::tan(__pi * __u);
+	  }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const cauchy_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.a() << __space << __x.b();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       cauchy_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b;
+      __is >> __a >> __b;
+      __x.param(typename cauchy_distribution<_RealType>::
+		param_type(__a, __b));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      std::fisher_f_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	while (__f != __t)
+	  *__f++ = ((_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()));
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      std::fisher_f_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	typedef typename std::gamma_distribution<result_type>::param_type
+	  param_type;
+	param_type __p1(__p.m() / 2);
+	param_type __p2(__p.n() / 2);
+	while (__f != __t)
+	  *__f++ = ((_M_gd_x(__urng, __p1) * n())
+		    / (_M_gd_y(__urng, __p2) * m()));
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const fisher_f_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.m() << __space << __x.n()
+	   << __space << __x._M_gd_x << __space << __x._M_gd_y;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       fisher_f_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __m, __n;
+      __is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y;
+      __x.param(typename fisher_f_distribution<_RealType>::
+		param_type(__m, __n));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      std::student_t_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	while (__f != __t)
+	  *__f++ = _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng));
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      std::student_t_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	typename std::gamma_distribution<result_type>::param_type
+	  __p2(__p.n() / 2, 2);
+	while (__f != __t)
+	  *__f++ =  _M_nd(__urng) * std::sqrt(__p.n() / _M_gd(__urng, __p2));
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const student_t_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.n() << __space << __x._M_nd << __space << __x._M_gd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       student_t_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __n;
+      __is >> __n >> __x._M_nd >> __x._M_gd;
+      __x.param(typename student_t_distribution<_RealType>::param_type(__n));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    void
+    gamma_distribution<_RealType>::param_type::
+    _M_initialize()
+    {
+      _M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType(1.0) : _M_alpha;
+
+      const _RealType __a1 = _M_malpha - _RealType(1.0) / _RealType(3.0);
+      _M_a2 = _RealType(1.0) / std::sqrt(_RealType(9.0) * __a1);
+    }
+
+  /**
+   * Marsaglia, G. and Tsang, W. W.
+   * "A Simple Method for Generating Gamma Variables"
+   * ACM Transactions on Mathematical Software, 26, 3, 363-372, 2000.
+   */
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename gamma_distribution<_RealType>::result_type
+      gamma_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	result_type __u, __v, __n;
+	const result_type __a1 = (__param._M_malpha
+				  - _RealType(1.0) / _RealType(3.0));
+
+	do
+	  {
+	    do
+	      {
+		__n = _M_nd(__urng);
+		__v = result_type(1.0) + __param._M_a2 * __n; 
+	      }
+	    while (__v <= 0.0);
+
+	    __v = __v * __v * __v;
+	    __u = __aurng();
+	  }
+	while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n
+	       && (std::log(__u) > (0.5 * __n * __n + __a1
+				    * (1.0 - __v + std::log(__v)))));
+
+	if (__param.alpha() == __param._M_malpha)
+	  return __a1 * __v * __param.beta();
+	else
+	  {
+	    do
+	      __u = __aurng();
+	    while (__u == 0.0);
+	    
+	    return (std::pow(__u, result_type(1.0) / __param.alpha())
+		    * __a1 * __v * __param.beta());
+	  }
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      gamma_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	result_type __u, __v, __n;
+	const result_type __a1 = (__param._M_malpha
+				  - _RealType(1.0) / _RealType(3.0));
+
+	if (__param.alpha() == __param._M_malpha)
+	  while (__f != __t)
+	    {
+	      do
+		{
+		  do
+		    {
+		      __n = _M_nd(__urng);
+		      __v = result_type(1.0) + __param._M_a2 * __n;
+		    }
+		  while (__v <= 0.0);
+
+		  __v = __v * __v * __v;
+		  __u = __aurng();
+		}
+	      while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n
+		     && (std::log(__u) > (0.5 * __n * __n + __a1
+					  * (1.0 - __v + std::log(__v)))));
+
+	      *__f++ = __a1 * __v * __param.beta();
+	    }
+	else
+	  while (__f != __t)
+	    {
+	      do
+		{
+		  do
+		    {
+		      __n = _M_nd(__urng);
+		      __v = result_type(1.0) + __param._M_a2 * __n;
+		    }
+		  while (__v <= 0.0);
+
+		  __v = __v * __v * __v;
+		  __u = __aurng();
+		}
+	      while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n
+		     && (std::log(__u) > (0.5 * __n * __n + __a1
+					  * (1.0 - __v + std::log(__v)))));
+
+	      do
+		__u = __aurng();
+	      while (__u == 0.0);
+
+	      *__f++ = (std::pow(__u, result_type(1.0) / __param.alpha())
+			* __a1 * __v * __param.beta());
+	    }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const gamma_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.alpha() << __space << __x.beta()
+	   << __space << __x._M_nd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       gamma_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __alpha_val, __beta_val;
+      __is >> __alpha_val >> __beta_val >> __x._M_nd;
+      __x.param(typename gamma_distribution<_RealType>::
+		param_type(__alpha_val, __beta_val));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename weibull_distribution<_RealType>::result_type
+      weibull_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+	return __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
+				  result_type(1) / __p.a());
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      weibull_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+	auto __inv_a = result_type(1) / __p.a();
+
+	while (__f != __t)
+	  *__f++ = __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
+				      __inv_a);
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const weibull_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.a() << __space << __x.b();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       weibull_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b;
+      __is >> __a >> __b;
+      __x.param(typename weibull_distribution<_RealType>::
+		param_type(__a, __b));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename extreme_value_distribution<_RealType>::result_type
+      extreme_value_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+	return __p.a() - __p.b() * std::log(-std::log(result_type(1)
+						      - __aurng()));
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      extreme_value_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	while (__f != __t)
+	  *__f++ = __p.a() - __p.b() * std::log(-std::log(result_type(1)
+							  - __aurng()));
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const extreme_value_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.a() << __space << __x.b();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       extreme_value_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b;
+      __is >> __a >> __b;
+      __x.param(typename extreme_value_distribution<_RealType>::
+		param_type(__a, __b));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType>
+    void
+    discrete_distribution<_IntType>::param_type::
+    _M_initialize()
+    {
+      if (_M_prob.size() < 2)
+	{
+	  _M_prob.clear();
+	  return;
+	}
+
+      const double __sum = std::accumulate(_M_prob.begin(),
+					   _M_prob.end(), 0.0);
+      // Now normalize the probabilites.
+      __detail::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(),
+			    __sum);
+      // Accumulate partial sums.
+      _M_cp.reserve(_M_prob.size());
+      std::partial_sum(_M_prob.begin(), _M_prob.end(),
+		       std::back_inserter(_M_cp));
+      // Make sure the last cumulative probability is one.
+      _M_cp[_M_cp.size() - 1] = 1.0;
+    }
+
+  template<typename _IntType>
+    template<typename _Func>
+      discrete_distribution<_IntType>::param_type::
+      param_type(size_t __nw, double __xmin, double __xmax, _Func __fw)
+      : _M_prob(), _M_cp()
+      {
+	const size_t __n = __nw == 0 ? 1 : __nw;
+	const double __delta = (__xmax - __xmin) / __n;
+
+	_M_prob.reserve(__n);
+	for (size_t __k = 0; __k < __nw; ++__k)
+	  _M_prob.push_back(__fw(__xmin + __k * __delta + 0.5 * __delta));
+
+	_M_initialize();
+      }
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename discrete_distribution<_IntType>::result_type
+      discrete_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	if (__param._M_cp.empty())
+	  return result_type(0);
+
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	const double __p = __aurng();
+	auto __pos = std::lower_bound(__param._M_cp.begin(),
+				      __param._M_cp.end(), __p);
+
+	return __pos - __param._M_cp.begin();
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      discrete_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+
+	if (__param._M_cp.empty())
+	  {
+	    while (__f != __t)
+	      *__f++ = result_type(0);
+	    return;
+	  }
+
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	while (__f != __t)
+	  {
+	    const double __p = __aurng();
+	    auto __pos = std::lower_bound(__param._M_cp.begin(),
+					  __param._M_cp.end(), __p);
+
+	    *__f++ = __pos - __param._M_cp.begin();
+	  }
+      }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const discrete_distribution<_IntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<double>::max_digits10);
+
+      std::vector<double> __prob = __x.probabilities();
+      __os << __prob.size();
+      for (auto __dit = __prob.begin(); __dit != __prob.end(); ++__dit)
+	__os << __space << *__dit;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       discrete_distribution<_IntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      size_t __n;
+      __is >> __n;
+
+      std::vector<double> __prob_vec;
+      __prob_vec.reserve(__n);
+      for (; __n != 0; --__n)
+	{
+	  double __prob;
+	  __is >> __prob;
+	  __prob_vec.push_back(__prob);
+	}
+
+      __x.param(typename discrete_distribution<_IntType>::
+		param_type(__prob_vec.begin(), __prob_vec.end()));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    void
+    piecewise_constant_distribution<_RealType>::param_type::
+    _M_initialize()
+    {
+      if (_M_int.size() < 2
+	  || (_M_int.size() == 2
+	      && _M_int[0] == _RealType(0)
+	      && _M_int[1] == _RealType(1)))
+	{
+	  _M_int.clear();
+	  _M_den.clear();
+	  return;
+	}
+
+      const double __sum = std::accumulate(_M_den.begin(),
+					   _M_den.end(), 0.0);
+
+      __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
+			    __sum);
+
+      _M_cp.reserve(_M_den.size());
+      std::partial_sum(_M_den.begin(), _M_den.end(),
+		       std::back_inserter(_M_cp));
+
+      // Make sure the last cumulative probability is one.
+      _M_cp[_M_cp.size() - 1] = 1.0;
+
+      for (size_t __k = 0; __k < _M_den.size(); ++__k)
+	_M_den[__k] /= _M_int[__k + 1] - _M_int[__k];
+    }
+
+  template<typename _RealType>
+    template<typename _InputIteratorB, typename _InputIteratorW>
+      piecewise_constant_distribution<_RealType>::param_type::
+      param_type(_InputIteratorB __bbegin,
+		 _InputIteratorB __bend,
+		 _InputIteratorW __wbegin)
+      : _M_int(), _M_den(), _M_cp()
+      {
+	if (__bbegin != __bend)
+	  {
+	    for (;;)
+	      {
+		_M_int.push_back(*__bbegin);
+		++__bbegin;
+		if (__bbegin == __bend)
+		  break;
+
+		_M_den.push_back(*__wbegin);
+		++__wbegin;
+	      }
+	  }
+
+	_M_initialize();
+      }
+
+  template<typename _RealType>
+    template<typename _Func>
+      piecewise_constant_distribution<_RealType>::param_type::
+      param_type(initializer_list<_RealType> __bl, _Func __fw)
+      : _M_int(), _M_den(), _M_cp()
+      {
+	_M_int.reserve(__bl.size());
+	for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
+	  _M_int.push_back(*__biter);
+
+	_M_den.reserve(_M_int.size() - 1);
+	for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
+	  _M_den.push_back(__fw(0.5 * (_M_int[__k + 1] + _M_int[__k])));
+
+	_M_initialize();
+      }
+
+  template<typename _RealType>
+    template<typename _Func>
+      piecewise_constant_distribution<_RealType>::param_type::
+      param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
+      : _M_int(), _M_den(), _M_cp()
+      {
+	const size_t __n = __nw == 0 ? 1 : __nw;
+	const _RealType __delta = (__xmax - __xmin) / __n;
+
+	_M_int.reserve(__n + 1);
+	for (size_t __k = 0; __k <= __nw; ++__k)
+	  _M_int.push_back(__xmin + __k * __delta);
+
+	_M_den.reserve(__n);
+	for (size_t __k = 0; __k < __nw; ++__k)
+	  _M_den.push_back(__fw(_M_int[__k] + 0.5 * __delta));
+
+	_M_initialize();
+      }
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename piecewise_constant_distribution<_RealType>::result_type
+      piecewise_constant_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	const double __p = __aurng();
+	if (__param._M_cp.empty())
+	  return __p;
+
+	auto __pos = std::lower_bound(__param._M_cp.begin(),
+				      __param._M_cp.end(), __p);
+	const size_t __i = __pos - __param._M_cp.begin();
+
+	const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
+
+	return __param._M_int[__i] + (__p - __pref) / __param._M_den[__i];
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      piecewise_constant_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	if (__param._M_cp.empty())
+	  {
+	    while (__f != __t)
+	      *__f++ = __aurng();
+	    return;
+	  }
+
+	while (__f != __t)
+	  {
+	    const double __p = __aurng();
+
+	    auto __pos = std::lower_bound(__param._M_cp.begin(),
+					  __param._M_cp.end(), __p);
+	    const size_t __i = __pos - __param._M_cp.begin();
+
+	    const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
+
+	    *__f++ = (__param._M_int[__i]
+		      + (__p - __pref) / __param._M_den[__i]);
+	  }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const piecewise_constant_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      std::vector<_RealType> __int = __x.intervals();
+      __os << __int.size() - 1;
+
+      for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
+	__os << __space << *__xit;
+
+      std::vector<double> __den = __x.densities();
+      for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
+	__os << __space << *__dit;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       piecewise_constant_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      size_t __n;
+      __is >> __n;
+
+      std::vector<_RealType> __int_vec;
+      __int_vec.reserve(__n + 1);
+      for (size_t __i = 0; __i <= __n; ++__i)
+	{
+	  _RealType __int;
+	  __is >> __int;
+	  __int_vec.push_back(__int);
+	}
+
+      std::vector<double> __den_vec;
+      __den_vec.reserve(__n);
+      for (size_t __i = 0; __i < __n; ++__i)
+	{
+	  double __den;
+	  __is >> __den;
+	  __den_vec.push_back(__den);
+	}
+
+      __x.param(typename piecewise_constant_distribution<_RealType>::
+	  param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin()));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    void
+    piecewise_linear_distribution<_RealType>::param_type::
+    _M_initialize()
+    {
+      if (_M_int.size() < 2
+	  || (_M_int.size() == 2
+	      && _M_int[0] == _RealType(0)
+	      && _M_int[1] == _RealType(1)
+	      && _M_den[0] == _M_den[1]))
+	{
+	  _M_int.clear();
+	  _M_den.clear();
+	  return;
+	}
+
+      double __sum = 0.0;
+      _M_cp.reserve(_M_int.size() - 1);
+      _M_m.reserve(_M_int.size() - 1);
+      for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
+	{
+	  const _RealType __delta = _M_int[__k + 1] - _M_int[__k];
+	  __sum += 0.5 * (_M_den[__k + 1] + _M_den[__k]) * __delta;
+	  _M_cp.push_back(__sum);
+	  _M_m.push_back((_M_den[__k + 1] - _M_den[__k]) / __delta);
+	}
+
+      //  Now normalize the densities...
+      __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
+			    __sum);
+      //  ... and partial sums... 
+      __detail::__normalize(_M_cp.begin(), _M_cp.end(), _M_cp.begin(), __sum);
+      //  ... and slopes.
+      __detail::__normalize(_M_m.begin(), _M_m.end(), _M_m.begin(), __sum);
+
+      //  Make sure the last cumulative probablility is one.
+      _M_cp[_M_cp.size() - 1] = 1.0;
+     }
+
+  template<typename _RealType>
+    template<typename _InputIteratorB, typename _InputIteratorW>
+      piecewise_linear_distribution<_RealType>::param_type::
+      param_type(_InputIteratorB __bbegin,
+		 _InputIteratorB __bend,
+		 _InputIteratorW __wbegin)
+      : _M_int(), _M_den(), _M_cp(), _M_m()
+      {
+	for (; __bbegin != __bend; ++__bbegin, ++__wbegin)
+	  {
+	    _M_int.push_back(*__bbegin);
+	    _M_den.push_back(*__wbegin);
+	  }
+
+	_M_initialize();
+      }
+
+  template<typename _RealType>
+    template<typename _Func>
+      piecewise_linear_distribution<_RealType>::param_type::
+      param_type(initializer_list<_RealType> __bl, _Func __fw)
+      : _M_int(), _M_den(), _M_cp(), _M_m()
+      {
+	_M_int.reserve(__bl.size());
+	_M_den.reserve(__bl.size());
+	for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
+	  {
+	    _M_int.push_back(*__biter);
+	    _M_den.push_back(__fw(*__biter));
+	  }
+
+	_M_initialize();
+      }
+
+  template<typename _RealType>
+    template<typename _Func>
+      piecewise_linear_distribution<_RealType>::param_type::
+      param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
+      : _M_int(), _M_den(), _M_cp(), _M_m()
+      {
+	const size_t __n = __nw == 0 ? 1 : __nw;
+	const _RealType __delta = (__xmax - __xmin) / __n;
+
+	_M_int.reserve(__n + 1);
+	_M_den.reserve(__n + 1);
+	for (size_t __k = 0; __k <= __nw; ++__k)
+	  {
+	    _M_int.push_back(__xmin + __k * __delta);
+	    _M_den.push_back(__fw(_M_int[__k] + __delta));
+	  }
+
+	_M_initialize();
+      }
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename piecewise_linear_distribution<_RealType>::result_type
+      piecewise_linear_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
+	  __aurng(__urng);
+
+	const double __p = __aurng();
+	if (__param._M_cp.empty())
+	  return __p;
+
+	auto __pos = std::lower_bound(__param._M_cp.begin(),
+				      __param._M_cp.end(), __p);
+	const size_t __i = __pos - __param._M_cp.begin();
+
+	const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
+
+	const double __a = 0.5 * __param._M_m[__i];
+	const double __b = __param._M_den[__i];
+	const double __cm = __p - __pref;
+
+	_RealType __x = __param._M_int[__i];
+	if (__a == 0)
+	  __x += __cm / __b;
+	else
+	  {
+	    const double __d = __b * __b + 4.0 * __a * __cm;
+	    __x += 0.5 * (std::sqrt(__d) - __b) / __a;
+          }
+
+        return __x;
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      piecewise_linear_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+	// We could duplicate everything from operator()...
+	while (__f != __t)
+	  *__f++ = this->operator()(__urng, __param);
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const piecewise_linear_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      std::vector<_RealType> __int = __x.intervals();
+      __os << __int.size() - 1;
+
+      for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
+	__os << __space << *__xit;
+
+      std::vector<double> __den = __x.densities();
+      for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
+	__os << __space << *__dit;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       piecewise_linear_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      size_t __n;
+      __is >> __n;
+
+      std::vector<_RealType> __int_vec;
+      __int_vec.reserve(__n + 1);
+      for (size_t __i = 0; __i <= __n; ++__i)
+	{
+	  _RealType __int;
+	  __is >> __int;
+	  __int_vec.push_back(__int);
+	}
+
+      std::vector<double> __den_vec;
+      __den_vec.reserve(__n + 1);
+      for (size_t __i = 0; __i <= __n; ++__i)
+	{
+	  double __den;
+	  __is >> __den;
+	  __den_vec.push_back(__den);
+	}
+
+      __x.param(typename piecewise_linear_distribution<_RealType>::
+	  param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin()));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType>
+    seed_seq::seed_seq(std::initializer_list<_IntType> __il)
+    {
+      for (auto __iter = __il.begin(); __iter != __il.end(); ++__iter)
+	_M_v.push_back(__detail::__mod<result_type,
+		       __detail::_Shift<result_type, 32>::__value>(*__iter));
+    }
+
+  template<typename _InputIterator>
+    seed_seq::seed_seq(_InputIterator __begin, _InputIterator __end)
+    {
+      for (_InputIterator __iter = __begin; __iter != __end; ++__iter)
+	_M_v.push_back(__detail::__mod<result_type,
+		       __detail::_Shift<result_type, 32>::__value>(*__iter));
+    }
+
+  template<typename _RandomAccessIterator>
+    void
+    seed_seq::generate(_RandomAccessIterator __begin,
+		       _RandomAccessIterator __end)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+        _Type;
+
+      if (__begin == __end)
+	return;
+
+      std::fill(__begin, __end, _Type(0x8b8b8b8bu));
+
+      const size_t __n = __end - __begin;
+      const size_t __s = _M_v.size();
+      const size_t __t = (__n >= 623) ? 11
+		       : (__n >=  68) ? 7
+		       : (__n >=  39) ? 5
+		       : (__n >=   7) ? 3
+		       : (__n - 1) / 2;
+      const size_t __p = (__n - __t) / 2;
+      const size_t __q = __p + __t;
+      const size_t __m = std::max(size_t(__s + 1), __n);
+
+      for (size_t __k = 0; __k < __m; ++__k)
+	{
+	  _Type __arg = (__begin[__k % __n]
+			 ^ __begin[(__k + __p) % __n]
+			 ^ __begin[(__k - 1) % __n]);
+	  _Type __r1 = __arg ^ (__arg >> 27);
+	  __r1 = __detail::__mod<_Type,
+		    __detail::_Shift<_Type, 32>::__value>(1664525u * __r1);
+	  _Type __r2 = __r1;
+	  if (__k == 0)
+	    __r2 += __s;
+	  else if (__k <= __s)
+	    __r2 += __k % __n + _M_v[__k - 1];
+	  else
+	    __r2 += __k % __n;
+	  __r2 = __detail::__mod<_Type,
+	           __detail::_Shift<_Type, 32>::__value>(__r2);
+	  __begin[(__k + __p) % __n] += __r1;
+	  __begin[(__k + __q) % __n] += __r2;
+	  __begin[__k % __n] = __r2;
+	}
+
+      for (size_t __k = __m; __k < __m + __n; ++__k)
+	{
+	  _Type __arg = (__begin[__k % __n]
+			 + __begin[(__k + __p) % __n]
+			 + __begin[(__k - 1) % __n]);
+	  _Type __r3 = __arg ^ (__arg >> 27);
+	  __r3 = __detail::__mod<_Type,
+		   __detail::_Shift<_Type, 32>::__value>(1566083941u * __r3);
+	  _Type __r4 = __r3 - __k % __n;
+	  __r4 = __detail::__mod<_Type,
+	           __detail::_Shift<_Type, 32>::__value>(__r4);
+	  __begin[(__k + __p) % __n] ^= __r3;
+	  __begin[(__k + __q) % __n] ^= __r4;
+	  __begin[__k % __n] = __r4;
+	}
+    }
+
+  template<typename _RealType, size_t __bits,
+	   typename _UniformRandomNumberGenerator>
+    _RealType
+    generate_canonical(_UniformRandomNumberGenerator& __urng)
+    {
+      const size_t __b
+	= std::min(static_cast<size_t>(std::numeric_limits<_RealType>::digits),
+                   __bits);
+      const long double __r = static_cast<long double>(__urng.max())
+			    - static_cast<long double>(__urng.min()) + 1.0L;
+      const size_t __log2r = std::log(__r) / std::log(2.0L);
+      size_t __k = std::max<size_t>(1UL, (__b + __log2r - 1UL) / __log2r);
+      _RealType __sum = _RealType(0);
+      _RealType __tmp = _RealType(1);
+      for (; __k != 0; --__k)
+	{
+	  __sum += _RealType(__urng() - __urng.min()) * __tmp;
+	  __tmp *= __r;
+	}
+      return __sum / __tmp;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/range_access.h b/gcc-4.9/libstdc++-v3/include/bits/range_access.h
new file mode 100644
index 0000000..b70f997
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/range_access.h
@@ -0,0 +1,105 @@
+// <range_access.h> -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/range_access.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ */
+
+#ifndef _GLIBCXX_RANGE_ACCESS_H
+#define _GLIBCXX_RANGE_ACCESS_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus >= 201103L
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Return an iterator pointing to the first element of
+   *          the container.
+   *  @param  __cont  Container.
+   */
+  template<class _Container>
+    inline auto
+    begin(_Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+  /**
+   *  @brief  Return an iterator pointing to the first element of
+   *          the const container.
+   *  @param  __cont  Container.
+   */
+  template<class _Container>
+    inline auto
+    begin(const _Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+  /**
+   *  @brief  Return an iterator pointing to one past the last element of
+   *          the container.
+   *  @param  __cont  Container.
+   */
+  template<class _Container>
+    inline auto
+    end(_Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+
+  /**
+   *  @brief  Return an iterator pointing to one past the last element of
+   *          the const container.
+   *  @param  __cont  Container.
+   */
+  template<class _Container>
+    inline auto
+    end(const _Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+
+  /**
+   *  @brief  Return an iterator pointing to the first element of the array.
+   *  @param  __arr  Array.
+   */
+  template<class _Tp, size_t _Nm>
+    inline _Tp*
+    begin(_Tp (&__arr)[_Nm])
+    { return __arr; }
+
+  /**
+   *  @brief  Return an iterator pointing to one past the last element
+   *          of the array.
+   *  @param  __arr  Array.
+   */
+  template<class _Tp, size_t _Nm>
+    inline _Tp*
+    end(_Tp (&__arr)[_Nm])
+    { return __arr + _Nm; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // C++11
+
+#endif // _GLIBCXX_RANGE_ACCESS_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex.h b/gcc-4.9/libstdc++-v3/include/bits/regex.h
new file mode 100644
index 0000000..e556350
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex.h
@@ -0,0 +1,2721 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+  template<typename, typename>
+    class basic_regex;
+
+  template<typename, typename>
+    class match_results;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  enum class _RegexExecutorPolicy : int
+    { _S_auto, _S_alternate };
+
+  template<typename _BiIter, typename _Alloc,
+	   typename _CharT, typename _TraitsT,
+	   _RegexExecutorPolicy __policy,
+	   bool __match_mode>
+    bool
+    __regex_algo_impl(_BiIter                              __s,
+		      _BiIter                              __e,
+		      match_results<_BiIter, _Alloc>&      __m,
+		      const basic_regex<_CharT, _TraitsT>& __re,
+		      regex_constants::match_flag_type     __flags);
+
+  template<typename, typename, typename, bool>
+    class _Executor;
+
+  template<typename _TraitsT>
+    inline std::shared_ptr<_NFA<_TraitsT>>
+    __compile_nfa(const typename _TraitsT::char_type* __first,
+		  const typename _TraitsT::char_type* __last,
+		  const _TraitsT& __traits,
+		  regex_constants::syntax_option_type __flags);
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup regex
+   * @{
+   */
+
+  /**
+   * @brief Describes aspects of a regular expression.
+   *
+   * A regular expression traits class that satisfies the requirements of
+   * section [28.7].
+   *
+   * The class %regex is parameterized around a set of related types and
+   * functions used to complete the definition of its semantics.  This class
+   * satisfies the requirements of such a traits class.
+   */
+  template<typename _Ch_type>
+    struct regex_traits
+    {
+    public:
+      typedef _Ch_type                     	char_type;
+      typedef std::basic_string<char_type> 	string_type;
+      typedef std::locale                  	locale_type;
+    private:
+      struct _RegexMask
+	{
+	  typedef typename std::ctype<char_type>::mask _BaseType;
+	  _BaseType _M_base;
+	  unsigned char _M_extended;
+	  static constexpr unsigned char _S_under = 1 << 0;
+	  // FIXME: _S_blank should be removed in the future,
+	  // when locale's complete.
+	  static constexpr unsigned char _S_blank = 1 << 1;
+	  static constexpr unsigned char _S_valid_mask = 0x3;
+
+	  constexpr _RegexMask(_BaseType __base = 0,
+			       unsigned char __extended = 0)
+	  : _M_base(__base), _M_extended(__extended)
+	  { }
+
+	  constexpr _RegexMask
+	  operator&(_RegexMask __other) const
+	  {
+	    return _RegexMask(_M_base & __other._M_base,
+			      _M_extended & __other._M_extended);
+	  }
+
+	  constexpr _RegexMask
+	  operator|(_RegexMask __other) const
+	  {
+	    return _RegexMask(_M_base | __other._M_base,
+			      _M_extended | __other._M_extended);
+	  }
+
+	  constexpr _RegexMask
+	  operator^(_RegexMask __other) const
+	  {
+	    return _RegexMask(_M_base ^ __other._M_base,
+			      _M_extended ^ __other._M_extended);
+	  }
+
+	  constexpr _RegexMask
+	  operator~() const
+	  { return _RegexMask(~_M_base, ~_M_extended); }
+
+	  _RegexMask&
+	  operator&=(_RegexMask __other)
+	  { return *this = (*this) & __other; }
+
+	  _RegexMask&
+	  operator|=(_RegexMask __other)
+	  { return *this = (*this) | __other; }
+
+	  _RegexMask&
+	  operator^=(_RegexMask __other)
+	  { return *this = (*this) ^ __other; }
+
+	  constexpr bool
+	  operator==(_RegexMask __other) const
+	  {
+	    return (_M_extended & _S_valid_mask)
+		   == (__other._M_extended & _S_valid_mask)
+		     && _M_base == __other._M_base;
+	  }
+
+	  constexpr bool
+	  operator!=(_RegexMask __other) const
+	  { return !((*this) == __other); }
+
+	};
+    public:
+      typedef _RegexMask char_class_type;
+
+    public:
+      /**
+       * @brief Constructs a default traits object.
+       */
+      regex_traits() { }
+
+      /**
+       * @brief Gives the length of a C-style string starting at @p __p.
+       *
+       * @param __p a pointer to the start of a character sequence.
+       *
+       * @returns the number of characters between @p *__p and the first
+       * default-initialized value of type @p char_type.  In other words, uses
+       * the C-string algorithm for determining the length of a sequence of
+       * characters.
+       */
+      static std::size_t
+      length(const char_type* __p)
+      { return string_type::traits_type::length(__p); }
+
+      /**
+       * @brief Performs the identity translation.
+       *
+       * @param __c A character to the locale-specific character set.
+       *
+       * @returns __c.
+       */
+      char_type
+      translate(char_type __c) const
+      { return __c; }
+
+      /**
+       * @brief Translates a character into a case-insensitive equivalent.
+       *
+       * @param __c A character to the locale-specific character set.
+       *
+       * @returns the locale-specific lower-case equivalent of __c.
+       * @throws std::bad_cast if the imbued locale does not support the ctype
+       *         facet.
+       */
+      char_type
+      translate_nocase(char_type __c) const
+      {
+	typedef std::ctype<char_type> __ctype_type;
+	const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
+	return __fctyp.tolower(__c);
+      }
+
+      /**
+       * @brief Gets a sort key for a character sequence.
+       *
+       * @param __first beginning of the character sequence.
+       * @param __last  one-past-the-end of the character sequence.
+       *
+       * Returns a sort key for the character sequence designated by the
+       * iterator range [F1, F2) such that if the character sequence [G1, G2)
+       * sorts before the character sequence [H1, H2) then
+       * v.transform(G1, G2) < v.transform(H1, H2).
+       *
+       * What this really does is provide a more efficient way to compare a
+       * string to multiple other strings in locales with fancy collation
+       * rules and equivalence classes.
+       *
+       * @returns a locale-specific sort key equivalent to the input range.
+       *
+       * @throws std::bad_cast if the current locale does not have a collate
+       *         facet.
+       */
+      template<typename _Fwd_iter>
+	string_type
+	transform(_Fwd_iter __first, _Fwd_iter __last) const
+	{
+	  typedef std::collate<char_type> __collate_type;
+	  const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
+	  string_type __s(__first, __last);
+	  return __fclt.transform(__s.data(), __s.data() + __s.size());
+	}
+
+      /**
+       * @brief Gets a sort key for a character sequence, independent of case.
+       *
+       * @param __first beginning of the character sequence.
+       * @param __last  one-past-the-end of the character sequence.
+       *
+       * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
+       * typeid(collate_byname<_Ch_type>) and the form of the sort key
+       * returned by collate_byname<_Ch_type>::transform(__first, __last)
+       * is known and can be converted into a primary sort key
+       * then returns that key, otherwise returns an empty string.
+       *
+       * @todo Implement this function correctly.
+       */
+      template<typename _Fwd_iter>
+	string_type
+	transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
+	{
+	  // TODO : this is not entirely correct.
+	  // This function requires extra support from the platform.
+	  //
+	  // Read http://gcc.gnu.org/ml/libstdc++/2013-09/msg00117.html and
+	  // http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2003/n1429.htm
+	  // for details.
+	  typedef std::ctype<char_type> __ctype_type;
+	  const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
+	  std::vector<char_type> __s(__first, __last);
+	  __fctyp.tolower(__s.data(), __s.data() + __s.size());
+	  return this->transform(__s.data(), __s.data() + __s.size());
+	}
+
+      /**
+       * @brief Gets a collation element by name.
+       *
+       * @param __first beginning of the collation element name.
+       * @param __last  one-past-the-end of the collation element name.
+       *
+       * @returns a sequence of one or more characters that represents the
+       * collating element consisting of the character sequence designated by
+       * the iterator range [__first, __last). Returns an empty string if the
+       * character sequence is not a valid collating element.
+       */
+      template<typename _Fwd_iter>
+	string_type
+	lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
+
+      /**
+       * @brief Maps one or more characters to a named character
+       *        classification.
+       *
+       * @param __first beginning of the character sequence.
+       * @param __last  one-past-the-end of the character sequence.
+       * @param __icase ignores the case of the classification name.
+       *
+       * @returns an unspecified value that represents the character
+       * classification named by the character sequence designated by
+       * the iterator range [__first, __last). If @p icase is true,
+       * the returned mask identifies the classification regardless of
+       * the case of the characters to be matched (for example,
+       * [[:lower:]] is the same as [[:alpha:]]), otherwise a
+       * case-dependent classification is returned.  The value
+       * returned shall be independent of the case of the characters
+       * in the character sequence. If the name is not recognized then
+       * returns a value that compares equal to 0.
+       *
+       * At least the following names (or their wide-character equivalent) are
+       * supported.
+       * - d
+       * - w
+       * - s
+       * - alnum
+       * - alpha
+       * - blank
+       * - cntrl
+       * - digit
+       * - graph
+       * - lower
+       * - print
+       * - punct
+       * - space
+       * - upper
+       * - xdigit
+       */
+      template<typename _Fwd_iter>
+	char_class_type
+	lookup_classname(_Fwd_iter __first, _Fwd_iter __last,
+			 bool __icase = false) const;
+
+      /**
+       * @brief Determines if @p c is a member of an identified class.
+       *
+       * @param __c a character.
+       * @param __f a class type (as returned from lookup_classname).
+       *
+       * @returns true if the character @p __c is a member of the classification
+       * represented by @p __f, false otherwise.
+       *
+       * @throws std::bad_cast if the current locale does not have a ctype
+       *         facet.
+       */
+      bool
+      isctype(_Ch_type __c, char_class_type __f) const;
+
+      /**
+       * @brief Converts a digit to an int.
+       *
+       * @param __ch    a character representing a digit.
+       * @param __radix the radix if the numeric conversion (limited to 8, 10,
+       *              or 16).
+       *
+       * @returns the value represented by the digit __ch in base radix if the
+       * character __ch is a valid digit in base radix; otherwise returns -1.
+       */
+      int
+      value(_Ch_type __ch, int __radix) const;
+
+      /**
+       * @brief Imbues the regex_traits object with a copy of a new locale.
+       *
+       * @param __loc A locale.
+       *
+       * @returns a copy of the previous locale in use by the regex_traits
+       *          object.
+       *
+       * @note Calling imbue with a different locale than the one currently in
+       *       use invalidates all cached data held by *this.
+       */
+      locale_type
+      imbue(locale_type __loc)
+      {
+	std::swap(_M_locale, __loc);
+	return __loc;
+      }
+
+      /**
+       * @brief Gets a copy of the current locale in use by the regex_traits
+       * object.
+       */
+      locale_type
+      getloc() const
+      { return _M_locale; }
+
+    protected:
+      locale_type _M_locale;
+    };
+
+  // [7.8] Class basic_regex
+  /**
+   * Objects of specializations of this class represent regular expressions
+   * constructed from sequences of character type @p _Ch_type.
+   *
+   * Storage for the regular expression is allocated and deallocated as
+   * necessary by the member functions of this class.
+   */
+  template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
+    class basic_regex
+    {
+    public:
+      static_assert(is_same<_Ch_type, typename _Rx_traits::char_type>::value,
+		    "regex traits class must have the same char_type");
+
+      // types:
+      typedef _Ch_type                            value_type;
+      typedef _Rx_traits                          traits_type;
+      typedef typename traits_type::string_type   string_type;
+      typedef regex_constants::syntax_option_type flag_type;
+      typedef typename traits_type::locale_type   locale_type;
+
+      /**
+       * @name Constants
+       * std [28.8.1](1)
+       */
+      //@{
+      static constexpr flag_type icase = regex_constants::icase;
+      static constexpr flag_type nosubs = regex_constants::nosubs;
+      static constexpr flag_type optimize = regex_constants::optimize;
+      static constexpr flag_type collate = regex_constants::collate;
+      static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
+      static constexpr flag_type basic = regex_constants::basic;
+      static constexpr flag_type extended = regex_constants::extended;
+      static constexpr flag_type awk = regex_constants::awk;
+      static constexpr flag_type grep = regex_constants::grep;
+      static constexpr flag_type egrep = regex_constants::egrep;
+      //@}
+
+      // [7.8.2] construct/copy/destroy
+      /**
+       * Constructs a basic regular expression that does not match any
+       * character sequence.
+       */
+      basic_regex()
+      : _M_flags(ECMAScript), _M_automaton(nullptr)
+      { }
+
+      /**
+       * @brief Constructs a basic regular expression from the
+       * sequence [__p, __p + char_traits<_Ch_type>::length(__p))
+       * interpreted according to the flags in @p __f.
+       *
+       * @param __p A pointer to the start of a C-style null-terminated string
+       *          containing a regular expression.
+       * @param __f Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p __p is not a valid regular expression.
+       */
+      explicit
+      basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript)
+      : basic_regex(__p, __p + _Rx_traits::length(__p), __f)
+      { }
+
+      /**
+       * @brief Constructs a basic regular expression from the sequence
+       * [p, p + len) interpreted according to the flags in @p f.
+       *
+       * @param __p   A pointer to the start of a string containing a regular
+       *              expression.
+       * @param __len The length of the string containing the regular
+       *              expression.
+       * @param __f   Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p __p is not a valid regular expression.
+       */
+      basic_regex(const _Ch_type* __p, std::size_t __len,
+		  flag_type __f = ECMAScript)
+      : basic_regex(__p, __p + __len, __f)
+      { }
+
+      /**
+       * @brief Copy-constructs a basic regular expression.
+       *
+       * @param __rhs A @p regex object.
+       */
+      basic_regex(const basic_regex& __rhs) = default;
+
+      /**
+       * @brief Move-constructs a basic regular expression.
+       *
+       * @param __rhs A @p regex object.
+       */
+      basic_regex(const basic_regex&& __rhs) noexcept
+      : _M_flags(__rhs._M_flags), _M_traits(__rhs._M_traits),
+	_M_automaton(std::move(__rhs._M_automaton))
+      { }
+
+      /**
+       * @brief Constructs a basic regular expression from the string
+       * @p s interpreted according to the flags in @p f.
+       *
+       * @param __s A string containing a regular expression.
+       * @param __f Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p __s is not a valid regular expression.
+       */
+      template<typename _Ch_traits, typename _Ch_alloc>
+	explicit
+	basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
+					    _Ch_alloc>& __s,
+		    flag_type __f = ECMAScript)
+	: basic_regex(__s.begin(), __s.end(), __f)
+	{ }
+
+      /**
+       * @brief Constructs a basic regular expression from the range
+       * [first, last) interpreted according to the flags in @p f.
+       *
+       * @param __first The start of a range containing a valid regular
+       *                expression.
+       * @param __last  The end of a range containing a valid regular
+       *                expression.
+       * @param __f     The format flags of the regular expression.
+       *
+       * @throws regex_error if @p [__first, __last) is not a valid regular
+       *         expression.
+       */
+      template<typename _FwdIter>
+	basic_regex(_FwdIter __first, _FwdIter __last,
+		    flag_type __f = ECMAScript)
+	: _M_flags(__f),
+	  _M_original_str(__first, __last),
+	  _M_automaton(__detail::__compile_nfa(_M_original_str.c_str(),
+					       _M_original_str.c_str()
+						 + _M_original_str.size(),
+					       _M_traits,
+					       _M_flags))
+	{ }
+
+      /**
+       * @brief Constructs a basic regular expression from an initializer list.
+       *
+       * @param __l  The initializer list.
+       * @param __f  The format flags of the regular expression.
+       *
+       * @throws regex_error if @p __l is not a valid regular expression.
+       */
+      basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript)
+      : basic_regex(__l.begin(), __l.end(), __f)
+      { }
+
+      /**
+       * @brief Destroys a basic regular expression.
+       */
+      ~basic_regex()
+      { }
+
+      /**
+       * @brief Assigns one regular expression to another.
+       */
+      basic_regex&
+      operator=(const basic_regex& __rhs)
+      { return this->assign(__rhs); }
+
+      /**
+       * @brief Move-assigns one regular expression to another.
+       */
+      basic_regex&
+      operator=(basic_regex&& __rhs) noexcept
+      { return this->assign(std::move(__rhs)); }
+
+      /**
+       * @brief Replaces a regular expression with a new one constructed from
+       * a C-style null-terminated string.
+       *
+       * @param __p A pointer to the start of a null-terminated C-style string
+       *        containing a regular expression.
+       */
+      basic_regex&
+      operator=(const _Ch_type* __p)
+      { return this->assign(__p, flags()); }
+
+      /**
+       * @brief Replaces a regular expression with a new one constructed from
+       * a string.
+       *
+       * @param __s A pointer to a string containing a regular expression.
+       */
+      template<typename _Ch_typeraits, typename _Alloc>
+	basic_regex&
+	operator=(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s)
+	{ return this->assign(__s, flags()); }
+
+      // [7.8.3] assign
+      /**
+       * @brief the real assignment operator.
+       *
+       * @param __rhs Another regular expression object.
+       */
+      basic_regex&
+      assign(const basic_regex& __rhs)
+      {
+	basic_regex __tmp(__rhs);
+	this->swap(__tmp);
+	return *this;
+      }
+
+      /**
+       * @brief The move-assignment operator.
+       *
+       * @param __rhs Another regular expression object.
+       */
+      basic_regex&
+      assign(basic_regex&& __rhs) noexcept
+      {
+	basic_regex __tmp(std::move(__rhs));
+	this->swap(__tmp);
+	return *this;
+      }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object from a
+       * C-style null-terminated string containing a regular expression
+       * pattern.
+       *
+       * @param __p     A pointer to a C-style null-terminated string containing
+       *              a regular expression pattern.
+       * @param __flags Syntax option flags.
+       *
+       * @throws regex_error if __p does not contain a valid regular
+       * expression pattern interpreted according to @p __flags.  If
+       * regex_error is thrown, *this remains unchanged.
+       */
+      basic_regex&
+      assign(const _Ch_type* __p, flag_type __flags = ECMAScript)
+      { return this->assign(string_type(__p), __flags); }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object from a
+       * C-style string containing a regular expression pattern.
+       *
+       * @param __p     A pointer to a C-style string containing a
+       *                regular expression pattern.
+       * @param __len   The length of the regular expression pattern string.
+       * @param __flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular
+       * expression pattern interpreted according to @p __flags.  If
+       * regex_error is thrown, *this remains unchanged.
+       */
+      basic_regex&
+      assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
+      { return this->assign(string_type(__p, __len), __flags); }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object from a
+       * string containing a regular expression pattern.
+       *
+       * @param __s     A string containing a regular expression pattern.
+       * @param __flags Syntax option flags.
+       *
+       * @throws regex_error if __s does not contain a valid regular
+       * expression pattern interpreted according to @p __flags.  If
+       * regex_error is thrown, *this remains unchanged.
+       */
+      template<typename _Ch_typeraits, typename _Alloc>
+	basic_regex&
+	assign(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s,
+	       flag_type __flags = ECMAScript)
+	{
+	  _M_flags = __flags;
+	  _M_original_str.assign(__s.begin(), __s.end());
+	  auto __p = _M_original_str.c_str();
+	  _M_automaton = __detail::__compile_nfa(__p,
+						 __p + _M_original_str.size(),
+						 _M_traits, _M_flags);
+	  return *this;
+	}
+
+      /**
+       * @brief Assigns a new regular expression to a regex object.
+       *
+       * @param __first The start of a range containing a valid regular
+       *                expression.
+       * @param __last  The end of a range containing a valid regular
+       *                expression.
+       * @param __flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular
+       * expression pattern interpreted according to @p __flags.  If
+       * regex_error is thrown, the object remains unchanged.
+       */
+      template<typename _InputIterator>
+	basic_regex&
+	assign(_InputIterator __first, _InputIterator __last,
+	       flag_type __flags = ECMAScript)
+	{ return this->assign(string_type(__first, __last), __flags); }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object.
+       *
+       * @param __l     An initializer list representing a regular expression.
+       * @param __flags Syntax option flags.
+       *
+       * @throws regex_error if @p __l does not contain a valid
+       * regular expression pattern interpreted according to @p
+       * __flags.  If regex_error is thrown, the object remains
+       * unchanged.
+       */
+      basic_regex&
+      assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript)
+      { return this->assign(__l.begin(), __l.end(), __flags); }
+
+      // [7.8.4] const operations
+      /**
+       * @brief Gets the number of marked subexpressions within the regular
+       * expression.
+       */
+      unsigned int
+      mark_count() const
+      { return _M_automaton->_M_sub_count() - 1; }
+
+      /**
+       * @brief Gets the flags used to construct the regular expression
+       * or in the last call to assign().
+       */
+      flag_type
+      flags() const
+      { return _M_flags; }
+
+      // [7.8.5] locale
+      /**
+       * @brief Imbues the regular expression object with the given locale.
+       *
+       * @param __loc A locale.
+       */
+      locale_type
+      imbue(locale_type __loc)
+      {
+	auto __ret = _M_traits.imbue(__loc);
+	this->assign(_M_original_str, _M_flags);
+	return __ret;
+      }
+
+      /**
+       * @brief Gets the locale currently imbued in the regular expression
+       *        object.
+       */
+      locale_type
+      getloc() const
+      { return _M_traits.getloc(); }
+
+      // [7.8.6] swap
+      /**
+       * @brief Swaps the contents of two regular expression objects.
+       *
+       * @param __rhs Another regular expression object.
+       */
+      void
+      swap(basic_regex& __rhs)
+      {
+	std::swap(_M_flags, __rhs._M_flags);
+	std::swap(_M_traits, __rhs._M_traits);
+	std::swap(_M_automaton, __rhs._M_automaton);
+      }
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      _M_dot(std::ostream& __ostr)
+      { _M_automaton->_M_dot(__ostr); }
+#endif
+
+    protected:
+      typedef std::shared_ptr<__detail::_NFA<_Rx_traits>> _AutomatonPtr;
+
+      template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
+	__detail::_RegexExecutorPolicy, bool>
+	friend bool
+	__detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+				    const basic_regex<_Cp, _Rp>&,
+				    regex_constants::match_flag_type);
+
+      template<typename, typename, typename, bool>
+	friend class __detail::_Executor;
+
+      flag_type              _M_flags;
+      _Rx_traits             _M_traits;
+      basic_string<_Ch_type> _M_original_str;
+      _AutomatonPtr          _M_automaton;
+    };
+
+  /** @brief Standard regular expressions. */
+  typedef basic_regex<char>    regex;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /** @brief Standard wide-character regular expressions. */
+  typedef basic_regex<wchar_t> wregex;
+#endif
+
+
+  // [7.8.6] basic_regex swap
+  /**
+   * @brief Swaps the contents of two regular expression objects.
+   * @param __lhs First regular expression.
+   * @param __rhs Second regular expression.
+   */
+  template<typename _Ch_type, typename _Rx_traits>
+    inline void
+    swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
+	 basic_regex<_Ch_type, _Rx_traits>& __rhs)
+    { __lhs.swap(__rhs); }
+
+
+  // [7.9] Class template sub_match
+  /**
+   * A sequence of characters matched by a particular marked sub-expression.
+   *
+   * An object of this class is essentially a pair of iterators marking a
+   * matched subexpression within a regular expression pattern match. Such
+   * objects can be converted to and compared with std::basic_string objects
+   * of a similar base character type as the pattern matched by the regular
+   * expression.
+   *
+   * The iterators that make up the pair are the usual half-open interval
+   * referencing the actual original pattern matched.
+   */
+  template<typename _BiIter>
+    class sub_match : public std::pair<_BiIter, _BiIter>
+    {
+      typedef iterator_traits<_BiIter>			__iter_traits;
+	
+    public:
+      typedef typename __iter_traits::value_type      	value_type;
+      typedef typename __iter_traits::difference_type 	difference_type;
+      typedef _BiIter                                   iterator;
+      typedef std::basic_string<value_type>             string_type;
+
+      bool matched;
+
+      constexpr sub_match() : matched() { }
+
+      /**
+       * Gets the length of the matching sequence.
+       */
+      difference_type
+      length() const
+      { return this->matched ? std::distance(this->first, this->second) : 0; }
+
+      /**
+       * @brief Gets the matching sequence as a string.
+       *
+       * @returns the matching sequence as a string.
+       *
+       * This is the implicit conversion operator.  It is identical to the
+       * str() member function except that it will want to pop up in
+       * unexpected places and cause a great deal of confusion and cursing
+       * from the unwary.
+       */
+      operator string_type() const
+      {
+	return this->matched
+	  ? string_type(this->first, this->second)
+	  : string_type();
+      }
+
+      /**
+       * @brief Gets the matching sequence as a string.
+       *
+       * @returns the matching sequence as a string.
+       */
+      string_type
+      str() const
+      {
+	return this->matched
+	  ? string_type(this->first, this->second)
+	  : string_type();
+      }
+
+      /**
+       * @brief Compares this and another matched sequence.
+       *
+       * @param __s Another matched sequence to compare to this one.
+       *
+       * @retval <0 this matched sequence will collate before @p __s.
+       * @retval =0 this matched sequence is equivalent to @p __s.
+       * @retval <0 this matched sequence will collate after @p __s.
+       */
+      int
+      compare(const sub_match& __s) const
+      { return this->str().compare(__s.str()); }
+
+      /**
+       * @brief Compares this sub_match to a string.
+       *
+       * @param __s A string to compare to this sub_match.
+       *
+       * @retval <0 this matched sequence will collate before @p __s.
+       * @retval =0 this matched sequence is equivalent to @p __s.
+       * @retval <0 this matched sequence will collate after @p __s.
+       */
+      int
+      compare(const string_type& __s) const
+      { return this->str().compare(__s); }
+
+      /**
+       * @brief Compares this sub_match to a C-style string.
+       *
+       * @param __s A C-style string to compare to this sub_match.
+       *
+       * @retval <0 this matched sequence will collate before @p __s.
+       * @retval =0 this matched sequence is equivalent to @p __s.
+       * @retval <0 this matched sequence will collate after @p __s.
+       */
+      int
+      compare(const value_type* __s) const
+      { return this->str().compare(__s); }
+    };
+
+
+  /** @brief Standard regex submatch over a C-style null-terminated string. */
+  typedef sub_match<const char*>             csub_match;
+
+  /** @brief Standard regex submatch over a standard string. */
+  typedef sub_match<string::const_iterator>  ssub_match;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /** @brief Regex submatch over a C-style null-terminated wide string. */
+  typedef sub_match<const wchar_t*>          wcsub_match;
+
+  /** @brief Regex submatch over a standard wide string. */
+  typedef sub_match<wstring::const_iterator> wssub_match;
+#endif
+
+  // [7.9.2] sub_match non-member operators
+
+  /**
+   * @brief Tests the equivalence of two regular expression submatches.
+   * @param __lhs First regular expression submatch.
+   * @param __rhs Second regular expression submatch.
+   * @returns true if @a __lhs  is equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  /**
+   * @brief Tests the inequivalence of two regular expression submatches.
+   * @param __lhs First regular expression submatch.
+   * @param __rhs Second regular expression submatch.
+   * @returns true if @a __lhs  is not equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) != 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param __lhs First regular expression submatch.
+   * @param __rhs Second regular expression submatch.
+   * @returns true if @a __lhs precedes @a __rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param __lhs First regular expression submatch.
+   * @param __rhs Second regular expression submatch.
+   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator<=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param __lhs First regular expression submatch.
+   * @param __rhs Second regular expression submatch.
+   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator>=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param __lhs First regular expression submatch.
+   * @param __rhs Second regular expression submatch.
+   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+  // Alias for sub_match'd string.
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    using __sub_match_string = basic_string<
+			      typename iterator_traits<_Bi_iter>::value_type,
+			      _Ch_traits, _Ch_alloc>;
+
+  /**
+   * @brief Tests the equivalence of a string and a regular expression
+   *        submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs  is equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator==(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __rhs.compare(__lhs.c_str()) == 0; }
+
+  /**
+   * @brief Tests the inequivalence of a string and a regular expression
+   *        submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs  is not equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator!=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs precedes @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+     { return __rhs.compare(__lhs.c_str()) > 0; }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator>(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __rhs < __lhs; }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator>=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__lhs < __rhs); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator<=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__rhs < __lhs); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.compare(__rhs.c_str()) == 0; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs precedes @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.compare(__rhs.c_str()) < 0; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
+    { return __rhs < __lhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
+    { return !(__lhs < __rhs); }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
+    { return !(__rhs < __lhs); }
+
+  /**
+   * @brief Tests the equivalence of a C string and a regular expression
+   *        submatch.
+   * @param __lhs A C string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs  is equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+
+  /**
+   * @brief Tests the inequivalence of an iterator value and a regular
+   *        expression submatch.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs precedes @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __rhs < __lhs; }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__lhs < __rhs); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__rhs < __lhs); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A pointer to a string?
+   * @returns true if @a __lhs  is equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A pointer to a string.
+   * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs precedes @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __rhs < __lhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return !(__lhs < __rhs); }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A string.
+   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return !(__rhs < __lhs); }
+
+  /**
+   * @brief Tests the equivalence of a string and a regular expression
+   *        submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    {
+      typedef typename sub_match<_Bi_iter>::string_type string_type;
+      return __rhs.compare(string_type(1, __lhs)) == 0;
+    }
+
+  /**
+   * @brief Tests the inequivalence of a string and a regular expression
+   *        submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs precedes @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    {
+      typedef typename sub_match<_Bi_iter>::string_type string_type;
+      return __rhs.compare(string_type(1, __lhs)) > 0;
+    }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __rhs < __lhs; }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__lhs < __rhs); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param __lhs A string.
+   * @param __rhs A regular expression submatch.
+   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return !(__rhs < __lhs); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A const string reference.
+   * @returns true if @a __lhs  is equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    {
+      typedef typename sub_match<_Bi_iter>::string_type string_type;
+      return __lhs.compare(string_type(1, __rhs)) == 0;
+    }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A const string reference.
+   * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A const string reference.
+   * @returns true if @a __lhs precedes @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    {
+      typedef typename sub_match<_Bi_iter>::string_type string_type;
+      return __lhs.compare(string_type(1, __rhs)) < 0;
+    }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A const string reference.
+   * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __rhs < __lhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A const string reference.
+   * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return !(__lhs < __rhs); }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param __lhs A regular expression submatch.
+   * @param __rhs A const string reference.
+   * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return !(__rhs < __lhs); }
+
+  /**
+   * @brief Inserts a matched string into an output stream.
+   *
+   * @param __os The output stream.
+   * @param __m  A submatch string.
+   *
+   * @returns the output stream with the submatch string inserted.
+   */
+  template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
+    inline
+    basic_ostream<_Ch_type, _Ch_traits>&
+    operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
+	       const sub_match<_Bi_iter>& __m)
+    { return __os << __m.str(); }
+
+  // [7.10] Class template match_results
+
+  /*
+   * Special sub_match object representing an unmatched sub-expression.
+   */
+  template<typename _Bi_iter>
+    inline const sub_match<_Bi_iter>&
+    __unmatched_sub()
+    {
+      static const sub_match<_Bi_iter> __unmatched = sub_match<_Bi_iter>();
+      return __unmatched;
+    }
+
+  /**
+   * @brief The results of a match or search operation.
+   *
+   * A collection of character sequences representing the result of a regular
+   * expression match.  Storage for the collection is allocated and freed as
+   * necessary by the member functions of class template match_results.
+   *
+   * This class satisfies the Sequence requirements, with the exception that
+   * only the operations defined for a const-qualified Sequence are supported.
+   *
+   * The sub_match object stored at index 0 represents sub-expression 0, i.e.
+   * the whole match. In this case the %sub_match member matched is always true.
+   * The sub_match object stored at index n denotes what matched the marked
+   * sub-expression n within the matched expression. If the sub-expression n
+   * participated in a regular expression match then the %sub_match member
+   * matched evaluates to true, and members first and second denote the range
+   * of characters [first, second) which formed that match. Otherwise matched
+   * is false, and members first and second point to the end of the sequence
+   * that was searched.
+   *
+   * @nosubgrouping
+   */
+  template<typename _Bi_iter,
+	   typename _Alloc = allocator<sub_match<_Bi_iter> > >
+    class match_results
+    : private std::vector<sub_match<_Bi_iter>, _Alloc>
+    {
+    private:
+      /*
+       * The vector base is empty if this does not represent a successful match.
+       * Otherwise it contains n+3 elements where n is the number of marked
+       * sub-expressions:
+       * [0] entire match
+       * [1] 1st marked subexpression
+       * ...
+       * [n] nth marked subexpression
+       * [n+1] prefix
+       * [n+2] suffix
+       */
+      typedef std::vector<sub_match<_Bi_iter>, _Alloc>     _Base_type;
+      typedef std::iterator_traits<_Bi_iter>   	   	   __iter_traits;
+      typedef regex_constants::match_flag_type		   match_flag_type;
+
+    public:
+      /**
+       * @name 10.? Public Types
+       */
+      //@{
+      typedef sub_match<_Bi_iter>                          value_type;
+      typedef const value_type&                            const_reference;
+      typedef const_reference                              reference;
+      typedef typename _Base_type::const_iterator          const_iterator;
+      typedef const_iterator                               iterator;
+      typedef typename __iter_traits::difference_type	   difference_type;
+      typedef typename allocator_traits<_Alloc>::size_type size_type;
+      typedef _Alloc                                       allocator_type;
+      typedef typename __iter_traits::value_type 	   char_type;
+      typedef std::basic_string<char_type>                 string_type;
+      //@}
+
+    public:
+      /**
+       * @name 28.10.1 Construction, Copying, and Destruction
+       */
+      //@{
+
+      /**
+       * @brief Constructs a default %match_results container.
+       * @post size() returns 0 and str() returns an empty string.
+       */
+      explicit
+      match_results(const _Alloc& __a = _Alloc())
+      : _Base_type(__a), _M_in_iterator(false)
+      { }
+
+      /**
+       * @brief Copy constructs a %match_results.
+       */
+      match_results(const match_results& __rhs)
+      : _Base_type(__rhs), _M_in_iterator(false)
+      { }
+
+      /**
+       * @brief Move constructs a %match_results.
+       */
+      match_results(match_results&& __rhs) noexcept
+      : _Base_type(std::move(__rhs)), _M_in_iterator(false)
+      { }
+
+      /**
+       * @brief Assigns rhs to *this.
+       */
+      match_results&
+      operator=(const match_results& __rhs)
+      {
+	match_results(__rhs).swap(*this);
+	return *this;
+      }
+
+      /**
+       * @brief Move-assigns rhs to *this.
+       */
+      match_results&
+      operator=(match_results&& __rhs)
+      {
+	match_results(std::move(__rhs)).swap(*this);
+	return *this;
+      }
+
+      /**
+       * @brief Destroys a %match_results object.
+       */
+      ~match_results()
+      { }
+
+      //@}
+
+      // 28.10.2, state:
+      /**
+       * @brief Indicates if the %match_results is ready.
+       * @retval true   The object has a fully-established result state.
+       * @retval false  The object is not ready.
+       */
+      bool ready() const { return !_Base_type::empty(); }
+
+      /**
+       * @name 28.10.2 Size
+       */
+      //@{
+
+      /**
+       * @brief Gets the number of matches and submatches.
+       *
+       * The number of matches for a given regular expression will be either 0
+       * if there was no match or mark_count() + 1 if a match was successful.
+       * Some matches may be empty.
+       *
+       * @returns the number of matches found.
+       */
+      size_type
+      size() const
+      {
+      	size_type __size = _Base_type::size();
+      	return (__size && _Base_type::operator[](0).matched) ? __size - 2 : 0;
+      }
+
+      size_type
+      max_size() const
+      { return _Base_type::max_size(); }
+
+      /**
+       * @brief Indicates if the %match_results contains no results.
+       * @retval true The %match_results object is empty.
+       * @retval false The %match_results object is not empty.
+       */
+      bool
+      empty() const
+      { return size() == 0; }
+
+      //@}
+
+      /**
+       * @name 10.3 Element Access
+       */
+      //@{
+
+      /**
+       * @brief Gets the length of the indicated submatch.
+       * @param __sub indicates the submatch.
+       * @pre   ready() == true
+       *
+       * This function returns the length of the indicated submatch, or the
+       * length of the entire match if @p __sub is zero (the default).
+       */
+      difference_type
+      length(size_type __sub = 0) const
+      { return (*this)[__sub].length(); }
+
+      /**
+       * @brief Gets the offset of the beginning of the indicated submatch.
+       * @param __sub indicates the submatch.
+       * @pre   ready() == true
+       *
+       * This function returns the offset from the beginning of the target
+       * sequence to the beginning of the submatch, unless the value of @p __sub
+       * is zero (the default), in which case this function returns the offset
+       * from the beginning of the target sequence to the beginning of the
+       * match.
+       *
+       * Returns -1 if @p __sub is out of range.
+       */
+      difference_type
+      position(size_type __sub = 0) const
+      {
+	// [28.12.1.4.5]
+	if (_M_in_iterator)
+	  return __sub < size() ? std::distance(_M_begin,
+						(*this)[__sub].first) : -1;
+	else
+	  return __sub < size() ? std::distance(this->prefix().first,
+						(*this)[__sub].first) : -1;
+      }
+
+      /**
+       * @brief Gets the match or submatch converted to a string type.
+       * @param __sub indicates the submatch.
+       * @pre   ready() == true
+       *
+       * This function gets the submatch (or match, if @p __sub is
+       * zero) extracted from the target range and converted to the
+       * associated string type.
+       */
+      string_type
+      str(size_type __sub = 0) const
+      { return (*this)[__sub].str(); }
+
+      /**
+       * @brief Gets a %sub_match reference for the match or submatch.
+       * @param __sub indicates the submatch.
+       * @pre   ready() == true
+       *
+       * This function gets a reference to the indicated submatch, or
+       * the entire match if @p __sub is zero.
+       *
+       * If @p __sub >= size() then this function returns a %sub_match with a
+       * special value indicating no submatch.
+       */
+      const_reference
+      operator[](size_type __sub) const
+      {
+      	_GLIBCXX_DEBUG_ASSERT( ready() );
+      	return __sub < size()
+	       ?  _Base_type::operator[](__sub)
+	       : __unmatched_sub<_Bi_iter>();
+      }
+
+      /**
+       * @brief Gets a %sub_match representing the match prefix.
+       * @pre   ready() == true
+       *
+       * This function gets a reference to a %sub_match object representing the
+       * part of the target range between the start of the target range and the
+       * start of the match.
+       */
+      const_reference
+      prefix() const
+      {
+      	_GLIBCXX_DEBUG_ASSERT( ready() );
+      	return !empty()
+      	       ? _Base_type::operator[](_Base_type::size() - 2)
+	       : __unmatched_sub<_Bi_iter>();
+      }
+
+      /**
+       * @brief Gets a %sub_match representing the match suffix.
+       * @pre   ready() == true
+       *
+       * This function gets a reference to a %sub_match object representing the
+       * part of the target range between the end of the match and the end of
+       * the target range.
+       */
+      const_reference
+      suffix() const
+      {
+	_GLIBCXX_DEBUG_ASSERT( ready() );
+	return !empty()
+	       ? _Base_type::operator[](_Base_type::size() - 1)
+	       : __unmatched_sub<_Bi_iter>();
+      }
+
+      /**
+       * @brief Gets an iterator to the start of the %sub_match collection.
+       */
+      const_iterator
+      begin() const
+      { return _Base_type::begin(); }
+
+      /**
+       * @brief Gets an iterator to the start of the %sub_match collection.
+       */
+      const_iterator
+      cbegin() const
+      { return _Base_type::cbegin() + 2; }
+
+      /**
+       * @brief Gets an iterator to one-past-the-end of the collection.
+       */
+      const_iterator
+      end() const
+      { return _Base_type::end() - 2; }
+
+      /**
+       * @brief Gets an iterator to one-past-the-end of the collection.
+       */
+      const_iterator
+      cend() const
+      { return _Base_type::cend(); }
+
+      //@}
+
+      /**
+       * @name 10.4 Formatting
+       *
+       * These functions perform formatted substitution of the matched
+       * character sequences into their target.  The format specifiers and
+       * escape sequences accepted by these functions are determined by
+       * their @p flags parameter as documented above.
+       */
+       //@{
+
+      /**
+       * @pre   ready() == true
+       */
+      template<typename _Out_iter>
+	_Out_iter
+	format(_Out_iter __out, const char_type* __fmt_first,
+	       const char_type* __fmt_last,
+	       match_flag_type __flags = regex_constants::format_default) const;
+
+      /**
+       * @pre   ready() == true
+       */
+      template<typename _Out_iter, typename _St, typename _Sa>
+	_Out_iter
+	format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
+	       match_flag_type __flags = regex_constants::format_default) const
+	{
+	  return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
+			__flags);
+	}
+
+      /**
+       * @pre   ready() == true
+       */
+      template<typename _Out_iter, typename _St, typename _Sa>
+	basic_string<char_type, _St, _Sa>
+	format(const basic_string<char_type, _St, _Sa>& __fmt,
+	       match_flag_type __flags = regex_constants::format_default) const
+	{
+	  basic_string<char_type, _St, _Sa> __result;
+	  format(std::back_inserter(__result), __fmt, __flags);
+	  return __result;
+	}
+
+      /**
+       * @pre   ready() == true
+       */
+      string_type
+      format(const char_type* __fmt,
+	     match_flag_type __flags = regex_constants::format_default) const
+      {
+	string_type __result;
+	format(std::back_inserter(__result),
+	       __fmt,
+	       __fmt + char_traits<char_type>::length(__fmt),
+	       __flags);
+	return __result;
+      }
+
+      //@}
+
+      /**
+       * @name 10.5 Allocator
+       */
+      //@{
+
+      /**
+       * @brief Gets a copy of the allocator.
+       */
+      allocator_type
+      get_allocator() const
+      { return _Base_type::get_allocator(); }
+
+      //@}
+
+      /**
+       * @name 10.6 Swap
+       */
+       //@{
+
+      /**
+       * @brief Swaps the contents of two match_results.
+       */
+      void
+      swap(match_results& __that)
+      { _Base_type::swap(__that); }
+      //@}
+
+    private:
+      template<typename, typename, typename, bool>
+	friend class __detail::_Executor;
+
+      template<typename, typename, typename>
+	friend class regex_iterator;
+
+      template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
+	__detail::_RegexExecutorPolicy, bool>
+	friend bool
+	__detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+				    const basic_regex<_Cp, _Rp>&,
+				    regex_constants::match_flag_type);
+
+      _Bi_iter _M_begin;
+      bool     _M_in_iterator;
+    };
+
+  typedef match_results<const char*>             cmatch;
+  typedef match_results<string::const_iterator>  smatch;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef match_results<const wchar_t*>          wcmatch;
+  typedef match_results<wstring::const_iterator> wsmatch;
+#endif
+
+  // match_results comparisons
+  /**
+   * @brief Compares two match_results for equality.
+   * @returns true if the two objects refer to the same match,
+   * false otherwise.
+   */
+  template<typename _Bi_iter, typename _Alloc>
+    inline bool
+    operator==(const match_results<_Bi_iter, _Alloc>& __m1,
+	       const match_results<_Bi_iter, _Alloc>& __m2)
+    {
+      if (__m1.ready() != __m2.ready())
+	return false;
+      if (!__m1.ready())  // both are not ready
+	return true;
+      if (__m1.empty() != __m2.empty())
+	return false;
+      if (__m1.empty())   // both are empty
+	return true;
+      return __m1.prefix() == __m2.prefix()
+	&& __m1.size() == __m2.size()
+	&& std::equal(__m1.begin(), __m1.end(), __m2.begin())
+	&& __m1.suffix() == __m2.suffix();
+    }
+
+  /**
+   * @brief Compares two match_results for inequality.
+   * @returns true if the two objects do not refer to the same match,
+   * false otherwise.
+   */
+  template<typename _Bi_iter, class _Alloc>
+    inline bool
+    operator!=(const match_results<_Bi_iter, _Alloc>& __m1,
+	       const match_results<_Bi_iter, _Alloc>& __m2)
+    { return !(__m1 == __m2); }
+
+  // [7.10.6] match_results swap
+  /**
+   * @brief Swaps two match results.
+   * @param __lhs A match result.
+   * @param __rhs A match result.
+   *
+   * The contents of the two match_results objects are swapped.
+   */
+  template<typename _Bi_iter, typename _Alloc>
+    inline void
+    swap(match_results<_Bi_iter, _Alloc>& __lhs,
+	 match_results<_Bi_iter, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+  // [7.11.2] Function template regex_match
+  /**
+   * @name Matching, Searching, and Replacing
+   */
+  //@{
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and all of the character sequence [first, last).
+   *
+   * @param __s     Start of the character sequence to match.
+   * @param __e     One-past-the-end of the character sequence to match.
+   * @param __m     The match results.
+   * @param __re    The regular expression.
+   * @param __flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Bi_iter, typename _Alloc,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(_Bi_iter                                 __s,
+		_Bi_iter                                 __e,
+		match_results<_Bi_iter, _Alloc>&         __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type         __flags
+			       = regex_constants::match_default)
+    {
+      return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+	__detail::_RegexExecutorPolicy::_S_auto, true>
+	  (__s, __e, __m, __re, __flags);
+    }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and all of the character sequence [first, last).
+   *
+   * @param __first Beginning of the character sequence to match.
+   * @param __last  One-past-the-end of the character sequence to match.
+   * @param __re    The regular expression.
+   * @param __flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(_Bi_iter __first, _Bi_iter __last,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    {
+      match_results<_Bi_iter> __what;
+      return regex_match(__first, __last, __what, __re, __flags);
+    }
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and a C-style null-terminated string.
+   *
+   * @param __s  The C-style null-terminated string to match.
+   * @param __m  The match results.
+   * @param __re The regular expression.
+   * @param __f  Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, typename _Alloc, typename _Rx_traits>
+    inline bool
+    regex_match(const _Ch_type* __s,
+		match_results<const _Ch_type*, _Alloc>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __f
+		= regex_constants::match_default)
+    { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and a string.
+   *
+   * @param __s     The string to match.
+   * @param __m     The match results.
+   * @param __re    The regular expression.
+   * @param __flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _Ch_alloc,
+	   typename _Alloc, typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		match_results<typename basic_string<_Ch_type,
+		_Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and a C-style null-terminated string.
+   *
+   * @param __s  The C-style null-terminated string to match.
+   * @param __re The regular expression.
+   * @param __f  Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, class _Rx_traits>
+    inline bool
+    regex_match(const _Ch_type* __s,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __f
+		= regex_constants::match_default)
+    { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and a string.
+   *
+   * @param __s     [IN] The string to match.
+   * @param __re    [IN] The regular expression.
+   * @param __flags [IN] Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _Str_allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { return regex_match(__s.begin(), __s.end(), __re, __flags); }
+
+  // [7.11.3] Function template regex_search
+  /**
+   * Searches for a regular expression within a range.
+   * @param __s     [IN]  The start of the string to search.
+   * @param __e     [IN]  One-past-the-end of the string to search.
+   * @param __m     [OUT] The match results.
+   * @param __re    [IN]  The regular expression to search for.
+   * @param __flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Bi_iter, typename _Alloc,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(_Bi_iter __s, _Bi_iter __e,
+		 match_results<_Bi_iter, _Alloc>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __re,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    {
+      return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+	__detail::_RegexExecutorPolicy::_S_auto, false>
+	  (__s, __e, __m, __re, __flags);
+    }
+
+  /**
+   * Searches for a regular expression within a range.
+   * @param __first [IN]  The start of the string to search.
+   * @param __last  [IN]  One-past-the-end of the string to search.
+   * @param __re    [IN]  The regular expression to search for.
+   * @param __flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(_Bi_iter __first, _Bi_iter __last,
+		 const basic_regex<_Ch_type, _Rx_traits>& __re,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    {
+      match_results<_Bi_iter> __what;
+      return regex_search(__first, __last, __what, __re, __flags);
+    }
+
+  /**
+   * @brief Searches for a regular expression within a C-string.
+   * @param __s [IN]  A C-string to search for the regex.
+   * @param __m [OUT] The set of regex matches.
+   * @param __e [IN]  The regex to search for in @p s.
+   * @param __f [IN]  The search flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, class _Alloc, class _Rx_traits>
+    inline bool
+    regex_search(const _Ch_type* __s,
+		 match_results<const _Ch_type*, _Alloc>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
+
+  /**
+   * @brief Searches for a regular expression within a C-string.
+   * @param __s [IN]  The C-string to search.
+   * @param __e [IN]  The regular expression to search for.
+   * @param __f [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(const _Ch_type* __s,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
+
+  /**
+   * @brief Searches for a regular expression within a string.
+   * @param __s     [IN]  The string to search.
+   * @param __e     [IN]  The regular expression to search for.
+   * @param __flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _String_allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(const basic_string<_Ch_type, _Ch_traits,
+		 _String_allocator>& __s,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    { return regex_search(__s.begin(), __s.end(), __e, __flags); }
+
+  /**
+   * @brief Searches for a regular expression within a string.
+   * @param __s [IN]  A C++ string to search for the regex.
+   * @param __m [OUT] The set of regex matches.
+   * @param __e [IN]  The regex to search for in @p s.
+   * @param __f [IN]  The search flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _Ch_alloc,
+	   typename _Alloc, typename _Ch_type,
+	   typename _Rx_traits>
+    inline bool
+    regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		 match_results<typename basic_string<_Ch_type,
+		 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
+
+  // std [28.11.4] Function template regex_replace
+  /**
+   * @brief Search for a regular expression within a range for multiple times,
+   and replace the matched parts through filling a format string.
+   * @param __out   [OUT] The output iterator.
+   * @param __first [IN]  The start of the string to search.
+   * @param __last  [IN]  One-past-the-end of the string to search.
+   * @param __e     [IN]  The regular expression to search for.
+   * @param __fmt   [IN]  The format string.
+   * @param __flags [IN]  Search and replace policy flags.
+   *
+   * @returns __out
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Out_iter, typename _Bi_iter,
+	   typename _Rx_traits, typename _Ch_type,
+	   typename _St, typename _Sa>
+    inline _Out_iter
+    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const basic_string<_Ch_type, _St, _Sa>& __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    {
+      return regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
+    }
+
+  /**
+   * @brief Search for a regular expression within a range for multiple times,
+   and replace the matched parts through filling a format C-string.
+   * @param __out   [OUT] The output iterator.
+   * @param __first [IN]  The start of the string to search.
+   * @param __last  [IN]  One-past-the-end of the string to search.
+   * @param __e     [IN]  The regular expression to search for.
+   * @param __fmt   [IN]  The format C-string.
+   * @param __flags [IN]  Search and replace policy flags.
+   *
+   * @returns __out
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Out_iter, typename _Bi_iter,
+	   typename _Rx_traits, typename _Ch_type>
+    _Out_iter
+    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const _Ch_type* __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default);
+
+  /**
+   * @brief Search for a regular expression within a string for multiple times,
+   and replace the matched parts through filling a format string.
+   * @param __s     [IN] The string to search and replace.
+   * @param __e     [IN] The regular expression to search for.
+   * @param __fmt   [IN] The format string.
+   * @param __flags [IN] Search and replace policy flags.
+   *
+   * @returns The string after replacing.
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Rx_traits, typename _Ch_type,
+	   typename _St, typename _Sa, typename _Fst, typename _Fsa>
+    inline basic_string<_Ch_type, _St, _Sa>
+    regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const basic_string<_Ch_type, _Fst, _Fsa>& __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    {
+      basic_string<_Ch_type, _St, _Sa> __result;
+      regex_replace(std::back_inserter(__result),
+		    __s.begin(), __s.end(), __e, __fmt, __flags);
+      return __result;
+    }
+
+  /**
+   * @brief Search for a regular expression within a string for multiple times,
+   and replace the matched parts through filling a format C-string.
+   * @param __s     [IN] The string to search and replace.
+   * @param __e     [IN] The regular expression to search for.
+   * @param __fmt   [IN] The format C-string.
+   * @param __flags [IN] Search and replace policy flags.
+   *
+   * @returns The string after replacing.
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Rx_traits, typename _Ch_type,
+	   typename _St, typename _Sa>
+    inline basic_string<_Ch_type, _St, _Sa>
+    regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const _Ch_type* __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    {
+      basic_string<_Ch_type, _St, _Sa> __result;
+      regex_replace(std::back_inserter(__result),
+		    __s.begin(), __s.end(), __e, __fmt, __flags);
+      return __result;
+    }
+
+  /**
+   * @brief Search for a regular expression within a C-string for multiple
+   times, and replace the matched parts through filling a format string.
+   * @param __s     [IN] The C-string to search and replace.
+   * @param __e     [IN] The regular expression to search for.
+   * @param __fmt   [IN] The format string.
+   * @param __flags [IN] Search and replace policy flags.
+   *
+   * @returns The string after replacing.
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Rx_traits, typename _Ch_type,
+	   typename _St, typename _Sa>
+    inline basic_string<_Ch_type>
+    regex_replace(const _Ch_type* __s,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const basic_string<_Ch_type, _St, _Sa>& __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    {
+      basic_string<_Ch_type> __result;
+      regex_replace(std::back_inserter(__result), __s,
+		    __s + char_traits<_Ch_type>::length(__s),
+		    __e, __fmt, __flags);
+      return __result;
+    }
+
+  /**
+   * @brief Search for a regular expression within a C-string for multiple
+   times, and replace the matched parts through filling a format C-string.
+   * @param __s     [IN] The C-string to search and replace.
+   * @param __e     [IN] The regular expression to search for.
+   * @param __fmt   [IN] The format C-string.
+   * @param __flags [IN] Search and replace policy flags.
+   *
+   * @returns The string after replacing.
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Rx_traits, typename _Ch_type>
+    inline basic_string<_Ch_type>
+    regex_replace(const _Ch_type* __s,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const _Ch_type* __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    {
+      basic_string<_Ch_type> __result;
+      regex_replace(std::back_inserter(__result), __s,
+		    __s + char_traits<_Ch_type>::length(__s),
+		    __e, __fmt, __flags);
+      return __result;
+    }
+
+  //@}
+
+  // std [28.12] Class template regex_iterator
+  /**
+   * An iterator adaptor that will provide repeated calls of regex_search over
+   * a range until no more matches remain.
+   */
+  template<typename _Bi_iter,
+	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+	   typename _Rx_traits = regex_traits<_Ch_type> >
+    class regex_iterator
+    {
+    public:
+      typedef basic_regex<_Ch_type, _Rx_traits>  regex_type;
+      typedef match_results<_Bi_iter>            value_type;
+      typedef std::ptrdiff_t                     difference_type;
+      typedef const value_type*                  pointer;
+      typedef const value_type&                  reference;
+      typedef std::forward_iterator_tag          iterator_category;
+
+      /**
+       * @brief Provides a singular iterator, useful for indicating
+       * one-past-the-end of a range.
+       */
+      regex_iterator()
+      : _M_match()
+      { }
+
+      /**
+       * Constructs a %regex_iterator...
+       * @param __a  [IN] The start of a text range to search.
+       * @param __b  [IN] One-past-the-end of the text range to search.
+       * @param __re [IN] The regular expression to match.
+       * @param __m  [IN] Policy flags for match rules.
+       */
+      regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+		     regex_constants::match_flag_type __m
+		     = regex_constants::match_default)
+      : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
+      {
+	if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
+	  *this = regex_iterator();
+      }
+
+      /**
+       * Copy constructs a %regex_iterator.
+       */
+      regex_iterator(const regex_iterator& __rhs) = default;
+
+      /**
+       * @brief Assigns one %regex_iterator to another.
+       */
+      regex_iterator&
+      operator=(const regex_iterator& __rhs) = default;
+
+      /**
+       * @brief Tests the equivalence of two regex iterators.
+       */
+      bool
+      operator==(const regex_iterator& __rhs) const;
+
+      /**
+       * @brief Tests the inequivalence of two regex iterators.
+       */
+      bool
+      operator!=(const regex_iterator& __rhs) const
+      { return !(*this == __rhs); }
+
+      /**
+       * @brief Dereferences a %regex_iterator.
+       */
+      const value_type&
+      operator*() const
+      { return _M_match; }
+
+      /**
+       * @brief Selects a %regex_iterator member.
+       */
+      const value_type*
+      operator->() const
+      { return &_M_match; }
+
+      /**
+       * @brief Increments a %regex_iterator.
+       */
+      regex_iterator&
+      operator++();
+
+      /**
+       * @brief Postincrements a %regex_iterator.
+       */
+      regex_iterator
+      operator++(int)
+      {
+	auto __tmp = *this;
+	++(*this);
+	return __tmp;
+      }
+
+    private:
+      _Bi_iter                         _M_begin;
+      _Bi_iter                         _M_end;
+      const regex_type*                _M_pregex;
+      regex_constants::match_flag_type _M_flags;
+      match_results<_Bi_iter>          _M_match;
+    };
+
+  typedef regex_iterator<const char*>             cregex_iterator;
+  typedef regex_iterator<string::const_iterator>  sregex_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef regex_iterator<const wchar_t*>          wcregex_iterator;
+  typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
+#endif
+
+  // [7.12.2] Class template regex_token_iterator
+  /**
+   * Iterates over submatches in a range (or @a splits a text string).
+   *
+   * The purpose of this iterator is to enumerate all, or all specified,
+   * matches of a regular expression within a text range.  The dereferenced
+   * value of an iterator of this class is a std::sub_match object.
+   */
+  template<typename _Bi_iter,
+	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+	   typename _Rx_traits = regex_traits<_Ch_type> >
+    class regex_token_iterator
+    {
+    public:
+      typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
+      typedef sub_match<_Bi_iter>               value_type;
+      typedef std::ptrdiff_t                    difference_type;
+      typedef const value_type*                 pointer;
+      typedef const value_type&                 reference;
+      typedef std::forward_iterator_tag         iterator_category;
+
+    public:
+      /**
+       * @brief Default constructs a %regex_token_iterator.
+       *
+       * A default-constructed %regex_token_iterator is a singular iterator
+       * that will compare equal to the one-past-the-end value for any
+       * iterator of the same type.
+       */
+      regex_token_iterator()
+      : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
+      _M_has_m1(false)
+      { }
+
+      /**
+       * Constructs a %regex_token_iterator...
+       * @param __a          [IN] The start of the text to search.
+       * @param __b          [IN] One-past-the-end of the text to search.
+       * @param __re         [IN] The regular expression to search for.
+       * @param __submatch   [IN] Which submatch to return.  There are some
+       *                        special values for this parameter:
+       *                        - -1 each enumerated subexpression does NOT
+       *                          match the regular expression (aka field
+       *                          splitting)
+       *                        - 0 the entire string matching the
+       *                          subexpression is returned for each match
+       *                          within the text.
+       *                        - >0 enumerates only the indicated
+       *                          subexpression from a match within the text.
+       * @param __m          [IN] Policy flags for match rules.
+       */
+      regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+			   int __submatch = 0,
+			   regex_constants::match_flag_type __m
+			   = regex_constants::match_default)
+      : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
+      { _M_init(__a, __b); }
+
+      /**
+       * Constructs a %regex_token_iterator...
+       * @param __a          [IN] The start of the text to search.
+       * @param __b          [IN] One-past-the-end of the text to search.
+       * @param __re         [IN] The regular expression to search for.
+       * @param __submatches [IN] A list of subexpressions to return for each
+       *                          regular expression match within the text.
+       * @param __m          [IN] Policy flags for match rules.
+       */
+      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+			   const regex_type& __re,
+			   const std::vector<int>& __submatches,
+			   regex_constants::match_flag_type __m
+			     = regex_constants::match_default)
+      : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
+      { _M_init(__a, __b); }
+
+      /**
+       * Constructs a %regex_token_iterator...
+       * @param __a          [IN] The start of the text to search.
+       * @param __b          [IN] One-past-the-end of the text to search.
+       * @param __re         [IN] The regular expression to search for.
+       * @param __submatches [IN] A list of subexpressions to return for each
+       *                          regular expression match within the text.
+       * @param __m          [IN] Policy flags for match rules.
+       */
+      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+			   const regex_type& __re,
+			   initializer_list<int> __submatches,
+			   regex_constants::match_flag_type __m
+			     = regex_constants::match_default)
+      : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
+      { _M_init(__a, __b); }
+
+      /**
+       * Constructs a %regex_token_iterator...
+       * @param __a          [IN] The start of the text to search.
+       * @param __b          [IN] One-past-the-end of the text to search.
+       * @param __re         [IN] The regular expression to search for.
+       * @param __submatches [IN] A list of subexpressions to return for each
+       *                          regular expression match within the text.
+       * @param __m          [IN] Policy flags for match rules.
+       */
+      template<std::size_t _Nm>
+	regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+			     const regex_type& __re,
+			     const int (&__submatches)[_Nm],
+			     regex_constants::match_flag_type __m
+			     = regex_constants::match_default)
+      : _M_position(__a, __b, __re, __m),
+      _M_subs(__submatches, *(&__submatches+1)), _M_n(0)
+      { _M_init(__a, __b); }
+
+      /**
+       * @brief Copy constructs a %regex_token_iterator.
+       * @param __rhs [IN] A %regex_token_iterator to copy.
+       */
+      regex_token_iterator(const regex_token_iterator& __rhs)
+      : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
+      _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_result(__rhs._M_result),
+      _M_has_m1(__rhs._M_has_m1)
+      {
+	if (__rhs._M_result == &__rhs._M_suffix)
+	  _M_result = &_M_suffix;
+      }
+
+      /**
+       * @brief Assigns a %regex_token_iterator to another.
+       * @param __rhs [IN] A %regex_token_iterator to copy.
+       */
+      regex_token_iterator&
+      operator=(const regex_token_iterator& __rhs);
+
+      /**
+       * @brief Compares a %regex_token_iterator to another for equality.
+       */
+      bool
+      operator==(const regex_token_iterator& __rhs) const;
+
+      /**
+       * @brief Compares a %regex_token_iterator to another for inequality.
+       */
+      bool
+      operator!=(const regex_token_iterator& __rhs) const
+      { return !(*this == __rhs); }
+
+      /**
+       * @brief Dereferences a %regex_token_iterator.
+       */
+      const value_type&
+      operator*() const
+      { return *_M_result; }
+
+      /**
+       * @brief Selects a %regex_token_iterator member.
+       */
+      const value_type*
+      operator->() const
+      { return _M_result; }
+
+      /**
+       * @brief Increments a %regex_token_iterator.
+       */
+      regex_token_iterator&
+      operator++();
+
+      /**
+       * @brief Postincrements a %regex_token_iterator.
+       */
+      regex_token_iterator
+      operator++(int)
+      {
+	auto __tmp = *this;
+	++(*this);
+	return __tmp;
+      }
+
+    private:
+      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _Position;
+
+      void
+      _M_init(_Bi_iter __a, _Bi_iter __b);
+
+      const value_type&
+      _M_current_match() const
+      {
+	if (_M_subs[_M_n] == -1)
+	  return (*_M_position).prefix();
+	else
+	  return (*_M_position)[_M_subs[_M_n]];
+      }
+
+      constexpr bool
+      _M_end_of_seq()
+      { return _M_result == nullptr; }
+
+      _Position         _M_position;
+      std::vector<int>  _M_subs;
+      value_type        _M_suffix;
+      std::size_t       _M_n;
+      const value_type* _M_result;
+
+      // Show whether _M_subs contains -1
+      bool              _M_has_m1;
+    };
+
+  /** @brief Token iterator for C-style NULL-terminated strings. */
+  typedef regex_token_iterator<const char*>             cregex_token_iterator;
+
+  /** @brief Token iterator for standard strings. */
+  typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /** @brief Token iterator for C-style NULL-terminated wide strings. */
+  typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
+
+  /** @brief Token iterator for standard wide-character strings. */
+  typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+#endif
+
+  //@} // group regex
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/regex.tcc>
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex.tcc b/gcc-4.9/libstdc++-v3/include/bits/regex.tcc
new file mode 100644
index 0000000..5fa1f01
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex.tcc
@@ -0,0 +1,708 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+// See below __regex_algo_impl to get what this is talking about. The default
+// value 1 indicated a conservative optimization without giving up worst case
+// performance.
+#ifndef _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT
+#define _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT 1
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Result of merging regex_match and regex_search.
+  //
+  // __policy now can be _S_auto (auto dispatch) and _S_alternate (use
+  // the other one if possible, for test purpose).
+  //
+  // That __match_mode is true means regex_match, else regex_search.
+  template<typename _BiIter, typename _Alloc,
+	   typename _CharT, typename _TraitsT,
+	   _RegexExecutorPolicy __policy,
+	   bool __match_mode>
+    bool
+    __regex_algo_impl(_BiIter                              __s,
+		      _BiIter                              __e,
+		      match_results<_BiIter, _Alloc>&      __m,
+		      const basic_regex<_CharT, _TraitsT>& __re,
+		      regex_constants::match_flag_type     __flags)
+    {
+      if (__re._M_automaton == nullptr)
+	return false;
+
+      typename match_results<_BiIter, _Alloc>::_Base_type& __res = __m;
+      __res.resize(__re._M_automaton->_M_sub_count() + 2);
+      for (auto& __it : __res)
+	__it.matched = false;
+
+      // This function decide which executor to use under given circumstances.
+      // The _S_auto policy now is the following: if a NFA has no
+      // back-references and has more than _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT
+      // quantifiers (*, +, ?), the BFS executor will be used, other wise
+      // DFS executor. This is because DFS executor has a exponential upper
+      // bound, but better best-case performace. Meanwhile, BFS executor can
+      // effectively prevent from exponential-long time matching (which must
+      // contains many quantifiers), but it's slower in average.
+      //
+      // For simple regex, BFS executor could be 2 or more times slower than
+      // DFS executor.
+      //
+      // Of course, BFS executor cannot handle back-references.
+      bool __ret;
+      if (!__re._M_automaton->_M_has_backref
+	  && (__policy == _RegexExecutorPolicy::_S_alternate
+	      || __re._M_automaton->_M_quant_count
+		> _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT))
+	{
+	  _Executor<_BiIter, _Alloc, _TraitsT, false>
+	    __executor(__s, __e, __m, __re, __flags);
+	  if (__match_mode)
+	    __ret = __executor._M_match();
+	  else
+	    __ret = __executor._M_search();
+	}
+      else
+	{
+	  _Executor<_BiIter, _Alloc, _TraitsT, true>
+	    __executor(__s, __e, __m, __re, __flags);
+	  if (__match_mode)
+	    __ret = __executor._M_match();
+	  else
+	    __ret = __executor._M_search();
+	}
+      if (__ret)
+	{
+	  for (auto __it : __res)
+	    if (!__it.matched)
+	      __it.first = __it.second = __e;
+	  auto& __pre = __res[__res.size()-2];
+	  auto& __suf = __res[__res.size()-1];
+	  if (__match_mode)
+	    {
+	      __pre.matched = false;
+	      __pre.first = __s;
+	      __pre.second = __s;
+	      __suf.matched = false;
+	      __suf.first = __e;
+	      __suf.second = __e;
+	    }
+	  else
+	    {
+	      __pre.first = __s;
+	      __pre.second = __res[0].first;
+	      __pre.matched = (__pre.first != __pre.second);
+	      __suf.first = __res[0].second;
+	      __suf.second = __e;
+	      __suf.matched = (__suf.first != __suf.second);
+	    }
+	}
+      return __ret;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Ch_type>
+  template<typename _Fwd_iter>
+    typename regex_traits<_Ch_type>::string_type
+    regex_traits<_Ch_type>::
+    lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
+    {
+      typedef std::ctype<char_type> __ctype_type;
+      const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
+
+      static const char* __collatenames[] =
+	{
+	  "NUL",
+	  "SOH",
+	  "STX",
+	  "ETX",
+	  "EOT",
+	  "ENQ",
+	  "ACK",
+	  "alert",
+	  "backspace",
+	  "tab",
+	  "newline",
+	  "vertical-tab",
+	  "form-feed",
+	  "carriage-return",
+	  "SO",
+	  "SI",
+	  "DLE",
+	  "DC1",
+	  "DC2",
+	  "DC3",
+	  "DC4",
+	  "NAK",
+	  "SYN",
+	  "ETB",
+	  "CAN",
+	  "EM",
+	  "SUB",
+	  "ESC",
+	  "IS4",
+	  "IS3",
+	  "IS2",
+	  "IS1",
+	  "space",
+	  "exclamation-mark",
+	  "quotation-mark",
+	  "number-sign",
+	  "dollar-sign",
+	  "percent-sign",
+	  "ampersand",
+	  "apostrophe",
+	  "left-parenthesis",
+	  "right-parenthesis",
+	  "asterisk",
+	  "plus-sign",
+	  "comma",
+	  "hyphen",
+	  "period",
+	  "slash",
+	  "zero",
+	  "one",
+	  "two",
+	  "three",
+	  "four",
+	  "five",
+	  "six",
+	  "seven",
+	  "eight",
+	  "nine",
+	  "colon",
+	  "semicolon",
+	  "less-than-sign",
+	  "equals-sign",
+	  "greater-than-sign",
+	  "question-mark",
+	  "commercial-at",
+	  "A",
+	  "B",
+	  "C",
+	  "D",
+	  "E",
+	  "F",
+	  "G",
+	  "H",
+	  "I",
+	  "J",
+	  "K",
+	  "L",
+	  "M",
+	  "N",
+	  "O",
+	  "P",
+	  "Q",
+	  "R",
+	  "S",
+	  "T",
+	  "U",
+	  "V",
+	  "W",
+	  "X",
+	  "Y",
+	  "Z",
+	  "left-square-bracket",
+	  "backslash",
+	  "right-square-bracket",
+	  "circumflex",
+	  "underscore",
+	  "grave-accent",
+	  "a",
+	  "b",
+	  "c",
+	  "d",
+	  "e",
+	  "f",
+	  "g",
+	  "h",
+	  "i",
+	  "j",
+	  "k",
+	  "l",
+	  "m",
+	  "n",
+	  "o",
+	  "p",
+	  "q",
+	  "r",
+	  "s",
+	  "t",
+	  "u",
+	  "v",
+	  "w",
+	  "x",
+	  "y",
+	  "z",
+	  "left-curly-bracket",
+	  "vertical-line",
+	  "right-curly-bracket",
+	  "tilde",
+	  "DEL",
+	  ""
+	};
+
+      // same as boost
+      //static const char* __digraphs[] =
+      //  {
+      //    "ae",
+      //    "Ae",
+      //    "AE",
+      //    "ch",
+      //    "Ch",
+      //    "CH",
+      //    "ll",
+      //    "Ll",
+      //    "LL",
+      //    "ss",
+      //    "Ss",
+      //    "SS",
+      //    "nj",
+      //    "Nj",
+      //    "NJ",
+      //    "dz",
+      //    "Dz",
+      //    "DZ",
+      //    "lj",
+      //    "Lj",
+      //    "LJ",
+      //    ""
+      //  };
+
+      std::string __s(__last - __first, '?');
+      __fctyp.narrow(__first, __last, '?', &*__s.begin());
+
+      for (unsigned int __i = 0; *__collatenames[__i]; __i++)
+	if (__s == __collatenames[__i])
+	  return string_type(1, __fctyp.widen(static_cast<char>(__i)));
+
+      //for (unsigned int __i = 0; *__digraphs[__i]; __i++)
+      //  {
+      //    const char* __now = __digraphs[__i];
+      //    if (__s == __now)
+      //      {
+      //	string_type ret(__s.size(), __fctyp.widen('?'));
+      //	__fctyp.widen(__now, __now + 2/* ouch */, &*ret.begin());
+      //	return ret;
+      //      }
+      //  }
+      return string_type();
+    }
+
+  template<typename _Ch_type>
+  template<typename _Fwd_iter>
+    typename regex_traits<_Ch_type>::char_class_type
+    regex_traits<_Ch_type>::
+    lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase) const
+    {
+      typedef std::ctype<char_type> __ctype_type;
+      typedef std::ctype<char> __cctype_type;
+      typedef const pair<const char*, char_class_type> _ClassnameEntry;
+      const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
+      const __cctype_type& __cctyp(use_facet<__cctype_type>(_M_locale));
+
+      static _ClassnameEntry __classnames[] =
+      {
+	{"d", ctype_base::digit},
+	{"w", {ctype_base::alnum, _RegexMask::_S_under}},
+	{"s", ctype_base::space},
+	{"alnum", ctype_base::alnum},
+	{"alpha", ctype_base::alpha},
+	{"blank", {0, _RegexMask::_S_blank}},
+	{"cntrl", ctype_base::cntrl},
+	{"digit", ctype_base::digit},
+	{"graph", ctype_base::graph},
+	{"lower", ctype_base::lower},
+	{"print", ctype_base::print},
+	{"punct", ctype_base::punct},
+	{"space", ctype_base::space},
+	{"upper", ctype_base::upper},
+	{"xdigit", ctype_base::xdigit},
+      };
+
+      std::string __s(__last - __first, '?');
+      __fctyp.narrow(__first, __last, '?', &__s[0]);
+      __cctyp.tolower(&*__s.begin(), &*__s.begin() + __s.size());
+      for (_ClassnameEntry* __it = __classnames;
+	   __it < *(&__classnames + 1);
+	   ++__it)
+	{
+	  if (__s == __it->first)
+	    {
+	      if (__icase
+		  && ((__it->second
+		       & (ctype_base::lower | ctype_base::upper)) != 0))
+		return ctype_base::alpha;
+	      return __it->second;
+	    }
+	}
+      return 0;
+    }
+
+  template<typename _Ch_type>
+    bool
+    regex_traits<_Ch_type>::
+    isctype(_Ch_type __c, char_class_type __f) const
+    {
+      typedef std::ctype<char_type> __ctype_type;
+      const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
+
+      return __fctyp.is(__f._M_base, __c)
+	// [[:w:]]
+	|| ((__f._M_extended & _RegexMask::_S_under)
+	    && __c == __fctyp.widen('_'))
+	// [[:blank:]]
+	|| ((__f._M_extended & _RegexMask::_S_blank)
+	    && (__c == __fctyp.widen(' ')
+		|| __c == __fctyp.widen('\t')));
+    }
+
+  template<typename _Ch_type>
+    int
+    regex_traits<_Ch_type>::
+    value(_Ch_type __ch, int __radix) const
+    {
+      std::basic_istringstream<char_type> __is(string_type(1, __ch));
+      long __v;
+      if (__radix == 8)
+	__is >> std::oct;
+      else if (__radix == 16)
+	__is >> std::hex;
+      __is >> __v;
+      return __is.fail() ? -1 : __v;
+    }
+
+  template<typename _Bi_iter, typename _Alloc>
+  template<typename _Out_iter>
+    _Out_iter match_results<_Bi_iter, _Alloc>::
+    format(_Out_iter __out,
+	   const match_results<_Bi_iter, _Alloc>::char_type* __fmt_first,
+	   const match_results<_Bi_iter, _Alloc>::char_type* __fmt_last,
+	   match_flag_type __flags) const
+    {
+      _GLIBCXX_DEBUG_ASSERT( ready() );
+      regex_traits<char_type> __traits;
+      typedef std::ctype<char_type> __ctype_type;
+      const __ctype_type&
+	__fctyp(use_facet<__ctype_type>(__traits.getloc()));
+
+      auto __output = [&](size_t __idx)
+	{
+	  auto& __sub = _Base_type::operator[](__idx);
+	  if (__sub.matched)
+	    __out = std::copy(__sub.first, __sub.second, __out);
+	};
+
+      if (__flags & regex_constants::format_sed)
+	{
+	  for (; __fmt_first != __fmt_last;)
+	    if (*__fmt_first == '&')
+	      {
+		__output(0);
+		++__fmt_first;
+	      }
+	    else if (*__fmt_first == '\\')
+	      {
+		if (++__fmt_first != __fmt_last
+		    && __fctyp.is(__ctype_type::digit, *__fmt_first))
+		  __output(__traits.value(*__fmt_first++, 10));
+		else
+		  *__out++ = '\\';
+	      }
+	    else
+	      *__out++ = *__fmt_first++;
+	}
+      else
+	{
+	  while (1)
+	    {
+	      auto __next = std::find(__fmt_first, __fmt_last, '$');
+	      if (__next == __fmt_last)
+		break;
+
+	      __out = std::copy(__fmt_first, __next, __out);
+
+	      auto __eat = [&](char __ch) -> bool
+		{
+		  if (*__next == __ch)
+		    {
+		      ++__next;
+		      return true;
+		    }
+		  return false;
+		};
+
+	      if (++__next == __fmt_last)
+		*__out++ = '$';
+	      else if (__eat('$'))
+		*__out++ = '$';
+	      else if (__eat('&'))
+		__output(0);
+	      else if (__eat('`'))
+		__output(_Base_type::size()-2);
+	      else if (__eat('\''))
+		__output(_Base_type::size()-1);
+	      else if (__fctyp.is(__ctype_type::digit, *__next))
+		{
+		  long __num = __traits.value(*__next, 10);
+		  if (++__next != __fmt_last
+		      && __fctyp.is(__ctype_type::digit, *__next))
+		    {
+		      __num *= 10;
+		      __num += __traits.value(*__next++, 10);
+		    }
+		  if (0 <= __num && __num < this->size())
+		    __output(__num);
+		}
+	      else
+		*__out++ = '$';
+	      __fmt_first = __next;
+	    }
+	  __out = std::copy(__fmt_first, __fmt_last, __out);
+	}
+      return __out;
+    }
+
+  template<typename _Out_iter, typename _Bi_iter,
+	   typename _Rx_traits, typename _Ch_type>
+    _Out_iter
+    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const _Ch_type* __fmt,
+		  regex_constants::match_flag_type __flags)
+    {
+      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _IterT;
+      _IterT __i(__first, __last, __e, __flags);
+      _IterT __end;
+      if (__i == __end)
+	{
+	  if (!(__flags & regex_constants::format_no_copy))
+	    __out = std::copy(__first, __last, __out);
+	}
+      else
+	{
+	  sub_match<_Bi_iter> __last;
+	  auto __len = char_traits<_Ch_type>::length(__fmt);
+	  for (; __i != __end; ++__i)
+	    {
+	      if (!(__flags & regex_constants::format_no_copy))
+		__out = std::copy(__i->prefix().first, __i->prefix().second,
+				  __out);
+	      __out = __i->format(__out, __fmt, __fmt + __len, __flags);
+	      __last = __i->suffix();
+	      if (__flags & regex_constants::format_first_only)
+		break;
+	    }
+	  if (!(__flags & regex_constants::format_no_copy))
+	    __out = std::copy(__last.first, __last.second, __out);
+	}
+      return __out;
+    }
+
+  template<typename _Bi_iter,
+	   typename _Ch_type,
+	   typename _Rx_traits>
+    bool
+    regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
+    operator==(const regex_iterator& __rhs) const
+    {
+      return (_M_match.empty() && __rhs._M_match.empty())
+	|| (_M_begin == __rhs._M_begin
+	    && _M_end == __rhs._M_end
+	    && _M_pregex == __rhs._M_pregex
+	    && _M_flags == __rhs._M_flags
+	    && _M_match[0] == __rhs._M_match[0]);
+    }
+
+  template<typename _Bi_iter,
+	   typename _Ch_type,
+	   typename _Rx_traits>
+    regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
+    regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
+    operator++()
+    {
+      // In all cases in which the call to regex_search returns true,
+      // match.prefix().first shall be equal to the previous value of
+      // match[0].second, and for each index i in the half-open range
+      // [0, match.size()) for which match[i].matched is true,
+      // match[i].position() shall return distance(begin, match[i].first).
+      // [28.12.1.4.5]
+      if (_M_match[0].matched)
+	{
+	  auto __start = _M_match[0].second;
+	  auto __prefix_first = _M_match[0].second;
+	  if (_M_match[0].first == _M_match[0].second)
+	    {
+	      if (__start == _M_end)
+		{
+		  _M_match = value_type();
+		  return *this;
+		}
+	      else
+		{
+		  if (regex_search(__start, _M_end, _M_match, *_M_pregex,
+				   _M_flags
+				   | regex_constants::match_not_null
+				   | regex_constants::match_continuous))
+		    {
+		      _GLIBCXX_DEBUG_ASSERT(_M_match[0].matched);
+		      _M_match.at(_M_match.size()).first = __prefix_first;
+		      _M_match._M_in_iterator = true;
+		      _M_match._M_begin = _M_begin;
+		      return *this;
+		    }
+		  else
+		    ++__start;
+		}
+	    }
+	  _M_flags |= regex_constants::match_prev_avail;
+	  if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags))
+	    {
+	      _GLIBCXX_DEBUG_ASSERT(_M_match[0].matched);
+	      _M_match.at(_M_match.size()).first = __prefix_first;
+	      _M_match._M_in_iterator = true;
+	      _M_match._M_begin = _M_begin;
+	    }
+	  else
+	    _M_match = value_type();
+	}
+      return *this;
+    }
+
+  template<typename _Bi_iter,
+	   typename _Ch_type,
+	   typename _Rx_traits>
+    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
+    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
+    operator=(const regex_token_iterator& __rhs)
+    {
+      _M_position = __rhs._M_position;
+      _M_subs = __rhs._M_subs;
+      _M_n = __rhs._M_n;
+      _M_result = __rhs._M_result;
+      _M_suffix = __rhs._M_suffix;
+      _M_has_m1 = __rhs._M_has_m1;
+      if (__rhs._M_result == &__rhs._M_suffix)
+	_M_result = &_M_suffix;
+      return *this;
+    }
+
+  template<typename _Bi_iter,
+	   typename _Ch_type,
+	   typename _Rx_traits>
+    bool
+    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
+    operator==(const regex_token_iterator& __rhs) const
+    {
+      if (_M_end_of_seq() && __rhs._M_end_of_seq())
+	return true;
+      if (_M_suffix.matched && __rhs._M_suffix.matched
+	  && _M_suffix == __rhs._M_suffix)
+	return true;
+      if (_M_end_of_seq() || _M_suffix.matched
+	  || __rhs._M_end_of_seq() || __rhs._M_suffix.matched)
+	return false;
+      return _M_position == __rhs._M_position
+	&& _M_n == __rhs._M_n
+	&& _M_subs == __rhs._M_subs;
+    }
+
+  template<typename _Bi_iter,
+	   typename _Ch_type,
+	   typename _Rx_traits>
+    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
+    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
+    operator++()
+    {
+      _Position __prev = _M_position;
+      if (_M_suffix.matched)
+	*this = regex_token_iterator();
+      else if (_M_n + 1 < _M_subs.size())
+	{
+	  _M_n++;
+	  _M_result = &_M_current_match();
+	}
+      else
+	{
+	  _M_n = 0;
+	  ++_M_position;
+	  if (_M_position != _Position())
+	    _M_result = &_M_current_match();
+	  else if (_M_has_m1 && __prev->suffix().length() != 0)
+	    {
+	      _M_suffix.matched = true;
+	      _M_suffix.first = __prev->suffix().first;
+	      _M_suffix.second = __prev->suffix().second;
+	      _M_result = &_M_suffix;
+	    }
+	  else
+	    *this = regex_token_iterator();
+	}
+      return *this;
+    }
+
+  template<typename _Bi_iter,
+	   typename _Ch_type,
+	   typename _Rx_traits>
+    void
+    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
+    _M_init(_Bi_iter __a, _Bi_iter __b)
+    {
+      _M_has_m1 = false;
+      for (auto __it : _M_subs)
+	if (__it == -1)
+	  {
+	    _M_has_m1 = true;
+	    break;
+	  }
+      if (_M_position != _Position())
+	_M_result = &_M_current_match();
+      else if (_M_has_m1)
+	{
+	  _M_suffix.matched = true;
+	  _M_suffix.first = __a;
+	  _M_suffix.second = __b;
+	  _M_result = &_M_suffix;
+	}
+      else
+	_M_result = nullptr;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_automaton.h b/gcc-4.9/libstdc++-v3/include/bits/regex_automaton.h
new file mode 100644
index 0000000..a442cfe
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_automaton.h
@@ -0,0 +1,310 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_automaton.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @defgroup regex-detail Base and Implementation Classes
+   *  @ingroup regex
+   *  @{
+   */
+
+  typedef long _StateIdT;
+  static const _StateIdT _S_invalid_state_id  = -1;
+
+  template<typename _CharT>
+    using _Matcher = std::function<bool (_CharT)>;
+
+  /// Operation codes that define the type of transitions within the base NFA
+  /// that represents the regular expression.
+  enum _Opcode : int
+  {
+      _S_opcode_unknown,
+      _S_opcode_alternative,
+      _S_opcode_backref,
+      _S_opcode_line_begin_assertion,
+      _S_opcode_line_end_assertion,
+      _S_opcode_word_boundary,
+      _S_opcode_subexpr_lookahead,
+      _S_opcode_subexpr_begin,
+      _S_opcode_subexpr_end,
+      _S_opcode_dummy,
+      _S_opcode_match,
+      _S_opcode_accept,
+  };
+
+  struct _State_base
+  {
+    _Opcode      _M_opcode;           // type of outgoing transition
+    _StateIdT    _M_next;             // outgoing transition
+    union // Since they are mutually exclusive.
+    {
+      size_t _M_subexpr;        // for _S_opcode_subexpr_*
+      size_t _M_backref_index;  // for _S_opcode_backref
+      struct
+      {
+	// for _S_opcode_alternative.
+	_StateIdT  _M_quant_index;
+	// for _S_opcode_alternative or _S_opcode_subexpr_lookahead
+	_StateIdT  _M_alt;
+	// for _S_opcode_word_boundary or _S_opcode_subexpr_lookahead or
+	// quantifiers (ungreedy if set true)
+	bool       _M_neg;
+      };
+    };
+
+    explicit _State_base(_Opcode __opcode)
+    : _M_opcode(__opcode), _M_next(_S_invalid_state_id)
+    { }
+
+  protected:
+    ~_State_base() = default;
+
+  public:
+#ifdef _GLIBCXX_DEBUG
+    std::ostream&
+    _M_print(std::ostream& ostr) const;
+
+    // Prints graphviz dot commands for state.
+    std::ostream&
+    _M_dot(std::ostream& __ostr, _StateIdT __id) const;
+#endif
+  };
+
+  template<typename _TraitsT>
+    struct _State : _State_base
+    {
+      typedef _Matcher<typename _TraitsT::char_type> _MatcherT;
+
+      _MatcherT      _M_matches;        // for _S_opcode_match
+
+      explicit _State(_Opcode __opcode) : _State_base(__opcode) { }
+    };
+
+  struct _NFA_base
+  {
+    typedef size_t                              _SizeT;
+    typedef regex_constants::syntax_option_type _FlagT;
+
+    explicit
+    _NFA_base(_FlagT __f)
+    : _M_flags(__f), _M_start_state(0), _M_subexpr_count(0),
+    _M_quant_count(0), _M_has_backref(false)
+    { }
+
+    _NFA_base(_NFA_base&&) = default;
+
+  protected:
+    ~_NFA_base() = default;
+
+  public:
+    _FlagT
+    _M_options() const
+    { return _M_flags; }
+
+    _StateIdT
+    _M_start() const
+    { return _M_start_state; }
+
+    _SizeT
+    _M_sub_count() const
+    { return _M_subexpr_count; }
+
+    std::vector<size_t>       _M_paren_stack;
+    _FlagT                    _M_flags;
+    _StateIdT                 _M_start_state;
+    _SizeT                    _M_subexpr_count;
+    _SizeT                    _M_quant_count;
+    bool                      _M_has_backref;
+  };
+
+  template<typename _TraitsT>
+    struct _NFA
+    : _NFA_base, std::vector<_State<_TraitsT>>
+    {
+      typedef _State<_TraitsT>				_StateT;
+      typedef _Matcher<typename _TraitsT::char_type>	_MatcherT;
+
+      using _NFA_base::_NFA_base;
+
+      // for performance reasons _NFA objects should only be moved not copied
+      _NFA(const _NFA&) = delete;
+      _NFA(_NFA&&) = default;
+
+      _StateIdT
+      _M_insert_accept()
+      {
+	auto __ret = _M_insert_state(_StateT(_S_opcode_accept));
+	return __ret;
+      }
+
+      _StateIdT
+      _M_insert_alt(_StateIdT __next, _StateIdT __alt, bool __neg)
+      {
+	_StateT __tmp(_S_opcode_alternative);
+	// It labels every quantifier to make greedy comparison easier in BFS
+	// approach.
+	__tmp._M_quant_index = this->_M_quant_count++;
+	__tmp._M_next = __next;
+	__tmp._M_alt = __alt;
+	__tmp._M_neg = __neg;
+	return _M_insert_state(std::move(__tmp));
+      }
+
+      _StateIdT
+      _M_insert_matcher(_MatcherT __m)
+      {
+	_StateT __tmp(_S_opcode_match);
+	__tmp._M_matches = std::move(__m);
+	return _M_insert_state(std::move(__tmp));
+      }
+
+      _StateIdT
+      _M_insert_subexpr_begin()
+      {
+	auto __id = this->_M_subexpr_count++;
+	this->_M_paren_stack.push_back(__id);
+	_StateT __tmp(_S_opcode_subexpr_begin);
+	__tmp._M_subexpr = __id;
+	return _M_insert_state(std::move(__tmp));
+      }
+
+      _StateIdT
+      _M_insert_subexpr_end()
+      {
+	_StateT __tmp(_S_opcode_subexpr_end);
+	__tmp._M_subexpr = this->_M_paren_stack.back();
+	this->_M_paren_stack.pop_back();
+	return _M_insert_state(std::move(__tmp));
+      }
+
+      _StateIdT
+      _M_insert_backref(size_t __index);
+
+      _StateIdT
+      _M_insert_line_begin()
+      { return _M_insert_state(_StateT(_S_opcode_line_begin_assertion)); }
+
+      _StateIdT
+      _M_insert_line_end()
+      { return _M_insert_state(_StateT(_S_opcode_line_end_assertion)); }
+
+      _StateIdT
+      _M_insert_word_bound(bool __neg)
+      {
+	_StateT __tmp(_S_opcode_word_boundary);
+	__tmp._M_neg = __neg;
+	return _M_insert_state(std::move(__tmp));
+      }
+
+      _StateIdT
+      _M_insert_lookahead(_StateIdT __alt, bool __neg)
+      {
+	_StateT __tmp(_S_opcode_subexpr_lookahead);
+	__tmp._M_alt = __alt;
+	__tmp._M_neg = __neg;
+	return _M_insert_state(std::move(__tmp));
+      }
+
+      _StateIdT
+      _M_insert_dummy()
+      { return _M_insert_state(_StateT(_S_opcode_dummy)); }
+
+      _StateIdT
+      _M_insert_state(_StateT __s)
+      {
+	this->push_back(std::move(__s));
+	return this->size()-1;
+      }
+
+      // Eliminate dummy node in this NFA to make it compact.
+      void
+      _M_eliminate_dummy();
+
+#ifdef _GLIBCXX_DEBUG
+      std::ostream&
+      _M_dot(std::ostream& __ostr) const;
+#endif
+    };
+
+  /// Describes a sequence of one or more %_State, its current start
+  /// and end(s).  This structure contains fragments of an NFA during
+  /// construction.
+  template<typename _TraitsT>
+    class _StateSeq
+    {
+    public:
+      typedef _NFA<_TraitsT> _RegexT;
+
+    public:
+      _StateSeq(_RegexT& __nfa, _StateIdT __s)
+      : _M_nfa(__nfa), _M_start(__s), _M_end(__s)
+      { }
+
+      _StateSeq(_RegexT& __nfa, _StateIdT __s, _StateIdT __end)
+      : _M_nfa(__nfa), _M_start(__s), _M_end(__end)
+      { }
+
+      // Append a state on *this and change *this to the new sequence.
+      void
+      _M_append(_StateIdT __id)
+      {
+	_M_nfa[_M_end]._M_next = __id;
+	_M_end = __id;
+      }
+
+      // Append a sequence on *this and change *this to the new sequence.
+      void
+      _M_append(const _StateSeq& __s)
+      {
+	_M_nfa[_M_end]._M_next = __s._M_start;
+	_M_end = __s._M_end;
+      }
+
+      // Clones an entire sequence.
+      _StateSeq
+      _M_clone();
+
+    public:
+      _RegexT&  _M_nfa;
+      _StateIdT _M_start;
+      _StateIdT _M_end;
+    };
+
+ //@} regex-detail
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace std
+
+#include <bits/regex_automaton.tcc>
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_automaton.tcc b/gcc-4.9/libstdc++-v3/include/bits/regex_automaton.tcc
new file mode 100644
index 0000000..759b053
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_automaton.tcc
@@ -0,0 +1,234 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_automaton.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#ifdef _GLIBCXX_DEBUG
+  std::ostream&
+  _State_base::_M_print(std::ostream& ostr) const
+  {
+    switch (_M_opcode)
+    {
+      case _S_opcode_alternative:
+	ostr << "alt next=" << _M_next << " alt=" << _M_alt;
+	break;
+      case _S_opcode_subexpr_begin:
+	ostr << "subexpr begin next=" << _M_next << " index=" << _M_subexpr;
+	break;
+      case _S_opcode_subexpr_end:
+	ostr << "subexpr end next=" << _M_next << " index=" << _M_subexpr;
+	break;
+      case _S_opcode_backref:
+	ostr << "backref next=" << _M_next << " index=" << _M_backref_index;
+	break;
+      case _S_opcode_match:
+	ostr << "match next=" << _M_next;
+	break;
+      case _S_opcode_accept:
+	ostr << "accept next=" << _M_next;
+	break;
+      default:
+	ostr << "unknown next=" << _M_next;
+	break;
+    }
+    return ostr;
+  }
+
+  // Prints graphviz dot commands for state.
+  std::ostream&
+  _State_base::_M_dot(std::ostream& __ostr, _StateIdT __id) const
+  {
+    switch (_M_opcode)
+    {
+      case _S_opcode_alternative:
+	__ostr << __id << " [label=\"" << __id << "\\nALT\"];\n"
+	       << __id << " -> " << _M_next
+	       << " [label=\"epsilon\", tailport=\"s\"];\n"
+	       << __id << " -> " << _M_alt
+	       << " [label=\"epsilon\", tailport=\"n\"];\n";
+	break;
+      case _S_opcode_backref:
+	__ostr << __id << " [label=\"" << __id << "\\nBACKREF "
+	       << _M_subexpr << "\"];\n"
+	       << __id << " -> " << _M_next << " [label=\"<match>\"];\n";
+	break;
+      case _S_opcode_line_begin_assertion:
+	__ostr << __id << " [label=\"" << __id << "\\nLINE_BEGIN \"];\n"
+	       << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
+	break;
+      case _S_opcode_line_end_assertion:
+	__ostr << __id << " [label=\"" << __id << "\\nLINE_END \"];\n"
+	       << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
+	break;
+      case _S_opcode_word_boundary:
+	__ostr << __id << " [label=\"" << __id << "\\nWORD_BOUNDRY "
+	       << _M_neg << "\"];\n"
+	       << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
+	break;
+      case _S_opcode_subexpr_lookahead:
+	__ostr << __id << " [label=\"" << __id << "\\nLOOK_AHEAD\"];\n"
+	       << __id << " -> " << _M_next
+	       << " [label=\"epsilon\", tailport=\"s\"];\n"
+	       << __id << " -> " << _M_alt
+	       << " [label=\"<assert>\", tailport=\"n\"];\n";
+	break;
+      case _S_opcode_subexpr_begin:
+	__ostr << __id << " [label=\"" << __id << "\\nSBEGIN "
+	       << _M_subexpr << "\"];\n"
+	       << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
+	break;
+      case _S_opcode_subexpr_end:
+	__ostr << __id << " [label=\"" << __id << "\\nSEND "
+	       << _M_subexpr << "\"];\n"
+	       << __id << " -> " << _M_next << " [label=\"epsilon\"];\n";
+	break;
+      case _S_opcode_dummy:
+	break;
+      case _S_opcode_match:
+	__ostr << __id << " [label=\"" << __id << "\\nMATCH\"];\n"
+	       << __id << " -> " << _M_next << " [label=\"<match>\"];\n";
+	break;
+      case _S_opcode_accept:
+	__ostr << __id << " [label=\"" << __id << "\\nACC\"];\n" ;
+	break;
+      default:
+	_GLIBCXX_DEBUG_ASSERT(false);
+	break;
+    }
+    return __ostr;
+  }
+
+  template<typename _TraitsT>
+    std::ostream&
+    _NFA<_TraitsT>::_M_dot(std::ostream& __ostr) const
+    {
+      __ostr << "digraph _Nfa {\n"
+		"  rankdir=LR;\n";
+      for (size_t __i = 0; __i < this->size(); ++__i)
+	(*this)[__i]._M_dot(__ostr, __i);
+      __ostr << "}\n";
+      return __ostr;
+    }
+#endif
+
+  template<typename _TraitsT>
+    _StateIdT
+    _NFA<_TraitsT>::_M_insert_backref(size_t __index)
+    {
+      // To figure out whether a backref is valid, a stack is used to store
+      // unfinished sub-expressions. For example, when parsing
+      // "(a(b)(c\\1(d)))" at '\\1', _M_subexpr_count is 3, indicating that 3
+      // sub expressions are parsed or partially parsed(in the stack), aka,
+      // "(a..", "(b)" and "(c..").
+      // _M_paren_stack is {1, 3}, for incomplete "(a.." and "(c..". At this
+      // time, "\\2" is valid, but "\\1" and "\\3" are not.
+      if (__index >= _M_subexpr_count)
+	__throw_regex_error(regex_constants::error_backref);
+      for (auto __it : this->_M_paren_stack)
+	if (__index == __it)
+	  __throw_regex_error(regex_constants::error_backref);
+      this->_M_has_backref = true;
+      _StateT __tmp(_S_opcode_backref);
+      __tmp._M_backref_index = __index;
+      return _M_insert_state(std::move(__tmp));
+    }
+
+  template<typename _TraitsT>
+    void
+    _NFA<_TraitsT>::_M_eliminate_dummy()
+    {
+      for (auto& __it : *this)
+	{
+	  while (__it._M_next >= 0 && (*this)[__it._M_next]._M_opcode
+		 == _S_opcode_dummy)
+	    __it._M_next = (*this)[__it._M_next]._M_next;
+	  if (__it._M_opcode == _S_opcode_alternative
+	      || __it._M_opcode == _S_opcode_subexpr_lookahead)
+	    while (__it._M_alt >= 0 && (*this)[__it._M_alt]._M_opcode
+		   == _S_opcode_dummy)
+	      __it._M_alt = (*this)[__it._M_alt]._M_next;
+	}
+    }
+
+  // Just apply DFS on the sequence and re-link their links.
+  template<typename _TraitsT>
+    _StateSeq<_TraitsT>
+    _StateSeq<_TraitsT>::_M_clone()
+    {
+      std::vector<_StateIdT> __m(_M_nfa.size(), -1);
+      std::stack<_StateIdT> __stack;
+      __stack.push(_M_start);
+      while (!__stack.empty())
+	{
+	  auto __u = __stack.top();
+	  __stack.pop();
+	  auto __dup = _M_nfa[__u];
+	  // _M_insert_state() never return -1
+	  auto __id = _M_nfa._M_insert_state(__dup);
+	  __m[__u] = __id;
+	  if (__u == _M_end)
+	    continue;
+	  if (__dup._M_next != _S_invalid_state_id && __m[__dup._M_next] == -1)
+	    __stack.push(__dup._M_next);
+	  if (__dup._M_opcode == _S_opcode_alternative
+	      || __dup._M_opcode == _S_opcode_subexpr_lookahead)
+	    if (__dup._M_alt != _S_invalid_state_id && __m[__dup._M_alt] == -1)
+	      __stack.push(__dup._M_alt);
+	}
+      long __size = static_cast<long>(__m.size());
+      for (long __k = 0; __k < __size; __k++)
+	{
+	  long __v;
+	  if ((__v = __m[__k]) == -1)
+	    continue;
+	  auto& __ref = _M_nfa[__v];
+	  if (__ref._M_next != _S_invalid_state_id)
+	    {
+	      _GLIBCXX_DEBUG_ASSERT(__m[__ref._M_next] != -1);
+	      __ref._M_next = __m[__ref._M_next];
+	    }
+	  if (__ref._M_opcode == _S_opcode_alternative
+	      || __ref._M_opcode == _S_opcode_subexpr_lookahead)
+	    if (__ref._M_alt != _S_invalid_state_id)
+	      {
+		_GLIBCXX_DEBUG_ASSERT(__m[__ref._M_alt] != -1);
+		__ref._M_alt = __m[__ref._M_alt];
+	      }
+	}
+      return _StateSeq(_M_nfa, __m[_M_start], __m[_M_end]);
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_compiler.h b/gcc-4.9/libstdc++-v3/include/bits/regex_compiler.h
new file mode 100644
index 0000000..f5a198f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_compiler.h
@@ -0,0 +1,452 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_compiler.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup regex-detail
+   * @{
+   */
+
+  template<typename, bool, bool>
+    struct _BracketMatcher;
+
+  /**
+   * @brief Builds an NFA from an input iterator interval.
+   *
+   * The %_TraitsT type should fulfill requirements [28.3].
+   */
+  template<typename _TraitsT>
+    class _Compiler
+    {
+    public:
+      typedef typename _TraitsT::char_type        _CharT;
+      typedef const _CharT*                       _IterT;
+      typedef _NFA<_TraitsT>              	  _RegexT;
+      typedef regex_constants::syntax_option_type _FlagT;
+
+      _Compiler(_IterT __b, _IterT __e,
+		const _TraitsT& __traits, _FlagT __flags);
+
+      std::shared_ptr<_RegexT>
+      _M_get_nfa()
+      { return make_shared<_RegexT>(std::move(_M_nfa)); }
+
+    private:
+      typedef _Scanner<_CharT>               _ScannerT;
+      typedef typename _TraitsT::string_type _StringT;
+      typedef typename _ScannerT::_TokenT    _TokenT;
+      typedef _StateSeq<_TraitsT>            _StateSeqT;
+      typedef std::stack<_StateSeqT>         _StackT;
+      typedef std::ctype<_CharT>             _CtypeT;
+
+      // accepts a specific token or returns false.
+      bool
+      _M_match_token(_TokenT __token);
+
+      void
+      _M_disjunction();
+
+      void
+      _M_alternative();
+
+      bool
+      _M_term();
+
+      bool
+      _M_assertion();
+
+      bool
+      _M_quantifier();
+
+      bool
+      _M_atom();
+
+      bool
+      _M_bracket_expression();
+
+      template<bool __icase, bool __collate>
+	void
+	_M_insert_any_matcher_ecma();
+
+      template<bool __icase, bool __collate>
+	void
+	_M_insert_any_matcher_posix();
+
+      template<bool __icase, bool __collate>
+	void
+	_M_insert_char_matcher();
+
+      template<bool __icase, bool __collate>
+	void
+	_M_insert_character_class_matcher();
+
+      template<bool __icase, bool __collate>
+	void
+	_M_insert_bracket_matcher(bool __neg);
+
+      template<bool __icase, bool __collate>
+	void
+	_M_expression_term(_BracketMatcher<_TraitsT, __icase, __collate>&
+			   __matcher);
+
+      int
+      _M_cur_int_value(int __radix);
+
+      bool
+      _M_try_char();
+
+      _StateSeqT
+      _M_pop()
+      {
+	auto ret = _M_stack.top();
+	_M_stack.pop();
+	return ret;
+      }
+
+      _FlagT          _M_flags;
+      const _TraitsT& _M_traits;
+      const _CtypeT&  _M_ctype;
+      _ScannerT       _M_scanner;
+      _RegexT         _M_nfa;
+      _StringT        _M_value;
+      _StackT         _M_stack;
+    };
+
+  template<typename _TraitsT>
+    inline std::shared_ptr<_NFA<_TraitsT>>
+    __compile_nfa(const typename _TraitsT::char_type* __first,
+		  const typename _TraitsT::char_type* __last,
+		  const _TraitsT& __traits,
+		  regex_constants::syntax_option_type __flags)
+    {
+      using _Cmplr = _Compiler<_TraitsT>;
+      return _Cmplr(__first, __last, __traits, __flags)._M_get_nfa();
+    }
+
+  // [28.13.14]
+  template<typename _TraitsT, bool __icase, bool __collate>
+    class _RegexTranslator
+    {
+    public:
+      typedef typename _TraitsT::char_type	      _CharT;
+      typedef typename _TraitsT::string_type	      _StringT;
+      typedef typename std::conditional<__collate,
+					_StringT,
+					_CharT>::type _StrTransT;
+
+      explicit
+      _RegexTranslator(const _TraitsT& __traits)
+      : _M_traits(__traits)
+      { }
+
+      _CharT
+      _M_translate(_CharT __ch) const
+      {
+	if (__icase)
+	  return _M_traits.translate_nocase(__ch);
+	else if (__collate)
+	  return _M_traits.translate(__ch);
+	else
+	  return __ch;
+      }
+
+      _StrTransT
+      _M_transform(_CharT __ch) const
+      {
+	return _M_transform_impl(__ch, typename integral_constant<bool,
+				 __collate>::type());
+      }
+
+    private:
+      _StrTransT
+      _M_transform_impl(_CharT __ch, false_type) const
+      { return __ch; }
+
+      _StrTransT
+      _M_transform_impl(_CharT __ch, true_type) const
+      {
+	_StrTransT __str = _StrTransT(1, _M_translate(__ch));
+	return _M_traits.transform(__str.begin(), __str.end());
+      }
+
+      const _TraitsT& _M_traits;
+    };
+
+  template<typename _TraitsT>
+    class _RegexTranslator<_TraitsT, false, false>
+    {
+    public:
+      typedef typename _TraitsT::char_type _CharT;
+      typedef _CharT                       _StrTransT;
+
+      explicit
+      _RegexTranslator(const _TraitsT& __traits)
+      { }
+
+      _CharT
+      _M_translate(_CharT __ch) const
+      { return __ch; }
+
+      _StrTransT
+      _M_transform(_CharT __ch) const
+      { return __ch; }
+    };
+
+  template<typename _TraitsT, bool __is_ecma, bool __icase, bool __collate>
+    struct _AnyMatcher;
+
+  template<typename _TraitsT, bool __icase, bool __collate>
+    struct _AnyMatcher<_TraitsT, false, __icase, __collate>
+    {
+      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
+      typedef typename _TransT::_CharT                       _CharT;
+
+      explicit
+      _AnyMatcher(const _TraitsT& __traits)
+      : _M_translator(__traits)
+      { }
+
+      bool
+      operator()(_CharT __ch) const
+      {
+	static auto __nul = _M_translator._M_translate('\0');
+	return _M_translator._M_translate(__ch) != __nul;
+      }
+
+      _TransT _M_translator;
+    };
+
+  template<typename _TraitsT, bool __icase, bool __collate>
+    struct _AnyMatcher<_TraitsT, true, __icase, __collate>
+    {
+      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
+      typedef typename _TransT::_CharT                       _CharT;
+
+      explicit
+      _AnyMatcher(const _TraitsT& __traits)
+      : _M_translator(__traits)
+      { }
+
+      bool
+      operator()(_CharT __ch) const
+      { return _M_apply(__ch, typename is_same<_CharT, char>::type()); }
+
+      bool
+      _M_apply(_CharT __ch, true_type) const
+      {
+	auto __c = _M_translator._M_translate(__ch);
+	auto __n = _M_translator._M_translate('\n');
+	auto __r = _M_translator._M_translate('\r');
+	return __c != __n && __c != __r;
+      }
+
+      bool
+      _M_apply(_CharT __ch, false_type) const
+      {
+	auto __c = _M_translator._M_translate(__ch);
+	auto __n = _M_translator._M_translate('\n');
+	auto __r = _M_translator._M_translate('\r');
+	auto __u2028 = _M_translator._M_translate(u'\u2028');
+	auto __u2029 = _M_translator._M_translate(u'\u2029');
+	return __c != __n && __c != __r && __c != __u2028 && __c != __u2029;
+      }
+
+      _TransT _M_translator;
+    };
+
+  template<typename _TraitsT, bool __icase, bool __collate>
+    struct _CharMatcher
+    {
+      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
+      typedef typename _TransT::_CharT                       _CharT;
+
+      _CharMatcher(_CharT __ch, const _TraitsT& __traits)
+      : _M_translator(__traits), _M_ch(_M_translator._M_translate(__ch))
+      { }
+
+      bool
+      operator()(_CharT __ch) const
+      { return _M_ch == _M_translator._M_translate(__ch); }
+
+      _TransT _M_translator;
+      _CharT  _M_ch;
+    };
+
+  /// Matches a character range (bracket expression)
+  template<typename _TraitsT, bool __icase, bool __collate>
+    struct _BracketMatcher
+    {
+    public:
+      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
+      typedef typename _TransT::_CharT                       _CharT;
+      typedef typename _TransT::_StrTransT                   _StrTransT;
+      typedef typename _TraitsT::string_type                 _StringT;
+      typedef typename _TraitsT::char_class_type             _CharClassT;
+
+    public:
+      _BracketMatcher(bool __is_non_matching,
+		      const _TraitsT& __traits)
+      : _M_class_set(0), _M_translator(__traits), _M_traits(__traits),
+      _M_is_non_matching(__is_non_matching)
+#ifdef _GLIBCXX_DEBUG
+      , _M_is_ready(false)
+#endif
+      { }
+
+      bool
+      operator()(_CharT __ch) const
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_is_ready);
+	return _M_apply(__ch, _IsChar());
+      }
+
+      void
+      _M_add_char(_CharT __c)
+      {
+	_M_char_set.push_back(_M_translator._M_translate(__c));
+#ifdef _GLIBCXX_DEBUG
+	_M_is_ready = false;
+#endif
+      }
+
+      void
+      _M_add_collating_element(const _StringT& __s)
+      {
+	auto __st = _M_traits.lookup_collatename(__s.data(),
+						 __s.data() + __s.size());
+	if (__st.empty())
+	  __throw_regex_error(regex_constants::error_collate);
+	_M_char_set.push_back(_M_translator._M_translate(__st[0]));
+#ifdef _GLIBCXX_DEBUG
+	_M_is_ready = false;
+#endif
+      }
+
+      void
+      _M_add_equivalence_class(const _StringT& __s)
+      {
+	auto __st = _M_traits.lookup_collatename(__s.data(),
+						 __s.data() + __s.size());
+	if (__st.empty())
+	  __throw_regex_error(regex_constants::error_collate);
+	__st = _M_traits.transform_primary(__st.data(),
+					   __st.data() + __st.size());
+	_M_equiv_set.push_back(__st);
+#ifdef _GLIBCXX_DEBUG
+	_M_is_ready = false;
+#endif
+      }
+
+      void
+      _M_add_character_class(const _StringT& __s)
+      {
+	auto __mask = _M_traits.lookup_classname(__s.data(),
+						 __s.data() + __s.size(),
+						 __icase);
+	if (__mask == 0)
+	  __throw_regex_error(regex_constants::error_ctype);
+	_M_class_set |= __mask;
+#ifdef _GLIBCXX_DEBUG
+	_M_is_ready = false;
+#endif
+      }
+
+      void
+      _M_make_range(_CharT __l, _CharT __r)
+      {
+	_M_range_set.push_back(make_pair(_M_translator._M_transform(__l),
+				      _M_translator._M_transform(__r)));
+#ifdef _GLIBCXX_DEBUG
+	_M_is_ready = false;
+#endif
+      }
+
+      void
+      _M_ready()
+      {
+	_M_make_cache(_IsChar());
+#ifdef _GLIBCXX_DEBUG
+	_M_is_ready = true;
+#endif
+      }
+
+    private:
+      typedef typename is_same<_CharT, char>::type _IsChar;
+      struct _Dummy { };
+      typedef typename conditional<_IsChar::value,
+				   std::bitset<1 << (8 * sizeof(_CharT))>,
+				   _Dummy>::type _CacheT;
+      typedef typename make_unsigned<_CharT>::type _UnsignedCharT;
+
+    private:
+      bool
+      _M_apply(_CharT __ch, false_type) const;
+
+      bool
+      _M_apply(_CharT __ch, true_type) const
+      { return _M_cache[static_cast<_UnsignedCharT>(__ch)]; }
+
+      void
+      _M_make_cache(true_type)
+      {
+	for (int __i = 0; __i < _M_cache.size(); __i++)
+	  _M_cache[static_cast<_UnsignedCharT>(__i)] =
+	    _M_apply(__i, false_type());
+      }
+
+      void
+      _M_make_cache(false_type)
+      { }
+
+    private:
+      _CacheT                                   _M_cache;
+      std::vector<_CharT>                       _M_char_set;
+      std::vector<_StringT>                     _M_equiv_set;
+      std::vector<pair<_StrTransT, _StrTransT>> _M_range_set;
+      _CharClassT                               _M_class_set;
+      _TransT                                   _M_translator;
+      const _TraitsT&                           _M_traits;
+      bool                                      _M_is_non_matching;
+#ifdef _GLIBCXX_DEBUG
+      bool                                      _M_is_ready;
+#endif
+    };
+
+ //@} regex-detail
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace std
+
+#include <bits/regex_compiler.tcc>
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_compiler.tcc b/gcc-4.9/libstdc++-v3/include/bits/regex_compiler.tcc
new file mode 100644
index 0000000..128dac1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_compiler.tcc
@@ -0,0 +1,539 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_compiler.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+// FIXME make comments doxygen format.
+
+// This compiler refers to "Regular Expression Matching Can Be Simple And Fast"
+// (http://swtch.com/~rsc/regexp/regexp1.html"),
+// but doesn't strictly follow it.
+//
+// When compiling, states are *chained* instead of tree- or graph-constructed.
+// It's more like structured programs: there's if statement and loop statement.
+//
+// For alternative structure(say "a|b"), aka "if statement", two branchs should
+// be constructed. However, these two shall merge to an "end_tag" at the end of
+// this operator:
+//
+//                branch1
+//              /        \
+// => begin_tag            end_tag =>
+//              \        /
+//                branch2
+//
+// This is the difference between this implementation and that in Russ's
+// article.
+//
+// That's why we introduced dummy node here ------ "end_tag" is a dummy node.
+// All dummy node will be eliminated at the end of compiling process.
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _TraitsT>
+    _Compiler<_TraitsT>::
+    _Compiler(_IterT __b, _IterT __e,
+	      const _TraitsT& __traits, _FlagT __flags)
+    : _M_flags((__flags
+		& (regex_constants::ECMAScript
+		   | regex_constants::basic
+		   | regex_constants::extended
+		   | regex_constants::grep
+		   | regex_constants::egrep
+		   | regex_constants::awk))
+	       ? __flags
+	       : __flags | regex_constants::ECMAScript),
+    _M_traits(__traits),
+    _M_ctype(std::use_facet<_CtypeT>(_M_traits.getloc())),
+    _M_scanner(__b, __e, _M_flags, _M_traits.getloc()),
+    _M_nfa(_M_flags)
+    {
+      _StateSeqT __r(_M_nfa, _M_nfa._M_start());
+      __r._M_append(_M_nfa._M_insert_subexpr_begin());
+      this->_M_disjunction();
+      if (!_M_match_token(_ScannerT::_S_token_eof))
+	__throw_regex_error(regex_constants::error_paren);
+      __r._M_append(_M_pop());
+      _GLIBCXX_DEBUG_ASSERT(_M_stack.empty());
+      __r._M_append(_M_nfa._M_insert_subexpr_end());
+      __r._M_append(_M_nfa._M_insert_accept());
+      _M_nfa._M_eliminate_dummy();
+    }
+
+  template<typename _TraitsT>
+    void
+    _Compiler<_TraitsT>::
+    _M_disjunction()
+    {
+      this->_M_alternative();
+      while (_M_match_token(_ScannerT::_S_token_or))
+	{
+	  _StateSeqT __alt1 = _M_pop();
+	  this->_M_alternative();
+	  _StateSeqT __alt2 = _M_pop();
+	  auto __end = _M_nfa._M_insert_dummy();
+	  __alt1._M_append(__end);
+	  __alt2._M_append(__end);
+	  _M_stack.push(_StateSeqT(_M_nfa,
+				   _M_nfa._M_insert_alt(__alt1._M_start,
+							__alt2._M_start, false),
+				   __end));
+	}
+    }
+
+  template<typename _TraitsT>
+    void
+    _Compiler<_TraitsT>::
+    _M_alternative()
+    {
+      if (this->_M_term())
+	{
+	  _StateSeqT __re = _M_pop();
+	  this->_M_alternative();
+	  __re._M_append(_M_pop());
+	  _M_stack.push(__re);
+	}
+      else
+	_M_stack.push(_StateSeqT(_M_nfa, _M_nfa._M_insert_dummy()));
+    }
+
+  template<typename _TraitsT>
+    bool
+    _Compiler<_TraitsT>::
+    _M_term()
+    {
+      if (this->_M_assertion())
+	return true;
+      if (this->_M_atom())
+	{
+	  while (this->_M_quantifier());
+	  return true;
+	}
+      return false;
+    }
+
+  template<typename _TraitsT>
+    bool
+    _Compiler<_TraitsT>::
+    _M_assertion()
+    {
+      if (_M_match_token(_ScannerT::_S_token_line_begin))
+	_M_stack.push(_StateSeqT(_M_nfa, _M_nfa._M_insert_line_begin()));
+      else if (_M_match_token(_ScannerT::_S_token_line_end))
+	_M_stack.push(_StateSeqT(_M_nfa, _M_nfa._M_insert_line_end()));
+      else if (_M_match_token(_ScannerT::_S_token_word_bound))
+	// _M_value[0] == 'n' means it's negtive, say "not word boundary".
+	_M_stack.push(_StateSeqT(_M_nfa, _M_nfa.
+	      _M_insert_word_bound(_M_value[0] == 'n')));
+      else if (_M_match_token(_ScannerT::_S_token_subexpr_lookahead_begin))
+	{
+	  auto __neg = _M_value[0] == 'n';
+	  this->_M_disjunction();
+	  if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
+	    __throw_regex_error(regex_constants::error_paren);
+	  auto __tmp = _M_pop();
+	  __tmp._M_append(_M_nfa._M_insert_accept());
+	  _M_stack.push(
+	      _StateSeqT(
+		_M_nfa,
+		_M_nfa._M_insert_lookahead(__tmp._M_start, __neg)));
+	}
+      else
+	return false;
+      return true;
+    }
+
+  template<typename _TraitsT>
+    bool
+    _Compiler<_TraitsT>::
+    _M_quantifier()
+    {
+      bool __neg = (_M_flags & regex_constants::ECMAScript);
+      auto __init = [this, &__neg]()
+	{
+	  if (_M_stack.empty())
+	    __throw_regex_error(regex_constants::error_badrepeat);
+	  __neg = __neg && _M_match_token(_ScannerT::_S_token_opt);
+	};
+      if (_M_match_token(_ScannerT::_S_token_closure0))
+	{
+	  __init();
+	  auto __e = _M_pop();
+	  _StateSeqT __r(_M_nfa, _M_nfa._M_insert_alt(_S_invalid_state_id,
+						      __e._M_start, __neg));
+	  __e._M_append(__r);
+	  _M_stack.push(__r);
+	}
+      else if (_M_match_token(_ScannerT::_S_token_closure1))
+	{
+	  __init();
+	  auto __e = _M_pop();
+	  __e._M_append(_M_nfa._M_insert_alt(_S_invalid_state_id, __e._M_start,
+					     __neg));
+	  _M_stack.push(__e);
+	}
+      else if (_M_match_token(_ScannerT::_S_token_opt))
+	{
+	  __init();
+	  auto __e = _M_pop();
+	  auto __end = _M_nfa._M_insert_dummy();
+	  _StateSeqT __r(_M_nfa, _M_nfa._M_insert_alt(_S_invalid_state_id,
+						      __e._M_start, __neg));
+	  __e._M_append(__end);
+	  __r._M_append(__end);
+	  _M_stack.push(__r);
+	}
+      else if (_M_match_token(_ScannerT::_S_token_interval_begin))
+	{
+	  if (_M_stack.empty())
+	    __throw_regex_error(regex_constants::error_badrepeat);
+	  if (!_M_match_token(_ScannerT::_S_token_dup_count))
+	    __throw_regex_error(regex_constants::error_badbrace);
+	  _StateSeqT __r(_M_pop());
+	  _StateSeqT __e(_M_nfa, _M_nfa._M_insert_dummy());
+	  long __min_rep = _M_cur_int_value(10);
+	  bool __infi = false;
+	  long __n;
+
+	  // {3
+	  if (_M_match_token(_ScannerT::_S_token_comma))
+	    if (_M_match_token(_ScannerT::_S_token_dup_count)) // {3,7}
+	      __n = _M_cur_int_value(10) - __min_rep;
+	    else
+	      __infi = true;
+	  else
+	    __n = 0;
+	  if (!_M_match_token(_ScannerT::_S_token_interval_end))
+	    __throw_regex_error(regex_constants::error_brace);
+
+	  __neg = __neg && _M_match_token(_ScannerT::_S_token_opt);
+
+	  for (long __i = 0; __i < __min_rep; ++__i)
+	    __e._M_append(__r._M_clone());
+
+	  if (__infi)
+	    {
+	      auto __tmp = __r._M_clone();
+	      _StateSeqT __s(_M_nfa,
+			     _M_nfa._M_insert_alt(_S_invalid_state_id,
+						  __tmp._M_start, __neg));
+	      __tmp._M_append(__s);
+	      __e._M_append(__s);
+	    }
+	  else
+	    {
+	      if (__n < 0)
+		__throw_regex_error(regex_constants::error_badbrace);
+	      auto __end = _M_nfa._M_insert_dummy();
+	      // _M_alt is the "match more" branch, and _M_next is the
+	      // "match less" one. Switch _M_alt and _M_next of all created
+	      // nodes. This is a hacking but IMO works well.
+	      std::stack<_StateIdT> __stack;
+	      for (long __i = 0; __i < __n; ++__i)
+		{
+		  auto __tmp = __r._M_clone();
+		  auto __alt = _M_nfa._M_insert_alt(__tmp._M_start,
+						    __end, __neg);
+		  __stack.push(__alt);
+		  __e._M_append(_StateSeqT(_M_nfa, __alt, __tmp._M_end));
+		}
+	      __e._M_append(__end);
+	      while (!__stack.empty())
+		{
+		  auto& __tmp = _M_nfa[__stack.top()];
+		  __stack.pop();
+		  swap(__tmp._M_next, __tmp._M_alt);
+		}
+	    }
+	  _M_stack.push(__e);
+	}
+      else
+	return false;
+      return true;
+    }
+
+#define __INSERT_REGEX_MATCHER(__func, args...)\
+	do\
+	  if (!(_M_flags & regex_constants::icase))\
+	    if (!(_M_flags & regex_constants::collate))\
+	      __func<false, false>(args);\
+	    else\
+	      __func<false, true>(args);\
+	  else\
+	    if (!(_M_flags & regex_constants::collate))\
+	      __func<true, false>(args);\
+	    else\
+	      __func<true, true>(args);\
+	while (false)
+
+  template<typename _TraitsT>
+    bool
+    _Compiler<_TraitsT>::
+    _M_atom()
+    {
+      if (_M_match_token(_ScannerT::_S_token_anychar))
+	{
+	  if (!(_M_flags & regex_constants::ECMAScript))
+	    __INSERT_REGEX_MATCHER(_M_insert_any_matcher_posix);
+	  else
+	    __INSERT_REGEX_MATCHER(_M_insert_any_matcher_ecma);
+	}
+      else if (_M_try_char())
+	__INSERT_REGEX_MATCHER(_M_insert_char_matcher);
+      else if (_M_match_token(_ScannerT::_S_token_backref))
+	_M_stack.push(_StateSeqT(_M_nfa, _M_nfa.
+				 _M_insert_backref(_M_cur_int_value(10))));
+      else if (_M_match_token(_ScannerT::_S_token_quoted_class))
+	__INSERT_REGEX_MATCHER(_M_insert_character_class_matcher);
+      else if (_M_match_token(_ScannerT::_S_token_subexpr_no_group_begin))
+	{
+	  _StateSeqT __r(_M_nfa, _M_nfa._M_insert_dummy());
+	  this->_M_disjunction();
+	  if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
+	    __throw_regex_error(regex_constants::error_paren);
+	  __r._M_append(_M_pop());
+	  _M_stack.push(__r);
+	}
+      else if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
+	{
+	  _StateSeqT __r(_M_nfa, _M_nfa._M_insert_subexpr_begin());
+	  this->_M_disjunction();
+	  if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
+	    __throw_regex_error(regex_constants::error_paren);
+	  __r._M_append(_M_pop());
+	  __r._M_append(_M_nfa._M_insert_subexpr_end());
+	  _M_stack.push(__r);
+	}
+      else if (!_M_bracket_expression())
+	return false;
+      return true;
+    }
+
+  template<typename _TraitsT>
+    bool
+    _Compiler<_TraitsT>::
+    _M_bracket_expression()
+    {
+      bool __neg =
+	_M_match_token(_ScannerT::_S_token_bracket_neg_begin);
+      if (!(__neg || _M_match_token(_ScannerT::_S_token_bracket_begin)))
+	return false;
+      __INSERT_REGEX_MATCHER(_M_insert_bracket_matcher, __neg);
+      return true;
+    }
+#undef __INSERT_REGEX_MATCHER
+
+  template<typename _TraitsT>
+  template<bool __icase, bool __collate>
+    void
+    _Compiler<_TraitsT>::
+    _M_insert_any_matcher_ecma()
+    {
+      _M_stack.push(_StateSeqT(_M_nfa,
+	_M_nfa._M_insert_matcher
+	  (_AnyMatcher<_TraitsT, true, __icase, __collate>
+	    (_M_traits))));
+    }
+
+  template<typename _TraitsT>
+  template<bool __icase, bool __collate>
+    void
+    _Compiler<_TraitsT>::
+    _M_insert_any_matcher_posix()
+    {
+      _M_stack.push(_StateSeqT(_M_nfa,
+	_M_nfa._M_insert_matcher
+	  (_AnyMatcher<_TraitsT, false, __icase, __collate>
+	    (_M_traits))));
+    }
+
+  template<typename _TraitsT>
+  template<bool __icase, bool __collate>
+    void
+    _Compiler<_TraitsT>::
+    _M_insert_char_matcher()
+    {
+      _M_stack.push(_StateSeqT(_M_nfa,
+	_M_nfa._M_insert_matcher
+	  (_CharMatcher<_TraitsT, __icase, __collate>
+	    (_M_value[0], _M_traits))));
+    }
+
+  template<typename _TraitsT>
+  template<bool __icase, bool __collate>
+    void
+    _Compiler<_TraitsT>::
+    _M_insert_character_class_matcher()
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_value.size() == 1);
+      _BracketMatcher<_TraitsT, __icase, __collate> __matcher
+	(_M_ctype.is(_CtypeT::upper, _M_value[0]), _M_traits);
+      __matcher._M_add_character_class(_M_value);
+      __matcher._M_ready();
+      _M_stack.push(_StateSeqT(_M_nfa,
+	_M_nfa._M_insert_matcher(std::move(__matcher))));
+    }
+
+  template<typename _TraitsT>
+  template<bool __icase, bool __collate>
+    void
+    _Compiler<_TraitsT>::
+    _M_insert_bracket_matcher(bool __neg)
+    {
+      _BracketMatcher<_TraitsT, __icase, __collate> __matcher(__neg, _M_traits);
+      while (!_M_match_token(_ScannerT::_S_token_bracket_end))
+	_M_expression_term(__matcher);
+      __matcher._M_ready();
+      _M_stack.push(_StateSeqT(_M_nfa,
+			       _M_nfa._M_insert_matcher(std::move(__matcher))));
+    }
+
+  template<typename _TraitsT>
+  template<bool __icase, bool __collate>
+    void
+    _Compiler<_TraitsT>::
+    _M_expression_term(_BracketMatcher<_TraitsT, __icase, __collate>& __matcher)
+    {
+      if (_M_match_token(_ScannerT::_S_token_collsymbol))
+	__matcher._M_add_collating_element(_M_value);
+      else if (_M_match_token(_ScannerT::_S_token_equiv_class_name))
+	__matcher._M_add_equivalence_class(_M_value);
+      else if (_M_match_token(_ScannerT::_S_token_char_class_name))
+	__matcher._M_add_character_class(_M_value);
+      else if (_M_try_char()) // [a
+	{
+	  auto __ch = _M_value[0];
+	  if (_M_try_char())
+	    {
+	      if (_M_value[0] == '-') // [a-
+		{
+		  if (_M_try_char()) // [a-z]
+		    {
+		      __matcher._M_make_range(__ch, _M_value[0]);
+		      return;
+		    }
+		  // If the dash is the last character in the bracket
+		  // expression, it is not special.
+		  if (_M_scanner._M_get_token()
+		      != _ScannerT::_S_token_bracket_end)
+		    __throw_regex_error(regex_constants::error_range);
+		}
+	      __matcher._M_add_char(_M_value[0]);
+	    }
+	  __matcher._M_add_char(__ch);
+	}
+      else
+	__throw_regex_error(regex_constants::error_brack);
+    }
+
+  template<typename _TraitsT>
+    bool
+    _Compiler<_TraitsT>::
+    _M_try_char()
+    {
+      bool __is_char = false;
+      if (_M_match_token(_ScannerT::_S_token_oct_num))
+	{
+	  __is_char = true;
+	  _M_value.assign(1, _M_cur_int_value(8));
+	}
+      else if (_M_match_token(_ScannerT::_S_token_hex_num))
+	{
+	  __is_char = true;
+	  _M_value.assign(1, _M_cur_int_value(16));
+	}
+      else if (_M_match_token(_ScannerT::_S_token_ord_char))
+	__is_char = true;
+      return __is_char;
+    }
+
+  template<typename _TraitsT>
+    bool
+    _Compiler<_TraitsT>::
+    _M_match_token(_TokenT token)
+    {
+      if (token == _M_scanner._M_get_token())
+	{
+	  _M_value = _M_scanner._M_get_value();
+	  _M_scanner._M_advance();
+	  return true;
+	}
+      return false;
+    }
+
+  template<typename _TraitsT>
+    int
+    _Compiler<_TraitsT>::
+    _M_cur_int_value(int __radix)
+    {
+      long __v = 0;
+      for (typename _StringT::size_type __i = 0;
+	   __i < _M_value.length(); ++__i)
+	__v =__v * __radix + _M_traits.value(_M_value[__i], __radix);
+      return __v;
+    }
+
+  template<typename _TraitsT, bool __icase, bool __collate>
+    bool
+    _BracketMatcher<_TraitsT, __icase, __collate>::
+    _M_apply(_CharT __ch, false_type) const
+    {
+      bool __ret = false;
+      if (std::find(_M_char_set.begin(), _M_char_set.end(),
+		    _M_translator._M_translate(__ch))
+	  != _M_char_set.end())
+	__ret = true;
+      else
+	{
+	  auto __s = _M_translator._M_transform(__ch);
+	  for (auto& __it : _M_range_set)
+	    if (__it.first <= __s && __s <= __it.second)
+	      {
+		__ret = true;
+		break;
+	      }
+	  if (_M_traits.isctype(__ch, _M_class_set))
+	    __ret = true;
+	  else if (std::find(_M_equiv_set.begin(), _M_equiv_set.end(),
+			     _M_traits.transform_primary(&__ch, &__ch+1))
+		   != _M_equiv_set.end())
+	    __ret = true;
+	}
+      if (_M_is_non_matching)
+	return !__ret;
+      else
+	return __ret;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_constants.h b/gcc-4.9/libstdc++-v3/include/bits/regex_constants.h
new file mode 100644
index 0000000..b5705ba
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_constants.h
@@ -0,0 +1,386 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_constants.h
+ *  @brief Constant definitions for the std regex library.
+ *
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+/**
+ * @defgroup regex Regular Expressions
+ *
+ * A facility for performing regular expression pattern matching.
+ * @{
+ */
+
+/**
+ * @namespace std::regex_constants
+ * @brief ISO C++-0x entities sub namespace for regex.
+ */
+namespace regex_constants
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @name 5.1 Regular Expression Syntax Options
+   */
+  //@{
+  enum __syntax_option
+  {
+    _S_icase,
+    _S_nosubs,
+    _S_optimize,
+    _S_collate,
+    _S_ECMAScript,
+    _S_basic,
+    _S_extended,
+    _S_awk,
+    _S_grep,
+    _S_egrep,
+    _S_syntax_last
+  };
+
+  /**
+   * @brief This is a bitmask type indicating how to interpret the regex.
+   *
+   * The @c syntax_option_type is implementation defined but it is valid to
+   * perform bitwise operations on these values and expect the right thing to
+   * happen.
+   *
+   * A valid value of type syntax_option_type shall have exactly one of the
+   * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
+   * %set.
+   */
+  enum syntax_option_type : unsigned int
+  {
+    /**
+     * Specifies that the matching of regular expressions against a character
+     * sequence shall be performed without regard to case.
+     */
+    icase      = 1 << _S_icase,
+
+    /**
+     * Specifies that when a regular expression is matched against a character
+     * container sequence, no sub-expression matches are to be stored in the
+     * supplied match_results structure.
+     */
+    nosubs     = 1 << _S_nosubs,
+
+    /**
+     * Specifies that the regular expression engine should pay more attention to
+     * the speed with which regular expressions are matched, and less to the
+     * speed with which regular expression objects are constructed. Otherwise
+     * it has no detectable effect on the program output.
+     */
+    optimize   = 1 << _S_optimize,
+
+    /**
+     * Specifies that character ranges of the form [a-b] should be locale
+     * sensitive.
+     */
+    collate    = 1 << _S_collate,
+
+    /**
+     * Specifies that the grammar recognized by the regular expression engine is
+     * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
+     * Language Specification, Standard Ecma-262, third edition, 1999], as
+     * modified in section [28.13].  This grammar is similar to that defined
+     * in the PERL scripting language but extended with elements found in the
+     * POSIX regular expression grammar.
+     */
+    ECMAScript = 1 << _S_ECMAScript,
+
+    /**
+     * Specifies that the grammar recognized by the regular expression engine is
+     * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
+     * Portable Operating System Interface (POSIX), Base Definitions and
+     * Headers, Section 9, Regular Expressions [IEEE, Information Technology --
+     * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+     */
+    basic      = 1 << _S_basic,
+
+    /**
+     * Specifies that the grammar recognized by the regular expression engine is
+     * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
+     * Portable Operating System Interface (POSIX), Base Definitions and
+     * Headers, Section 9, Regular Expressions.
+     */
+    extended   = 1 << _S_extended,
+
+    /**
+     * Specifies that the grammar recognized by the regular expression engine is
+     * that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
+     * identical to syntax_option_type extended, except that C-style escape
+     * sequences are supported.  These sequences are:
+     * \\\\, \\a, \\b, \\f, \\n, \\r, \\t , \\v, \\&apos,, &apos,,
+     * and \\ddd (where ddd is one, two, or three octal digits).
+     */
+    awk        = 1 << _S_awk,
+
+    /**
+     * Specifies that the grammar recognized by the regular expression engine is
+     * that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
+     * identical to syntax_option_type basic, except that newlines are treated
+     * as whitespace.
+     */
+    grep       = 1 << _S_grep,
+
+    /**
+     * Specifies that the grammar recognized by the regular expression engine is
+     * that used by POSIX utility grep when given the -E option in
+     * IEEE Std 1003.1-2001.  This option is identical to syntax_option_type
+     * extended, except that newlines are treated as whitespace.
+     */
+    egrep      = 1 << _S_egrep,
+  };
+
+  constexpr inline syntax_option_type
+  operator&(syntax_option_type __a, syntax_option_type __b)
+  {
+    return (syntax_option_type)(static_cast<unsigned int>(__a)
+				& static_cast<unsigned int>(__b));
+  }
+
+  constexpr inline syntax_option_type
+  operator|(syntax_option_type __a, syntax_option_type __b)
+  {
+    return (syntax_option_type)(static_cast<unsigned int>(__a)
+				| static_cast<unsigned int>(__b));
+  }
+
+  constexpr inline syntax_option_type
+  operator^(syntax_option_type __a, syntax_option_type __b)
+  {
+    return (syntax_option_type)(static_cast<unsigned int>(__a)
+				^ static_cast<unsigned int>(__b));
+  }
+
+  constexpr inline syntax_option_type
+  operator~(syntax_option_type __a)
+  { return (syntax_option_type)(~static_cast<unsigned int>(__a)); }
+
+  inline syntax_option_type&
+  operator&=(syntax_option_type& __a, syntax_option_type __b)
+  { return __a = __a & __b; }
+
+  inline syntax_option_type&
+  operator|=(syntax_option_type& __a, syntax_option_type __b)
+  { return __a = __a | __b; }
+
+  inline syntax_option_type&
+  operator^=(syntax_option_type& __a, syntax_option_type __b)
+  { return __a = __a ^ __b; }
+
+  //@}
+
+  /**
+   * @name 5.2 Matching Rules
+   *
+   * Matching a regular expression against a sequence of characters [first,
+   * last) proceeds according to the rules of the grammar specified for the
+   * regular expression object, modified according to the effects listed
+   * below for any bitmask elements set.
+   *
+   */
+  //@{
+
+  enum __match_flag
+  {
+    _S_not_bol,
+    _S_not_eol,
+    _S_not_bow,
+    _S_not_eow,
+    _S_any,
+    _S_not_null,
+    _S_continuous,
+    _S_prev_avail,
+    _S_sed,
+    _S_no_copy,
+    _S_first_only,
+    _S_match_flag_last
+  };
+
+  /**
+   * @brief This is a bitmask type indicating regex matching rules.
+   *
+   * The @c match_flag_type is implementation defined but it is valid to
+   * perform bitwise operations on these values and expect the right thing to
+   * happen.
+   */
+  enum match_flag_type : unsigned int
+  {
+    /**
+     * The default matching rules.
+     */
+    match_default     = 0,
+
+    /**
+     * The first character in the sequence [first, last) is treated as though it
+     * is not at the beginning of a line, so the character (^) in the regular
+     * expression shall not match [first, first).
+     */
+    match_not_bol     = 1 << _S_not_bol,
+
+    /**
+     * The last character in the sequence [first, last) is treated as though it
+     * is not at the end of a line, so the character ($) in the regular
+     * expression shall not match [last, last).
+     */
+    match_not_eol     = 1 << _S_not_eol,
+
+    /**
+     * The expression \\b is not matched against the sub-sequence
+     * [first,first).
+     */
+    match_not_bow     = 1 << _S_not_bow,
+
+    /**
+     * The expression \\b should not be matched against the sub-sequence
+     * [last,last).
+     */
+    match_not_eow     = 1 << _S_not_eow,
+
+    /**
+     * If more than one match is possible then any match is an acceptable
+     * result.
+     */
+    match_any         = 1 << _S_any,
+
+    /**
+     * The expression does not match an empty sequence.
+     */
+    match_not_null    = 1 << _S_not_null,
+
+    /**
+     * The expression only matches a sub-sequence that begins at first .
+     */
+    match_continuous  = 1 << _S_continuous,
+
+    /**
+     * --first is a valid iterator position.  When this flag is set then the
+     * flags match_not_bol and match_not_bow are ignored by the regular
+     * expression algorithms 28.11 and iterators 28.12.
+     */
+    match_prev_avail  = 1 << _S_prev_avail,
+
+    /**
+     * When a regular expression match is to be replaced by a new string, the
+     * new string is constructed using the rules used by the ECMAScript replace
+     * function in ECMA- 262 [Ecma International, ECMAScript Language
+     * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
+     * String.prototype.replace. In addition, during search and replace
+     * operations all non-overlapping occurrences of the regular expression
+     * are located and replaced, and sections of the input that did not match
+     * the expression are copied unchanged to the output string.
+     *
+     * Format strings (from ECMA-262 [15.5.4.11]):
+     * @li $$  The dollar-sign itself ($)
+     * @li $&  The matched substring.
+     * @li $`  The portion of @a string that precedes the matched substring.
+     *         This would be match_results::prefix().
+     * @li $'  The portion of @a string that follows the matched substring.
+     *         This would be match_results::suffix().
+     * @li $n  The nth capture, where n is in [1,9] and $n is not followed by a
+     *         decimal digit.  If n <= match_results::size() and the nth capture
+     *         is undefined, use the empty string instead.  If n >
+     *         match_results::size(), the result is implementation-defined.
+     * @li $nn The nnth capture, where nn is a two-digit decimal number on
+     *         [01, 99].  If nn <= match_results::size() and the nth capture is
+     *         undefined, use the empty string instead. If
+     *         nn > match_results::size(), the result is implementation-defined.
+     */
+    format_default    = 0,
+
+    /**
+     * When a regular expression match is to be replaced by a new string, the
+     * new string is constructed using the rules used by the POSIX sed utility
+     * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
+     * Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+     */
+    format_sed        = 1 << _S_sed,
+
+    /**
+     * During a search and replace operation, sections of the character
+     * container sequence being searched that do not match the regular
+     * expression shall not be copied to the output string.
+     */
+    format_no_copy    = 1 << _S_no_copy,
+
+    /**
+     * When specified during a search and replace operation, only the first
+     * occurrence of the regular expression shall be replaced.
+     */
+    format_first_only = 1 << _S_first_only,
+  };
+
+  constexpr inline match_flag_type
+  operator&(match_flag_type __a, match_flag_type __b)
+  {
+    return (match_flag_type)(static_cast<unsigned int>(__a)
+				& static_cast<unsigned int>(__b));
+  }
+
+  constexpr inline match_flag_type
+  operator|(match_flag_type __a, match_flag_type __b)
+  {
+    return (match_flag_type)(static_cast<unsigned int>(__a)
+				| static_cast<unsigned int>(__b));
+  }
+
+  constexpr inline match_flag_type
+  operator^(match_flag_type __a, match_flag_type __b)
+  {
+    return (match_flag_type)(static_cast<unsigned int>(__a)
+				^ static_cast<unsigned int>(__b));
+  }
+
+  constexpr inline match_flag_type
+  operator~(match_flag_type __a)
+  { return (match_flag_type)(~static_cast<unsigned int>(__a)); }
+
+  inline match_flag_type&
+  operator&=(match_flag_type& __a, match_flag_type __b)
+  { return __a = __a & __b; }
+
+  inline match_flag_type&
+  operator|=(match_flag_type& __a, match_flag_type __b)
+  { return __a = __a | __b; }
+
+  inline match_flag_type&
+  operator^=(match_flag_type& __a, match_flag_type __b)
+  { return __a = __a ^ __b; }
+
+  //@}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace regex_constants
+
+/* @} */ // group regex
+} // namespace std
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_error.h b/gcc-4.9/libstdc++-v3/include/bits/regex_error.h
new file mode 100644
index 0000000..58dbeb1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_error.h
@@ -0,0 +1,166 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file bits/regex_error.h
+ * @brief Error and exception objects for the std regex library.
+ *
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+/**
+ * @addtogroup regex
+ * @{
+ */
+
+namespace regex_constants
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @name 5.3 Error Types
+   */
+  //@{
+
+  enum error_type
+    {
+      _S_error_collate,
+      _S_error_ctype,
+      _S_error_escape,
+      _S_error_backref,
+      _S_error_brack,
+      _S_error_paren,
+      _S_error_brace,
+      _S_error_badbrace,
+      _S_error_range,
+      _S_error_space,
+      _S_error_badrepeat,
+      _S_error_complexity,
+      _S_error_stack,
+    };
+
+  /** The expression contained an invalid collating element name. */
+  constexpr error_type error_collate(_S_error_collate);
+
+  /** The expression contained an invalid character class name. */
+  constexpr error_type error_ctype(_S_error_ctype);
+
+  /**
+   * The expression contained an invalid escaped character, or a trailing
+   * escape.
+   */
+  constexpr error_type error_escape(_S_error_escape);
+
+  /** The expression contained an invalid back reference. */
+  constexpr error_type error_backref(_S_error_backref);
+
+  /** The expression contained mismatched [ and ]. */
+  constexpr error_type error_brack(_S_error_brack);
+
+  /** The expression contained mismatched ( and ). */
+  constexpr error_type error_paren(_S_error_paren);
+
+  /** The expression contained mismatched { and } */
+  constexpr error_type error_brace(_S_error_brace);
+
+  /** The expression contained an invalid range in a {} expression. */
+  constexpr error_type error_badbrace(_S_error_badbrace);
+
+  /**
+   * The expression contained an invalid character range,
+   * such as [b-a] in most encodings.
+   */
+  constexpr error_type error_range(_S_error_range);
+
+  /**
+   * There was insufficient memory to convert the expression into a
+   * finite state machine.
+   */
+  constexpr error_type error_space(_S_error_space);
+
+  /**
+   * One of <em>*?+{</em> was not preceded by a valid regular expression.
+   */
+  constexpr error_type error_badrepeat(_S_error_badrepeat);
+
+  /**
+   * The complexity of an attempted match against a regular expression
+   * exceeded a pre-set level.
+   */
+  constexpr error_type error_complexity(_S_error_complexity);
+
+  /**
+   * There was insufficient memory to determine whether the
+   * regular expression could match the specified character sequence.
+   */
+  constexpr error_type error_stack(_S_error_stack);
+
+  //@}
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace regex_constants
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // [7.8] Class regex_error
+  /**
+   * @brief A regular expression exception class.
+   * @ingroup exceptions
+   *
+   * The regular expression library throws objects of this class on error.
+   */
+  class regex_error : public std::runtime_error
+  {
+    regex_constants::error_type _M_code;
+
+  public:
+    /**
+     * @brief Constructs a regex_error object.
+     *
+     * @param __ecode the regex error code.
+     */
+    explicit
+    regex_error(regex_constants::error_type __ecode);
+
+    virtual ~regex_error() throw();
+
+    /**
+     * @brief Gets the regex error code.
+     *
+     * @returns the regex error code.
+     */
+    regex_constants::error_type
+    code() const
+    { return _M_code; }
+  };
+
+  //@} // group regex
+
+  void
+  __throw_regex_error(regex_constants::error_type __ecode);
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_executor.h b/gcc-4.9/libstdc++-v3/include/bits/regex_executor.h
new file mode 100644
index 0000000..708c78e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_executor.h
@@ -0,0 +1,167 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_executor.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+// FIXME convert comments to doxygen format.
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup regex-detail
+   * @{
+   */
+
+  /**
+   * @brief Takes a regex and an input string in and
+   * do the matching.
+   *
+   * The %_Executor class has two modes: DFS mode and BFS mode, controlled
+   * by the template parameter %__dfs_mode.
+   */
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+	   bool __dfs_mode>
+    class _Executor
+    {
+    public:
+      typedef typename iterator_traits<_BiIter>::value_type _CharT;
+      typedef basic_regex<_CharT, _TraitsT>                 _RegexT;
+      typedef std::vector<sub_match<_BiIter>, _Alloc>       _ResultsVec;
+      typedef regex_constants::match_flag_type              _FlagT;
+      typedef typename _TraitsT::char_class_type            _ClassT;
+      typedef _NFA<_TraitsT>                                _NFAT;
+
+    public:
+      _Executor(_BiIter         __begin,
+		_BiIter         __end,
+		_ResultsVec&    __results,
+		const _RegexT&  __re,
+		_FlagT          __flags)
+      : _M_begin(__begin),
+      _M_end(__end),
+      _M_re(__re),
+      _M_nfa(*__re._M_automaton),
+      _M_results(__results),
+      _M_match_queue(__dfs_mode ? nullptr
+		     : new vector<pair<_StateIdT, _ResultsVec>>()),
+      _M_visited(__dfs_mode ? nullptr : new vector<bool>(_M_nfa.size())),
+      _M_flags((__flags & regex_constants::match_prev_avail)
+	       ? (__flags
+		  & ~regex_constants::match_not_bol
+		  & ~regex_constants::match_not_bow)
+	       : __flags),
+      _M_start_state(_M_nfa._M_start())
+      { }
+
+      // Set matched when string exactly match the pattern.
+      bool
+      _M_match()
+      {
+	_M_current = _M_begin;
+	return _M_main<true>();
+      }
+
+      // Set matched when some prefix of the string matches the pattern.
+      bool
+      _M_search_from_first()
+      {
+	_M_current = _M_begin;
+	return _M_main<false>();
+      }
+
+      bool
+      _M_search();
+
+    private:
+      template<bool __match_mode>
+	void
+	_M_dfs(_StateIdT __start);
+
+      template<bool __match_mode>
+	bool
+	_M_main();
+
+      bool
+      _M_is_word(_CharT __ch) const
+      {
+	static const _CharT __s[2] = { 'w' };
+	return _M_re._M_traits.isctype
+	  (__ch, _M_re._M_traits.lookup_classname(__s, __s+1));
+      }
+
+      bool
+      _M_at_begin() const
+      {
+	return _M_current == _M_begin
+	  && !(_M_flags & (regex_constants::match_not_bol
+			   | regex_constants::match_prev_avail));
+      }
+
+      bool
+      _M_at_end() const
+      {
+	return _M_current == _M_end
+	  && !(_M_flags & regex_constants::match_not_eol);
+      }
+
+      bool
+      _M_word_boundary(_State<_TraitsT> __state) const;
+
+      bool
+      _M_lookahead(_State<_TraitsT> __state);
+
+    public:
+      _ResultsVec                                           _M_cur_results;
+      _BiIter                                               _M_current;
+      const _BiIter                                         _M_begin;
+      const _BiIter                                         _M_end;
+      const _RegexT&                                        _M_re;
+      const _NFAT&                                          _M_nfa;
+      _ResultsVec&                                          _M_results;
+      // Used in BFS, saving states that need to be considered for the next
+      // character.
+      std::unique_ptr<vector<pair<_StateIdT, _ResultsVec>>> _M_match_queue;
+      // Used in BFS, indicating that which state is already visited.
+      std::unique_ptr<vector<bool>>                         _M_visited;
+      _FlagT                                                _M_flags;
+      // To record current solution.
+      _StateIdT                                             _M_start_state;
+      // Do we have a solution so far?
+      bool                                                  _M_has_sol;
+    };
+
+ //@} regex-detail
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace std
+
+#include <bits/regex_executor.tcc>
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_executor.tcc b/gcc-4.9/libstdc++-v3/include/bits/regex_executor.tcc
new file mode 100644
index 0000000..68a5e04
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_executor.tcc
@@ -0,0 +1,374 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_executor.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+    bool __dfs_mode>
+    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_search()
+    {
+      if (_M_flags & regex_constants::match_continuous)
+	return _M_search_from_first();
+      auto __cur = _M_begin;
+      do
+	{
+	  _M_current = __cur;
+	  if (_M_main<false>())
+	    return true;
+	}
+      // Continue when __cur == _M_end
+      while (__cur++ != _M_end);
+      return false;
+    }
+
+  // This function operates in different modes, DFS mode or BFS mode, indicated
+  // by template parameter __dfs_mode. See _M_main for details.
+  //
+  // ------------------------------------------------------------
+  //
+  // DFS mode:
+  //
+  // It applies a Depth-First-Search (aka backtracking) on given NFA and input
+  // string.
+  // At the very beginning the executor stands in the start state, then it tries
+  // every possible state transition in current state recursively. Some state
+  // transitions consume input string, say, a single-char-matcher or a
+  // back-reference matcher; some don't, like assertion or other anchor nodes.
+  // When the input is exhausted and/or the current state is an accepting state,
+  // the whole executor returns true.
+  //
+  // TODO: This approach is exponentially slow for certain input.
+  //       Try to compile the NFA to a DFA.
+  //
+  // Time complexity: \Omega(match_length), O(2^(_M_nfa.size()))
+  // Space complexity: \theta(match_results.size() + match_length)
+  //
+  // ------------------------------------------------------------
+  //
+  // BFS mode:
+  //
+  // Russ Cox's article (http://swtch.com/~rsc/regexp/regexp1.html)
+  // explained this algorithm clearly.
+  //
+  // It first computes epsilon closure (states that can be achieved without
+  // consuming characters) for every state that's still matching,
+  // using the same DFS algorithm, but doesn't re-enter states (find a true in
+  // _M_visited), nor follows _S_opcode_match.
+  //
+  // Then apply DFS using every _S_opcode_match (in _M_match_queue) as the start
+  // state.
+  //
+  // It significantly reduces potential duplicate states, so has a better
+  // upper bound; but it requires more overhead.
+  //
+  // Time complexity: \Omega(match_length * match_results.size())
+  //                  O(match_length * _M_nfa.size() * match_results.size())
+  // Space complexity: \Omega(_M_nfa.size() + match_results.size())
+  //                   O(_M_nfa.size() * match_results.size())
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+    bool __dfs_mode>
+  template<bool __match_mode>
+    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_main()
+    {
+      if (__dfs_mode)
+	{
+	  _M_has_sol = false;
+	  _M_cur_results = _M_results;
+	  _M_dfs<__match_mode>(_M_start_state);
+	  return _M_has_sol;
+	}
+      else
+	{
+	  _M_match_queue->push_back(make_pair(_M_start_state, _M_results));
+	  bool __ret = false;
+	  while (1)
+	    {
+	      _M_has_sol = false;
+	      if (_M_match_queue->empty())
+		break;
+	      _M_visited->assign(_M_visited->size(), false);
+	      auto _M_old_queue = std::move(*_M_match_queue);
+	      for (auto __task : _M_old_queue)
+		{
+		  _M_cur_results = __task.second;
+		  _M_dfs<__match_mode>(__task.first);
+		}
+	      if (!__match_mode)
+		__ret |= _M_has_sol;
+	      if (_M_current == _M_end)
+		break;
+	      ++_M_current;
+	    }
+	  if (__match_mode)
+	    __ret = _M_has_sol;
+	  return __ret;
+	}
+    }
+
+  // Return whether now match the given sub-NFA.
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+    bool __dfs_mode>
+    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_lookahead(_State<_TraitsT> __state)
+    {
+      _ResultsVec __what(_M_cur_results.size());
+      auto __sub = std::unique_ptr<_Executor>(new _Executor(_M_current,
+							    _M_end,
+							    __what,
+							    _M_re,
+							    _M_flags));
+      __sub->_M_start_state = __state._M_alt;
+      if (__sub->_M_search_from_first())
+	{
+	  for (size_t __i = 0; __i < __what.size(); __i++)
+	    if (__what[__i].matched)
+	      _M_cur_results[__i] = __what[__i];
+	  return true;
+	}
+      return false;
+    }
+
+  // TODO: Use a function vector to dispatch, instead of using switch-case.
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+    bool __dfs_mode>
+  template<bool __match_mode>
+    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_dfs(_StateIdT __i)
+    {
+      if (!__dfs_mode)
+	{
+	  if ((*_M_visited)[__i])
+	    return;
+	  (*_M_visited)[__i] = true;
+	}
+
+      const auto& __state = _M_nfa[__i];
+      // Every change on _M_cur_results and _M_current will be rolled back after
+      // finishing the recursion step.
+      switch (__state._M_opcode)
+	{
+	// _M_alt branch is "match once more", while _M_next is "get me out
+	// of this quantifier". Executing _M_next first or _M_alt first don't
+	// mean the same thing, and we need to choose the correct order under
+	// given greedy mode.
+	case _S_opcode_alternative:
+	  // Greedy.
+	  if (!__state._M_neg)
+	    {
+	      // "Once more" is preferred in greedy mode.
+	      _M_dfs<__match_mode>(__state._M_alt);
+	      // If it's DFS executor and already accepted, we're done.
+	      if (!__dfs_mode || !_M_has_sol)
+		_M_dfs<__match_mode>(__state._M_next);
+	    }
+	  else // Non-greedy mode
+	    {
+	      if (__dfs_mode)
+		{
+		  // vice-versa.
+		  _M_dfs<__match_mode>(__state._M_next);
+		  if (!_M_has_sol)
+		    _M_dfs<__match_mode>(__state._M_alt);
+		}
+	      else
+		{
+		  // DON'T attempt anything, because there's already another
+		  // state with higher priority accepted. This state cannot be
+		  // better by attempting its next node.
+		  if (!_M_has_sol)
+		    {
+		      _M_dfs<__match_mode>(__state._M_next);
+		      // DON'T attempt anything if it's already accepted. An
+		      // accepted state *must* be better than a solution that
+		      // matches a non-greedy quantifier one more time.
+		      if (!_M_has_sol)
+			_M_dfs<__match_mode>(__state._M_alt);
+		    }
+		}
+	    }
+	  break;
+	case _S_opcode_subexpr_begin:
+	  // If there's nothing changed since last visit, do NOT continue.
+	  // This prevents the executor from get into infinite loop when using
+	  // "()*" to match "".
+	  if (!_M_cur_results[__state._M_subexpr].matched
+	      || _M_cur_results[__state._M_subexpr].first != _M_current)
+	    {
+	      auto& __res = _M_cur_results[__state._M_subexpr];
+	      auto __back = __res.first;
+	      __res.first = _M_current;
+	      _M_dfs<__match_mode>(__state._M_next);
+	      __res.first = __back;
+	    }
+	  break;
+	case _S_opcode_subexpr_end:
+	  if (_M_cur_results[__state._M_subexpr].second != _M_current
+	      || _M_cur_results[__state._M_subexpr].matched != true)
+	    {
+	      auto& __res = _M_cur_results[__state._M_subexpr];
+	      auto __back = __res;
+	      __res.second = _M_current;
+	      __res.matched = true;
+	      _M_dfs<__match_mode>(__state._M_next);
+	      __res = __back;
+	    }
+	  else
+	    _M_dfs<__match_mode>(__state._M_next);
+	  break;
+	case _S_opcode_line_begin_assertion:
+	  if (_M_at_begin())
+	    _M_dfs<__match_mode>(__state._M_next);
+	  break;
+	case _S_opcode_line_end_assertion:
+	  if (_M_at_end())
+	    _M_dfs<__match_mode>(__state._M_next);
+	  break;
+	case _S_opcode_word_boundary:
+	  if (_M_word_boundary(__state) == !__state._M_neg)
+	    _M_dfs<__match_mode>(__state._M_next);
+	  break;
+	// Here __state._M_alt offers a single start node for a sub-NFA.
+	// We recursively invoke our algorithm to match the sub-NFA.
+	case _S_opcode_subexpr_lookahead:
+	  if (_M_lookahead(__state) == !__state._M_neg)
+	    _M_dfs<__match_mode>(__state._M_next);
+	  break;
+	case _S_opcode_match:
+	  if (__dfs_mode)
+	    {
+	      if (_M_current != _M_end && __state._M_matches(*_M_current))
+		{
+		  ++_M_current;
+		  _M_dfs<__match_mode>(__state._M_next);
+		  --_M_current;
+		}
+	    }
+	  else
+	    if (__state._M_matches(*_M_current))
+	      _M_match_queue->push_back(make_pair(__state._M_next,
+						  _M_cur_results));
+	  break;
+	// First fetch the matched result from _M_cur_results as __submatch;
+	// then compare it with
+	// (_M_current, _M_current + (__submatch.second - __submatch.first)).
+	// If matched, keep going; else just return and try another state.
+	case _S_opcode_backref:
+	  {
+	    _GLIBCXX_DEBUG_ASSERT(__dfs_mode);
+	    auto& __submatch = _M_cur_results[__state._M_backref_index];
+	    if (!__submatch.matched)
+	      break;
+	    auto __last = _M_current;
+	    for (auto __tmp = __submatch.first;
+		 __last != _M_end && __tmp != __submatch.second;
+		 ++__tmp)
+	      ++__last;
+	    if (_M_re._M_traits.transform(__submatch.first,
+						__submatch.second)
+		== _M_re._M_traits.transform(_M_current, __last))
+	      {
+		if (__last != _M_current)
+		  {
+		    auto __backup = _M_current;
+		    _M_current = __last;
+		    _M_dfs<__match_mode>(__state._M_next);
+		    _M_current = __backup;
+		  }
+		else
+		  _M_dfs<__match_mode>(__state._M_next);
+	      }
+	  }
+	  break;
+	case _S_opcode_accept:
+	  if (__dfs_mode)
+	    {
+	      _GLIBCXX_DEBUG_ASSERT(!_M_has_sol);
+	      if (__match_mode)
+		_M_has_sol = _M_current == _M_end;
+	      else
+		_M_has_sol = true;
+	      if (_M_current == _M_begin
+		  && (_M_flags & regex_constants::match_not_null))
+		_M_has_sol = false;
+	      if (_M_has_sol)
+		_M_results = _M_cur_results;
+	    }
+	  else
+	    {
+	      if (_M_current == _M_begin
+		  && (_M_flags & regex_constants::match_not_null))
+		break;
+	      if (!__match_mode || _M_current == _M_end)
+		if (!_M_has_sol)
+		  {
+		    _M_has_sol = true;
+		    _M_results = _M_cur_results;
+		  }
+	    }
+	  break;
+	default:
+	  _GLIBCXX_DEBUG_ASSERT(false);
+	}
+    }
+
+  // Return whether now is at some word boundary.
+  template<typename _BiIter, typename _Alloc, typename _TraitsT,
+    bool __dfs_mode>
+    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
+    _M_word_boundary(_State<_TraitsT> __state) const
+    {
+      // By definition.
+      bool __ans = false;
+      auto __pre = _M_current;
+      --__pre;
+      if (!(_M_at_begin() && _M_at_end()))
+	{
+	  if (_M_at_begin())
+	    __ans = _M_is_word(*_M_current)
+	      && !(_M_flags & regex_constants::match_not_bow);
+	  else if (_M_at_end())
+	    __ans = _M_is_word(*__pre)
+	      && !(_M_flags & regex_constants::match_not_eow);
+	  else
+	    __ans = _M_is_word(*_M_current)
+	      != _M_is_word(*__pre);
+	}
+      return __ans;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_scanner.h b/gcc-4.9/libstdc++-v3/include/bits/regex_scanner.h
new file mode 100644
index 0000000..6627db9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_scanner.h
@@ -0,0 +1,263 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_scanner.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup regex-detail
+   * @{
+   */
+
+  struct _ScannerBase
+  {
+  public:
+    /// Token types returned from the scanner.
+    enum _TokenT
+    {
+      _S_token_anychar,
+      _S_token_ord_char,
+      _S_token_oct_num,
+      _S_token_hex_num,
+      _S_token_backref,
+      _S_token_subexpr_begin,
+      _S_token_subexpr_no_group_begin,
+      _S_token_subexpr_lookahead_begin, // neg if _M_value[0] == 'n'
+      _S_token_subexpr_end,
+      _S_token_bracket_begin,
+      _S_token_bracket_neg_begin,
+      _S_token_bracket_end,
+      _S_token_interval_begin,
+      _S_token_interval_end,
+      _S_token_quoted_class,
+      _S_token_char_class_name,
+      _S_token_collsymbol,
+      _S_token_equiv_class_name,
+      _S_token_opt,
+      _S_token_or,
+      _S_token_closure0,
+      _S_token_closure1,
+      _S_token_ungreedy,
+      _S_token_line_begin,
+      _S_token_line_end,
+      _S_token_word_bound, // neg if _M_value[0] == 'n'
+      _S_token_comma,
+      _S_token_dup_count,
+      _S_token_eof,
+      _S_token_unknown
+    };
+
+  protected:
+    typedef regex_constants::syntax_option_type _FlagT;
+
+    enum _StateT
+    {
+      _S_state_normal,
+      _S_state_in_brace,
+      _S_state_in_bracket,
+    };
+
+  protected:
+    _ScannerBase(_FlagT __flags)
+    : _M_state(_S_state_normal),
+    _M_flags(__flags),
+    _M_escape_tbl(_M_is_ecma()
+		  ? _M_ecma_escape_tbl
+		  : _M_awk_escape_tbl),
+    _M_spec_char(_M_is_ecma()
+		 ? _M_ecma_spec_char
+		 : _M_is_basic()
+		 ? _M_basic_spec_char
+		 : _M_extended_spec_char),
+    _M_at_bracket_start(false)
+    { }
+
+  protected:
+    const char*
+    _M_find_escape(char __c)
+    {
+      auto __it = _M_escape_tbl;
+      for (; __it->first != '\0'; ++__it)
+	if (__it->first == __c)
+	  return &__it->second;
+      return nullptr;
+    }
+
+    bool
+    _M_is_ecma() const
+    { return _M_flags & regex_constants::ECMAScript; }
+
+    bool
+    _M_is_basic() const
+    { return _M_flags & (regex_constants::basic | regex_constants::grep); }
+
+    bool
+    _M_is_extended() const
+    {
+      return _M_flags & (regex_constants::extended
+			 | regex_constants::egrep
+			 | regex_constants::awk);
+    }
+
+    bool
+    _M_is_grep() const
+    { return _M_flags & (regex_constants::grep | regex_constants::egrep); }
+
+    bool
+    _M_is_awk() const
+    { return _M_flags & regex_constants::awk; }
+
+  protected:
+    const std::pair<char, _TokenT> _M_token_tbl[9] =
+      {
+	{'^', _S_token_line_begin},
+	{'$', _S_token_line_end},
+	{'.', _S_token_anychar},
+	{'*', _S_token_closure0},
+	{'+', _S_token_closure1},
+	{'?', _S_token_opt},
+	{'|', _S_token_or},
+	{'\n', _S_token_or}, // grep and egrep
+	{'\0', _S_token_or},
+      };
+    const std::pair<char, char> _M_ecma_escape_tbl[8] =
+      {
+	{'0', '\0'},
+	{'b', '\b'},
+	{'f', '\f'},
+	{'n', '\n'},
+	{'r', '\r'},
+	{'t', '\t'},
+	{'v', '\v'},
+	{'\0', '\0'},
+      };
+    const std::pair<char, char> _M_awk_escape_tbl[11] =
+      {
+	{'"', '"'},
+	{'/', '/'},
+	{'\\', '\\'},
+	{'a', '\a'},
+	{'b', '\b'},
+	{'f', '\f'},
+	{'n', '\n'},
+	{'r', '\r'},
+	{'t', '\t'},
+	{'v', '\v'},
+	{'\0', '\0'},
+      };
+    const char* _M_ecma_spec_char = "^$\\.*+?()[]{}|";
+    const char* _M_basic_spec_char = ".[\\*^$";
+    const char* _M_extended_spec_char = ".[\\()*+?{|^$";
+
+    _StateT                       _M_state;
+    _FlagT                        _M_flags;
+    _TokenT                       _M_token;
+    const std::pair<char, char>*  _M_escape_tbl;
+    const char*                   _M_spec_char;
+    bool                          _M_at_bracket_start;
+  };
+
+  /**
+   * @brief Scans an input range for regex tokens.
+   *
+   * The %_Scanner class interprets the regular expression pattern in
+   * the input range passed to its constructor as a sequence of parse
+   * tokens passed to the regular expression compiler.  The sequence
+   * of tokens provided depends on the flag settings passed to the
+   * constructor: different regular expression grammars will interpret
+   * the same input pattern in syntactically different ways.
+   */
+  template<typename _CharT>
+    class _Scanner
+    : public _ScannerBase
+    {
+    public:
+      typedef const _CharT*                                       _IterT;
+      typedef std::basic_string<_CharT>                           _StringT;
+      typedef regex_constants::syntax_option_type                 _FlagT;
+      typedef const std::ctype<_CharT>                            _CtypeT;
+
+      _Scanner(_IterT __begin, _IterT __end,
+	       _FlagT __flags, std::locale __loc);
+
+      void
+      _M_advance();
+
+      _TokenT
+      _M_get_token() const
+      { return _M_token; }
+
+      const _StringT&
+      _M_get_value() const
+      { return _M_value; }
+
+#ifdef _GLIBCXX_DEBUG
+      std::ostream&
+      _M_print(std::ostream&);
+#endif
+
+    private:
+      void
+      _M_scan_normal();
+
+      void
+      _M_scan_in_bracket();
+
+      void
+      _M_scan_in_brace();
+
+      void
+      _M_eat_escape_ecma();
+
+      void
+      _M_eat_escape_posix();
+
+      void
+      _M_eat_escape_awk();
+
+      void
+      _M_eat_class(char);
+
+      _IterT                        _M_current;
+      _IterT                        _M_end;
+      _CtypeT&                      _M_ctype;
+      _StringT                      _M_value;
+      void (_Scanner::* _M_eat_escape)();
+    };
+
+ //@} regex-detail
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace std
+
+#include <bits/regex_scanner.tcc>
diff --git a/gcc-4.9/libstdc++-v3/include/bits/regex_scanner.tcc b/gcc-4.9/libstdc++-v3/include/bits/regex_scanner.tcc
new file mode 100644
index 0000000..5332d2e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/regex_scanner.tcc
@@ -0,0 +1,561 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file bits/regex_scanner.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{regex}
+ */
+
+// FIXME make comments doxygen format.
+
+// N3376 specified 6 regex styles: ECMAScript, basic, extended, grep, egrep
+// and awk
+// 1) grep is basic except '\n' is treated as '|'
+// 2) egrep is extended except '\n' is treated as '|'
+// 3) awk is extended except special escaping rules, and there's no
+//    back-reference.
+//
+// References:
+//
+// ECMAScript: ECMA-262 15.10
+//
+// basic, extended:
+// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html
+//
+// awk: http://pubs.opengroup.org/onlinepubs/000095399/utilities/awk.html
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT>
+    _Scanner<_CharT>::
+    _Scanner(typename _Scanner::_IterT __begin,
+	     typename _Scanner::_IterT __end,
+	     _FlagT __flags, std::locale __loc)
+    : _ScannerBase(__flags),
+      _M_current(__begin), _M_end(__end),
+      _M_ctype(std::use_facet<_CtypeT>(__loc)),
+      _M_eat_escape(_M_is_ecma()
+		    ? &_Scanner::_M_eat_escape_ecma
+		    : &_Scanner::_M_eat_escape_posix)
+    { _M_advance(); }
+
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_advance()
+    {
+      if (_M_current == _M_end)
+	{
+	  _M_token = _S_token_eof;
+	  return;
+	}
+
+      if (_M_state == _S_state_normal)
+	_M_scan_normal();
+      else if (_M_state == _S_state_in_bracket)
+	_M_scan_in_bracket();
+      else if (_M_state == _S_state_in_brace)
+	_M_scan_in_brace();
+      else
+	_GLIBCXX_DEBUG_ASSERT(false);
+    }
+
+  // Differences between styles:
+  // 1) "\(", "\)", "\{" in basic. It's not escaping.
+  // 2) "(?:", "(?=", "(?!" in ECMAScript.
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_scan_normal()
+    {
+      auto __c = *_M_current++;
+      const char* __pos;
+
+      if (__c == '\\')
+	{
+	  if (_M_current == _M_end)
+	    __throw_regex_error(regex_constants::error_escape);
+
+	  if (!_M_is_basic()
+	      || (*_M_current != '('
+		  && *_M_current != ')'
+		  && *_M_current != '{'))
+	    {
+	      (this->*_M_eat_escape)();
+	      return;
+	    }
+	  __c = *_M_current++;
+	}
+      if (__c == '(')
+	{
+	  if (_M_is_ecma() && *_M_current == '?')
+	    {
+	      if (++_M_current == _M_end)
+		__throw_regex_error(regex_constants::error_paren);
+
+	      if (*_M_current == ':')
+		{
+		  ++_M_current;
+		  _M_token = _S_token_subexpr_no_group_begin;
+		}
+	      else if (*_M_current == '=')
+		{
+		  ++_M_current;
+		  _M_token = _S_token_subexpr_lookahead_begin;
+		  _M_value.assign(1, 'p');
+		}
+	      else if (*_M_current == '!')
+		{
+		  ++_M_current;
+		  _M_token = _S_token_subexpr_lookahead_begin;
+		  _M_value.assign(1, 'n');
+		}
+	      else
+		__throw_regex_error(regex_constants::error_paren);
+	    }
+	  else if (_M_flags & regex_constants::nosubs)
+	    _M_token = _S_token_subexpr_no_group_begin;
+	  else
+	    _M_token = _S_token_subexpr_begin;
+	}
+      else if (__c == ')')
+	_M_token = _S_token_subexpr_end;
+      else if (__c == '[')
+	{
+	  _M_state = _S_state_in_bracket;
+	  _M_at_bracket_start = true;
+	  if (_M_current != _M_end && *_M_current == '^')
+	    {
+	      _M_token = _S_token_bracket_neg_begin;
+	      ++_M_current;
+	    }
+	  else
+	    _M_token = _S_token_bracket_begin;
+	}
+      else if (__c == '{')
+	{
+	  _M_state = _S_state_in_brace;
+	  _M_token = _S_token_interval_begin;
+	}
+      else if (((__pos = std::strchr(_M_spec_char, _M_ctype.narrow(__c, '\0')))
+		  != nullptr
+		&& *__pos != '\0'
+		&& __c != ']'
+		&& __c != '}')
+	       || (_M_is_grep() && __c == '\n'))
+	{
+	  auto __it = _M_token_tbl;
+	  auto __narrowc = _M_ctype.narrow(__c, '\0');
+	  for (; __it->first != '\0'; ++__it)
+	    if (__it->first == __narrowc)
+	      {
+		_M_token = __it->second;
+		return;
+	      }
+	  _GLIBCXX_DEBUG_ASSERT(false);
+	}
+      else
+	{
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, __c);
+	}
+    }
+
+  // Differences between styles:
+  // 1) different semantics of "[]" and "[^]".
+  // 2) Escaping in bracket expr.
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_scan_in_bracket()
+    {
+      if (_M_current == _M_end)
+	__throw_regex_error(regex_constants::error_brack);
+
+      auto __c = *_M_current++;
+
+      if (__c == '[')
+	{
+	  if (_M_current == _M_end)
+	    __throw_regex_error(regex_constants::error_brack);
+
+	  if (*_M_current == '.')
+	    {
+	      _M_token = _S_token_collsymbol;
+	      _M_eat_class(*_M_current++);
+	    }
+	  else if (*_M_current == ':')
+	    {
+	      _M_token = _S_token_char_class_name;
+	      _M_eat_class(*_M_current++);
+	    }
+	  else if (*_M_current == '=')
+	    {
+	      _M_token = _S_token_equiv_class_name;
+	      _M_eat_class(*_M_current++);
+	    }
+	  else
+	    {
+	      _M_token = _S_token_ord_char;
+	      _M_value.assign(1, __c);
+	    }
+	}
+      // In POSIX, when encountering "[]" or "[^]", the ']' is interpreted
+      // literally. So "[]]" or "[^]]" is valid regex. See the testcases
+      // `*/empty_range.cc`.
+      else if (__c == ']' && (_M_is_ecma() || !_M_at_bracket_start))
+	{
+	  _M_token = _S_token_bracket_end;
+	  _M_state = _S_state_normal;
+	}
+      // ECMAScirpt and awk permmits escaping in bracket.
+      else if (__c == '\\' && (_M_is_ecma() || _M_is_awk()))
+	(this->*_M_eat_escape)();
+      else
+	{
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, __c);
+	}
+      _M_at_bracket_start = false;
+    }
+
+  // Differences between styles:
+  // 1) "\}" in basic style.
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_scan_in_brace()
+    {
+      if (_M_current == _M_end)
+	__throw_regex_error(regex_constants::error_brace);
+
+      auto __c = *_M_current++;
+
+      if (_M_ctype.is(_CtypeT::digit, __c))
+	{
+	  _M_token = _S_token_dup_count;
+	  _M_value.assign(1, __c);
+	  while (_M_current != _M_end
+		 && _M_ctype.is(_CtypeT::digit, *_M_current))
+	    _M_value += *_M_current++;
+	}
+      else if (__c == ',')
+	_M_token = _S_token_comma;
+      // basic use \}.
+      else if (_M_is_basic())
+	{
+	  if (__c == '\\' && _M_current != _M_end && *_M_current == '}')
+	    {
+	      _M_state = _S_state_normal;
+	      _M_token = _S_token_interval_end;
+	      ++_M_current;
+	    }
+	  else
+	    __throw_regex_error(regex_constants::error_badbrace);
+	}
+      else if (__c == '}')
+	{
+	  _M_state = _S_state_normal;
+	  _M_token = _S_token_interval_end;
+	}
+      else
+	__throw_regex_error(regex_constants::error_badbrace);
+    }
+
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_eat_escape_ecma()
+    {
+      if (_M_current == _M_end)
+	__throw_regex_error(regex_constants::error_escape);
+
+      auto __c = *_M_current++;
+      auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0'));
+
+      if (__pos != nullptr && (__c != 'b' || _M_state == _S_state_in_bracket))
+	{
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, *__pos);
+	}
+      else if (__c == 'b')
+	{
+	  _M_token = _S_token_word_bound;
+	  _M_value.assign(1, 'p');
+	}
+      else if (__c == 'B')
+	{
+	  _M_token = _S_token_word_bound;
+	  _M_value.assign(1, 'n');
+	}
+      // N3376 28.13
+      else if (__c == 'd'
+	       || __c == 'D'
+	       || __c == 's'
+	       || __c == 'S'
+	       || __c == 'w'
+	       || __c == 'W')
+	{
+	  _M_token = _S_token_quoted_class;
+	  _M_value.assign(1, __c);
+	}
+      else if (__c == 'c')
+	{
+	  if (_M_current == _M_end)
+	    __throw_regex_error(regex_constants::error_escape);
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, *_M_current++);
+	}
+      else if (__c == 'x' || __c == 'u')
+	{
+	  _M_value.erase();
+	  for (int i = 0; i < (__c == 'x' ? 2 : 4); i++)
+	    {
+	      if (_M_current == _M_end
+		  || !_M_ctype.is(_CtypeT::xdigit, *_M_current))
+		__throw_regex_error(regex_constants::error_escape);
+	      _M_value += *_M_current++;
+	    }
+	  _M_token = _S_token_hex_num;
+	}
+      // ECMAScript recongnizes multi-digit back-references.
+      else if (_M_ctype.is(_CtypeT::digit, __c))
+	{
+	  _M_value.assign(1, __c);
+	  while (_M_current != _M_end
+		 && _M_ctype.is(_CtypeT::digit, *_M_current))
+	    _M_value += *_M_current++;
+	  _M_token = _S_token_backref;
+	}
+      else
+	{
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, __c);
+	}
+    }
+
+  // Differences between styles:
+  // 1) Extended doesn't support backref, but basic does.
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_eat_escape_posix()
+    {
+      if (_M_current == _M_end)
+	__throw_regex_error(regex_constants::error_escape);
+
+      auto __c = *_M_current;
+      auto __pos = std::strchr(_M_spec_char, _M_ctype.narrow(__c, '\0'));
+
+      if (__pos != nullptr && *__pos != '\0')
+	{
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, __c);
+	}
+      // We MUST judge awk before handling backrefs. There's no backref in awk.
+      else if (_M_is_awk())
+	{
+	  _M_eat_escape_awk();
+	  return;
+	}
+      else if (_M_is_basic() && _M_ctype.is(_CtypeT::digit, __c) && __c != '0')
+	{
+	  _M_token = _S_token_backref;
+	  _M_value.assign(1, __c);
+	}
+      else
+	{
+#ifdef __STRICT_ANSI__
+	  __throw_regex_error(regex_constants::error_escape);
+#else
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, __c);
+#endif
+	}
+      ++_M_current;
+    }
+
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_eat_escape_awk()
+    {
+      auto __c = *_M_current++;
+      auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0'));
+
+      if (__pos != nullptr)
+	{
+	  _M_token = _S_token_ord_char;
+	  _M_value.assign(1, *__pos);
+	}
+      // \ddd for oct representation
+      else if (_M_ctype.is(_CtypeT::digit, __c)
+	       && __c != '8'
+	       && __c != '9')
+	{
+	  _M_value.assign(1,  __c);
+	  for (int __i = 0;
+	       __i < 2
+	       && _M_current != _M_end
+	       && _M_ctype.is(_CtypeT::digit, *_M_current)
+	       && *_M_current != '8'
+	       && *_M_current != '9';
+	       __i++)
+	    _M_value += *_M_current++;
+	  _M_token = _S_token_oct_num;
+	  return;
+	}
+      else
+	__throw_regex_error(regex_constants::error_escape);
+    }
+
+  // Eats a character class or throwns an exception.
+  // __ch cound be ':', '.' or '=', _M_current is the char after ']' when
+  // returning.
+  template<typename _CharT>
+    void
+    _Scanner<_CharT>::
+    _M_eat_class(char __ch)
+    {
+      for (_M_value.clear(); _M_current != _M_end && *_M_current != __ch;)
+	_M_value += *_M_current++;
+      if (_M_current == _M_end
+	  || *_M_current++ != __ch
+	  || _M_current == _M_end // skip __ch
+	  || *_M_current++ != ']') // skip ']'
+	{
+	  if (__ch == ':')
+	    __throw_regex_error(regex_constants::error_ctype);
+	  else
+	    __throw_regex_error(regex_constants::error_collate);
+	}
+    }
+
+#ifdef _GLIBCXX_DEBUG
+  template<typename _CharT>
+    std::ostream&
+    _Scanner<_CharT>::
+    _M_print(std::ostream& ostr)
+    {
+      switch (_M_token)
+      {
+      case _S_token_anychar:
+	ostr << "any-character\n";
+	break;
+      case _S_token_backref:
+	ostr << "backref\n";
+	break;
+      case _S_token_bracket_begin:
+	ostr << "bracket-begin\n";
+	break;
+      case _S_token_bracket_neg_begin:
+	ostr << "bracket-neg-begin\n";
+	break;
+      case _S_token_bracket_end:
+	ostr << "bracket-end\n";
+	break;
+      case _S_token_char_class_name:
+	ostr << "char-class-name \"" << _M_value << "\"\n";
+	break;
+      case _S_token_closure0:
+	ostr << "closure0\n";
+	break;
+      case _S_token_closure1:
+	ostr << "closure1\n";
+	break;
+      case _S_token_collsymbol:
+	ostr << "collsymbol \"" << _M_value << "\"\n";
+	break;
+      case _S_token_comma:
+	ostr << "comma\n";
+	break;
+      case _S_token_dup_count:
+	ostr << "dup count: " << _M_value << "\n";
+	break;
+      case _S_token_eof:
+	ostr << "EOF\n";
+	break;
+      case _S_token_equiv_class_name:
+	ostr << "equiv-class-name \"" << _M_value << "\"\n";
+	break;
+      case _S_token_interval_begin:
+	ostr << "interval begin\n";
+	break;
+      case _S_token_interval_end:
+	ostr << "interval end\n";
+	break;
+      case _S_token_line_begin:
+	ostr << "line begin\n";
+	break;
+      case _S_token_line_end:
+	ostr << "line end\n";
+	break;
+      case _S_token_opt:
+	ostr << "opt\n";
+	break;
+      case _S_token_or:
+	ostr << "or\n";
+	break;
+      case _S_token_ord_char:
+	ostr << "ordinary character: \"" << _M_value << "\"\n";
+	break;
+      case _S_token_subexpr_begin:
+	ostr << "subexpr begin\n";
+	break;
+      case _S_token_subexpr_no_group_begin:
+	ostr << "no grouping subexpr begin\n";
+	break;
+      case _S_token_subexpr_lookahead_begin:
+	ostr << "lookahead subexpr begin\n";
+	break;
+      case _S_token_subexpr_end:
+	ostr << "subexpr end\n";
+	break;
+      case _S_token_unknown:
+	ostr << "-- unknown token --\n";
+	break;
+      case _S_token_oct_num:
+	ostr << "oct number " << _M_value << "\n";
+	break;
+      case _S_token_hex_num:
+	ostr << "hex number " << _M_value << "\n";
+	break;
+      case _S_token_quoted_class:
+	ostr << "quoted class " << "\\" << _M_value << "\n";
+	break;
+      default:
+	_GLIBCXX_DEBUG_ASSERT(false);
+      }
+      return ostr;
+    }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace
diff --git a/gcc-4.9/libstdc++-v3/include/bits/shared_ptr.h b/gcc-4.9/libstdc++-v3/include/bits/shared_ptr.h
new file mode 100644
index 0000000..081d3bd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/shared_ptr.h
@@ -0,0 +1,622 @@
+// shared_ptr and weak_ptr implementation -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// GCC Note: Based on files from version 1.32.0 of the Boost library.
+
+//  shared_count.hpp
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+
+//  shared_ptr.hpp
+//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
+//  Copyright (C) 2001, 2002, 2003 Peter Dimov
+
+//  weak_ptr.hpp
+//  Copyright (C) 2001, 2002, 2003 Peter Dimov
+
+//  enable_shared_from_this.hpp
+//  Copyright (C) 2002 Peter Dimov
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+/** @file bits/shared_ptr.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _SHARED_PTR_H
+#define _SHARED_PTR_H 1
+
+#include <bits/shared_ptr_base.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup pointer_abstractions
+   * @{
+   */
+
+  /// 20.7.2.2.11 shared_ptr I/O
+  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
+    inline std::basic_ostream<_Ch, _Tr>&
+    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
+	       const __shared_ptr<_Tp, _Lp>& __p)
+    {
+      __os << __p.get();
+      return __os;
+    }
+
+  /// 20.7.2.2.10 shared_ptr get_deleter
+  template<typename _Del, typename _Tp, _Lock_policy _Lp>
+    inline _Del*
+    get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
+    {
+#ifdef __GXX_RTTI
+      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
+#else
+      return 0;
+#endif
+    }
+
+
+  /**
+   *  @brief  A smart pointer with reference-counted copy semantics.
+   *
+   *  The object pointed to is deleted when the last shared_ptr pointing to
+   *  it is destroyed or reset.
+  */
+  template<typename _Tp>
+    class shared_ptr : public __shared_ptr<_Tp>
+    {
+    public:
+      /**
+       *  @brief  Construct an empty %shared_ptr.
+       *  @post   use_count()==0 && get()==0
+       */
+      constexpr shared_ptr() noexcept
+      : __shared_ptr<_Tp>() { }
+
+      shared_ptr(const shared_ptr&) noexcept = default;
+
+      /**
+       *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
+       *  @param  __p  A pointer that is convertible to element_type*.
+       *  @post   use_count() == 1 && get() == __p
+       *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
+       */
+      template<typename _Tp1>
+	explicit shared_ptr(_Tp1* __p)
+        : __shared_ptr<_Tp>(__p) { }
+
+      /**
+       *  @brief  Construct a %shared_ptr that owns the pointer @a __p
+       *          and the deleter @a __d.
+       *  @param  __p  A pointer.
+       *  @param  __d  A deleter.
+       *  @post   use_count() == 1 && get() == __p
+       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
+       *
+       *  Requirements: _Deleter's copy constructor and destructor must
+       *  not throw
+       *
+       *  __shared_ptr will release __p by calling __d(__p)
+       */
+      template<typename _Tp1, typename _Deleter>
+	shared_ptr(_Tp1* __p, _Deleter __d)
+        : __shared_ptr<_Tp>(__p, __d) { }
+
+      /**
+       *  @brief  Construct a %shared_ptr that owns a null pointer
+       *          and the deleter @a __d.
+       *  @param  __p  A null pointer constant.
+       *  @param  __d  A deleter.
+       *  @post   use_count() == 1 && get() == __p
+       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
+       *
+       *  Requirements: _Deleter's copy constructor and destructor must
+       *  not throw
+       *
+       *  The last owner will call __d(__p)
+       */
+      template<typename _Deleter>
+	shared_ptr(nullptr_t __p, _Deleter __d)
+        : __shared_ptr<_Tp>(__p, __d) { }
+
+      /**
+       *  @brief  Construct a %shared_ptr that owns the pointer @a __p
+       *          and the deleter @a __d.
+       *  @param  __p  A pointer.
+       *  @param  __d  A deleter.
+       *  @param  __a  An allocator.
+       *  @post   use_count() == 1 && get() == __p
+       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
+       *
+       *  Requirements: _Deleter's copy constructor and destructor must
+       *  not throw _Alloc's copy constructor and destructor must not
+       *  throw.
+       *
+       *  __shared_ptr will release __p by calling __d(__p)
+       */
+      template<typename _Tp1, typename _Deleter, typename _Alloc>
+	shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
+	: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
+
+      /**
+       *  @brief  Construct a %shared_ptr that owns a null pointer
+       *          and the deleter @a __d.
+       *  @param  __p  A null pointer constant.
+       *  @param  __d  A deleter.
+       *  @param  __a  An allocator.
+       *  @post   use_count() == 1 && get() == __p
+       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
+       *
+       *  Requirements: _Deleter's copy constructor and destructor must
+       *  not throw _Alloc's copy constructor and destructor must not
+       *  throw.
+       *
+       *  The last owner will call __d(__p)
+       */
+      template<typename _Deleter, typename _Alloc>
+	shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
+	: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
+
+      // Aliasing constructor
+
+      /**
+       *  @brief  Constructs a %shared_ptr instance that stores @a __p
+       *          and shares ownership with @a __r.
+       *  @param  __r  A %shared_ptr.
+       *  @param  __p  A pointer that will remain valid while @a *__r is valid.
+       *  @post   get() == __p && use_count() == __r.use_count()
+       *
+       *  This can be used to construct a @c shared_ptr to a sub-object
+       *  of an object managed by an existing @c shared_ptr.
+       *
+       * @code
+       * shared_ptr< pair<int,int> > pii(new pair<int,int>());
+       * shared_ptr<int> pi(pii, &pii->first);
+       * assert(pii.use_count() == 2);
+       * @endcode
+       */
+      template<typename _Tp1>
+	shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept
+	: __shared_ptr<_Tp>(__r, __p) { }
+
+      /**
+       *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
+       *          otherwise construct a %shared_ptr that shares ownership
+       *          with @a __r.
+       *  @param  __r  A %shared_ptr.
+       *  @post   get() == __r.get() && use_count() == __r.use_count()
+       */
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	shared_ptr(const shared_ptr<_Tp1>& __r) noexcept
+        : __shared_ptr<_Tp>(__r) { }
+
+      /**
+       *  @brief  Move-constructs a %shared_ptr instance from @a __r.
+       *  @param  __r  A %shared_ptr rvalue.
+       *  @post   *this contains the old value of @a __r, @a __r is empty.
+       */
+      shared_ptr(shared_ptr&& __r) noexcept
+      : __shared_ptr<_Tp>(std::move(__r)) { }
+
+      /**
+       *  @brief  Move-constructs a %shared_ptr instance from @a __r.
+       *  @param  __r  A %shared_ptr rvalue.
+       *  @post   *this contains the old value of @a __r, @a __r is empty.
+       */
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
+	: __shared_ptr<_Tp>(std::move(__r)) { }
+
+      /**
+       *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
+       *          and stores a copy of the pointer stored in @a __r.
+       *  @param  __r  A weak_ptr.
+       *  @post   use_count() == __r.use_count()
+       *  @throw  bad_weak_ptr when __r.expired(),
+       *          in which case the constructor has no effect.
+       */
+      template<typename _Tp1>
+	explicit shared_ptr(const weak_ptr<_Tp1>& __r)
+	: __shared_ptr<_Tp>(__r) { }
+
+#if _GLIBCXX_USE_DEPRECATED
+      template<typename _Tp1>
+	shared_ptr(std::auto_ptr<_Tp1>&& __r);
+#endif
+
+      template<typename _Tp1, typename _Del>
+	shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
+	: __shared_ptr<_Tp>(std::move(__r)) { }
+
+      /**
+       *  @brief  Construct an empty %shared_ptr.
+       *  @param  __p  A null pointer constant.
+       *  @post   use_count() == 0 && get() == nullptr
+       */
+      constexpr shared_ptr(nullptr_t __p) noexcept
+      : __shared_ptr<_Tp>(__p) { }
+
+      shared_ptr& operator=(const shared_ptr&) noexcept = default;
+
+      template<typename _Tp1>
+	shared_ptr&
+	operator=(const shared_ptr<_Tp1>& __r) noexcept
+	{
+	  this->__shared_ptr<_Tp>::operator=(__r);
+	  return *this;
+	}
+
+#if _GLIBCXX_USE_DEPRECATED
+      template<typename _Tp1>
+	shared_ptr&
+	operator=(std::auto_ptr<_Tp1>&& __r)
+	{
+	  this->__shared_ptr<_Tp>::operator=(std::move(__r));
+	  return *this;
+	}
+#endif
+
+      shared_ptr&
+      operator=(shared_ptr&& __r) noexcept
+      {
+	this->__shared_ptr<_Tp>::operator=(std::move(__r));
+	return *this;
+      }
+
+      template<class _Tp1>
+	shared_ptr&
+	operator=(shared_ptr<_Tp1>&& __r) noexcept
+	{
+	  this->__shared_ptr<_Tp>::operator=(std::move(__r));
+	  return *this;
+	}
+
+      template<typename _Tp1, typename _Del>
+	shared_ptr&
+	operator=(std::unique_ptr<_Tp1, _Del>&& __r)
+	{
+	  this->__shared_ptr<_Tp>::operator=(std::move(__r));
+	  return *this;
+	}
+
+    private:
+      // This constructor is non-standard, it is used by allocate_shared.
+      template<typename _Alloc, typename... _Args>
+	shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
+		   _Args&&... __args)
+	: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
+	{ }
+
+      template<typename _Tp1, typename _Alloc, typename... _Args>
+	friend shared_ptr<_Tp1>
+	allocate_shared(const _Alloc& __a, _Args&&... __args);
+
+      // This constructor is non-standard, it is used by weak_ptr::lock().
+      shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
+      : __shared_ptr<_Tp>(__r, std::nothrow) { }
+
+      friend class weak_ptr<_Tp>;
+    };
+
+  // 20.7.2.2.7 shared_ptr comparisons
+  template<typename _Tp1, typename _Tp2>
+    inline bool
+    operator==(const shared_ptr<_Tp1>& __a,
+	       const shared_ptr<_Tp2>& __b) noexcept
+    { return __a.get() == __b.get(); }
+
+  template<typename _Tp>
+    inline bool
+    operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !__a; }
+
+  template<typename _Tp>
+    inline bool
+    operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !__a; }
+
+  template<typename _Tp1, typename _Tp2>
+    inline bool
+    operator!=(const shared_ptr<_Tp1>& __a,
+	       const shared_ptr<_Tp2>& __b) noexcept
+    { return __a.get() != __b.get(); }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp1, typename _Tp2>
+    inline bool
+    operator<(const shared_ptr<_Tp1>& __a,
+	      const shared_ptr<_Tp2>& __b) noexcept
+    {
+      typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
+      return std::less<_CT>()(__a.get(), __b.get());
+    }
+
+  template<typename _Tp>
+    inline bool
+    operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return std::less<_Tp*>()(__a.get(), nullptr); }
+
+  template<typename _Tp>
+    inline bool
+    operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return std::less<_Tp*>()(nullptr, __a.get()); }
+
+  template<typename _Tp1, typename _Tp2>
+    inline bool
+    operator<=(const shared_ptr<_Tp1>& __a,
+	       const shared_ptr<_Tp2>& __b) noexcept
+    { return !(__b < __a); }
+
+  template<typename _Tp>
+    inline bool
+    operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !(nullptr < __a); }
+
+  template<typename _Tp>
+    inline bool
+    operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp1, typename _Tp2>
+    inline bool
+    operator>(const shared_ptr<_Tp1>& __a,
+	      const shared_ptr<_Tp2>& __b) noexcept
+    { return (__b < __a); }
+
+  template<typename _Tp>
+    inline bool
+    operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return std::less<_Tp*>()(nullptr, __a.get()); }
+
+  template<typename _Tp>
+    inline bool
+    operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return std::less<_Tp*>()(__a.get(), nullptr); }
+
+  template<typename _Tp1, typename _Tp2>
+    inline bool
+    operator>=(const shared_ptr<_Tp1>& __a,
+	       const shared_ptr<_Tp2>& __b) noexcept
+    { return !(__a < __b); }
+
+  template<typename _Tp>
+    inline bool
+    operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp>
+    inline bool
+    operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !(nullptr < __a); }
+
+  template<typename _Tp>
+    struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
+    { };
+
+  // 20.7.2.2.8 shared_ptr specialized algorithms.
+  template<typename _Tp>
+    inline void
+    swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
+    { __a.swap(__b); }
+
+  // 20.7.2.2.9 shared_ptr casts.
+  template<typename _Tp, typename _Tp1>
+    inline shared_ptr<_Tp>
+    static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
+    { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
+
+  template<typename _Tp, typename _Tp1>
+    inline shared_ptr<_Tp>
+    const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
+    { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
+
+  template<typename _Tp, typename _Tp1>
+    inline shared_ptr<_Tp>
+    dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
+    {
+      if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
+	return shared_ptr<_Tp>(__r, __p);
+      return shared_ptr<_Tp>();
+    }
+
+
+  /**
+   *  @brief  A smart pointer with weak semantics.
+   *
+   *  With forwarding constructors and assignment operators.
+   */
+  template<typename _Tp>
+    class weak_ptr : public __weak_ptr<_Tp>
+    {
+    public:
+      constexpr weak_ptr() noexcept
+      : __weak_ptr<_Tp>() { }
+
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
+	: __weak_ptr<_Tp>(__r) { }
+
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
+	: __weak_ptr<_Tp>(__r) { }
+
+      template<typename _Tp1>
+	weak_ptr&
+	operator=(const weak_ptr<_Tp1>& __r) noexcept
+	{
+	  this->__weak_ptr<_Tp>::operator=(__r);
+	  return *this;
+	}
+
+      template<typename _Tp1>
+	weak_ptr&
+	operator=(const shared_ptr<_Tp1>& __r) noexcept
+	{
+	  this->__weak_ptr<_Tp>::operator=(__r);
+	  return *this;
+	}
+
+      shared_ptr<_Tp>
+      lock() const noexcept
+      { return shared_ptr<_Tp>(*this, std::nothrow); }
+    };
+
+  // 20.7.2.3.6 weak_ptr specialized algorithms.
+  template<typename _Tp>
+    inline void
+    swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
+    { __a.swap(__b); }
+
+
+  /// Primary template owner_less
+  template<typename _Tp>
+    struct owner_less;
+
+  /// Partial specialization of owner_less for shared_ptr.
+  template<typename _Tp>
+    struct owner_less<shared_ptr<_Tp>>
+    : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
+    { };
+
+  /// Partial specialization of owner_less for weak_ptr.
+  template<typename _Tp>
+    struct owner_less<weak_ptr<_Tp>>
+    : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
+    { };
+
+  /**
+   *  @brief Base class allowing use of member function shared_from_this.
+   */
+  template<typename _Tp>
+    class enable_shared_from_this
+    {
+    protected:
+      constexpr enable_shared_from_this() noexcept { }
+
+      enable_shared_from_this(const enable_shared_from_this&) noexcept { }
+
+      enable_shared_from_this&
+      operator=(const enable_shared_from_this&) noexcept
+      { return *this; }
+
+      ~enable_shared_from_this() { }
+
+    public:
+      shared_ptr<_Tp>
+      shared_from_this()
+      { return shared_ptr<_Tp>(this->_M_weak_this); }
+
+      shared_ptr<const _Tp>
+      shared_from_this() const
+      { return shared_ptr<const _Tp>(this->_M_weak_this); }
+
+    private:
+      template<typename _Tp1>
+	void
+	_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
+	{ _M_weak_this._M_assign(__p, __n); }
+
+      template<typename _Tp1>
+	friend void
+	__enable_shared_from_this_helper(const __shared_count<>& __pn,
+					 const enable_shared_from_this* __pe,
+					 const _Tp1* __px) noexcept
+	{
+	  if (__pe != 0)
+	    __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
+	}
+
+      mutable weak_ptr<_Tp>  _M_weak_this;
+    };
+
+  /**
+   *  @brief  Create an object that is owned by a shared_ptr.
+   *  @param  __a     An allocator.
+   *  @param  __args  Arguments for the @a _Tp object's constructor.
+   *  @return A shared_ptr that owns the newly created object.
+   *  @throw  An exception thrown from @a _Alloc::allocate or from the
+   *          constructor of @a _Tp.
+   *
+   *  A copy of @a __a will be used to allocate memory for the shared_ptr
+   *  and the new object.
+   */
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline shared_ptr<_Tp>
+    allocate_shared(const _Alloc& __a, _Args&&... __args)
+    {
+      return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
+			     std::forward<_Args>(__args)...);
+    }
+
+  /**
+   *  @brief  Create an object that is owned by a shared_ptr.
+   *  @param  __args  Arguments for the @a _Tp object's constructor.
+   *  @return A shared_ptr that owns the newly created object.
+   *  @throw  std::bad_alloc, or an exception thrown from the
+   *          constructor of @a _Tp.
+   */
+  template<typename _Tp, typename... _Args>
+    inline shared_ptr<_Tp>
+    make_shared(_Args&&... __args)
+    {
+      typedef typename std::remove_const<_Tp>::type _Tp_nc;
+      return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
+				       std::forward<_Args>(__args)...);
+    }
+
+  /// std::hash specialization for shared_ptr.
+  template<typename _Tp>
+    struct hash<shared_ptr<_Tp>>
+    : public __hash_base<size_t, shared_ptr<_Tp>>
+    {
+      size_t
+      operator()(const shared_ptr<_Tp>& __s) const noexcept
+      { return std::hash<_Tp*>()(__s.get()); }
+    };
+
+  // @} group pointer_abstractions
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _SHARED_PTR_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/shared_ptr_base.h b/gcc-4.9/libstdc++-v3/include/bits/shared_ptr_base.h
new file mode 100644
index 0000000..536df01
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/shared_ptr_base.h
@@ -0,0 +1,1553 @@
+// shared_ptr and weak_ptr implementation details -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// GCC Note: Based on files from version 1.32.0 of the Boost library.
+
+//  shared_count.hpp
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+
+//  shared_ptr.hpp
+//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
+//  Copyright (C) 2001, 2002, 2003 Peter Dimov
+
+//  weak_ptr.hpp
+//  Copyright (C) 2001, 2002, 2003 Peter Dimov
+
+//  enable_shared_from_this.hpp
+//  Copyright (C) 2002 Peter Dimov
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+/** @file bits/shared_ptr_base.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _SHARED_PTR_BASE_H
+#define _SHARED_PTR_BASE_H 1
+
+#include <ext/aligned_buffer.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if _GLIBCXX_USE_DEPRECATED
+  template<typename> class auto_ptr;
+#endif
+
+ /**
+   *  @brief  Exception possibly thrown by @c shared_ptr.
+   *  @ingroup exceptions
+   */
+  class bad_weak_ptr : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const noexcept;
+
+    virtual ~bad_weak_ptr() noexcept;    
+  };
+
+  // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
+  inline void
+  __throw_bad_weak_ptr()
+  { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); }
+
+  using __gnu_cxx::_Lock_policy;
+  using __gnu_cxx::__default_lock_policy;
+  using __gnu_cxx::_S_single;
+  using __gnu_cxx::_S_mutex;
+  using __gnu_cxx::_S_atomic;
+
+  // Empty helper class except when the template argument is _S_mutex.
+  template<_Lock_policy _Lp>
+    class _Mutex_base
+    {
+    protected:
+      // The atomic policy uses fully-fenced builtins, single doesn't care.
+      enum { _S_need_barriers = 0 };
+    };
+
+  template<>
+    class _Mutex_base<_S_mutex>
+    : public __gnu_cxx::__mutex
+    {
+    protected:
+      // This policy is used when atomic builtins are not available.
+      // The replacement atomic operations might not have the necessary
+      // memory barriers.
+      enum { _S_need_barriers = 1 };
+    };
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class _Sp_counted_base
+    : public _Mutex_base<_Lp>
+    {
+    public:  
+      _Sp_counted_base() noexcept
+      : _M_use_count(1), _M_weak_count(1) { }
+      
+      virtual
+      ~_Sp_counted_base() noexcept
+      { }
+  
+      // Called when _M_use_count drops to zero, to release the resources
+      // managed by *this.
+      virtual void
+      _M_dispose() noexcept = 0;
+      
+      // Called when _M_weak_count drops to zero.
+      virtual void
+      _M_destroy() noexcept
+      { delete this; }
+      
+      virtual void*
+      _M_get_deleter(const std::type_info&) noexcept = 0;
+
+      void
+      _M_add_ref_copy()
+      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
+  
+      void
+      _M_add_ref_lock();
+
+      bool
+      _M_add_ref_lock_nothrow();
+
+      void
+      _M_release() noexcept
+      {
+        // Be race-detector-friendly.  For more info see bits/c++config.
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
+	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
+	  {
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
+	    _M_dispose();
+	    // There must be a memory barrier between dispose() and destroy()
+	    // to ensure that the effects of dispose() are observed in the
+	    // thread that runs destroy().
+	    // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
+	    if (_Mutex_base<_Lp>::_S_need_barriers)
+	      {
+	        _GLIBCXX_READ_MEM_BARRIER;
+	        _GLIBCXX_WRITE_MEM_BARRIER;
+	      }
+
+            // Be race-detector-friendly.  For more info see bits/c++config.
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
+	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
+						       -1) == 1)
+              {
+                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
+	        _M_destroy();
+              }
+	  }
+      }
+  
+      void
+      _M_weak_add_ref() noexcept
+      { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
+
+      void
+      _M_weak_release() noexcept
+      {
+        // Be race-detector-friendly. For more info see bits/c++config.
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
+	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
+	  {
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
+	    if (_Mutex_base<_Lp>::_S_need_barriers)
+	      {
+	        // See _M_release(),
+	        // destroy() must observe results of dispose()
+	        _GLIBCXX_READ_MEM_BARRIER;
+	        _GLIBCXX_WRITE_MEM_BARRIER;
+	      }
+	    _M_destroy();
+	  }
+      }
+  
+      long
+      _M_get_use_count() const noexcept
+      {
+        // No memory barrier is used here so there is no synchronization
+        // with other threads.
+        return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);
+      }
+
+    private:  
+      _Sp_counted_base(_Sp_counted_base const&) = delete;
+      _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
+
+      _Atomic_word  _M_use_count;     // #shared
+      _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
+    };
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::
+    _M_add_ref_lock()
+    {
+      if (_M_use_count == 0)
+	__throw_bad_weak_ptr();
+      ++_M_use_count;
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_mutex>::
+    _M_add_ref_lock()
+    {
+      __gnu_cxx::__scoped_lock sentry(*this);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+	{
+	  _M_use_count = 0;
+	  __throw_bad_weak_ptr();
+	}
+    }
+
+  template<> 
+    inline void
+    _Sp_counted_base<_S_atomic>::
+    _M_add_ref_lock()
+    {
+      // Perform lock-free add-if-not-zero operation.
+      _Atomic_word __count = _M_get_use_count();
+      do
+	{
+	  if (__count == 0)
+	    __throw_bad_weak_ptr();
+	  // Replace the current counter value with the old value + 1, as
+	  // long as it's not changed meanwhile. 
+	}
+      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
+					  true, __ATOMIC_ACQ_REL, 
+					  __ATOMIC_RELAXED));
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_single>::
+    _M_add_ref_lock_nothrow()
+    {
+      if (_M_use_count == 0)
+	return false;
+      ++_M_use_count;
+      return true;
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_mutex>::
+    _M_add_ref_lock_nothrow()
+    {
+      __gnu_cxx::__scoped_lock sentry(*this);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+	{
+	  _M_use_count = 0;
+	  return false;
+	}
+      return true;
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_atomic>::
+    _M_add_ref_lock_nothrow()
+    {
+      // Perform lock-free add-if-not-zero operation.
+      _Atomic_word __count = _M_get_use_count();
+      do
+	{
+	  if (__count == 0)
+	    return false;
+	  // Replace the current counter value with the old value + 1, as
+	  // long as it's not changed meanwhile.
+	}
+      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
+					  true, __ATOMIC_ACQ_REL,
+					  __ATOMIC_RELAXED));
+      return true;
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_add_ref_copy()
+    { ++_M_use_count; }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_release() noexcept
+    {
+      if (--_M_use_count == 0)
+        {
+          _M_dispose();
+          if (--_M_weak_count == 0)
+            _M_destroy();
+        }
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
+    { ++_M_weak_count; }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_weak_release() noexcept
+    {
+      if (--_M_weak_count == 0)
+        _M_destroy();
+    }
+
+  template<>
+    inline long
+    _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
+    { return _M_use_count; }
+
+
+  // Forward declarations.
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __shared_ptr;
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __weak_ptr;
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __enable_shared_from_this;
+
+  template<typename _Tp>
+    class shared_ptr;
+
+  template<typename _Tp>
+    class weak_ptr;
+
+  template<typename _Tp>
+    struct owner_less;
+
+  template<typename _Tp>
+    class enable_shared_from_this;
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __weak_count;
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __shared_count;
+
+
+  // Counted ptr with no deleter or allocator support
+  template<typename _Ptr, _Lock_policy _Lp>
+    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
+    {
+    public:
+      explicit
+      _Sp_counted_ptr(_Ptr __p) noexcept
+      : _M_ptr(__p) { }
+
+      virtual void
+      _M_dispose() noexcept
+      { delete _M_ptr; }
+
+      virtual void
+      _M_destroy() noexcept
+      { delete this; }
+
+      virtual void*
+      _M_get_deleter(const std::type_info&) noexcept
+      { return nullptr; }
+
+      _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
+      _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
+
+    private:
+      _Ptr             _M_ptr;
+    };
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
+
+  template<int _Nm, typename _Tp,
+	   bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+    struct _Sp_ebo_helper;
+
+  /// Specialization using EBO.
+  template<int _Nm, typename _Tp>
+    struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
+    {
+      explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
+
+      static _Tp&
+      _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
+    };
+
+  /// Specialization not using EBO.
+  template<int _Nm, typename _Tp>
+    struct _Sp_ebo_helper<_Nm, _Tp, false>
+    {
+      explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
+
+      static _Tp&
+      _S_get(_Sp_ebo_helper& __eboh)
+      { return __eboh._M_tp; }
+
+    private:
+      _Tp _M_tp;
+    };
+
+  // Support for custom deleter and/or allocator
+  template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
+    class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
+    {
+      class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
+      {
+	typedef _Sp_ebo_helper<0, _Deleter>	_Del_base;
+	typedef _Sp_ebo_helper<1, _Alloc>	_Alloc_base;
+
+      public:
+	_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
+	: _M_ptr(__p), _Del_base(__d), _Alloc_base(__a)
+	{ }
+
+	_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
+	_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
+
+	_Ptr _M_ptr;
+      };
+
+    public:
+      // __d(__p) must not throw.
+      _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
+      : _M_impl(__p, __d, _Alloc()) { }
+
+      // __d(__p) must not throw.
+      _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
+      : _M_impl(__p, __d, __a) { }
+
+      ~_Sp_counted_deleter() noexcept { }
+
+      virtual void
+      _M_dispose() noexcept
+      { _M_impl._M_del()(_M_impl._M_ptr); }
+
+      virtual void
+      _M_destroy() noexcept
+      {
+	typedef typename allocator_traits<_Alloc>::template
+	  rebind_traits<_Sp_counted_deleter> _Alloc_traits;
+	typename _Alloc_traits::allocator_type __a(_M_impl._M_alloc());
+	_Alloc_traits::destroy(__a, this);
+	_Alloc_traits::deallocate(__a, this, 1);
+      }
+
+      virtual void*
+      _M_get_deleter(const std::type_info& __ti) noexcept
+      {
+#ifdef __GXX_RTTI
+        return __ti == typeid(_Deleter) ? &_M_impl._M_del() : nullptr;
+#else
+        return nullptr;
+#endif
+      }
+
+    private:
+      _Impl _M_impl;
+    };
+
+  // helpers for make_shared / allocate_shared
+
+  struct _Sp_make_shared_tag { };
+
+  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
+    class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
+    {
+      class _Impl : _Sp_ebo_helper<0, _Alloc>
+      {
+	typedef _Sp_ebo_helper<0, _Alloc>	_A_base;
+
+      public:
+	explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
+
+	_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
+
+	__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+      };
+
+    public:
+      template<typename... _Args>
+	_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
+	: _M_impl(__a)
+	{
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 2070.  allocate_shared should use allocator_traits<A>::construct
+	  allocator_traits<_Alloc>::construct(__a, _M_ptr(),
+	      std::forward<_Args>(__args)...); // might throw
+	}
+
+      ~_Sp_counted_ptr_inplace() noexcept { }
+
+      virtual void
+      _M_dispose() noexcept
+      {
+	allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
+      }
+
+      // Override because the allocator needs to know the dynamic type
+      virtual void
+      _M_destroy() noexcept
+      {
+	typedef typename allocator_traits<_Alloc>::template
+	  rebind_traits<_Sp_counted_ptr_inplace> _Alloc_traits;
+	typename _Alloc_traits::allocator_type __a(_M_impl._M_alloc());
+	_Alloc_traits::destroy(__a, this);
+	_Alloc_traits::deallocate(__a, this, 1);
+      }
+
+      // Sneaky trick so __shared_ptr can get the managed pointer
+      virtual void*
+      _M_get_deleter(const std::type_info& __ti) noexcept
+      {
+#ifdef __GXX_RTTI
+	if (__ti == typeid(_Sp_make_shared_tag))
+	  return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
+#endif
+	return nullptr;
+      }
+
+    private:
+      _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
+
+      _Impl _M_impl;
+    };
+
+
+  template<_Lock_policy _Lp>
+    class __shared_count
+    {
+    public:
+      constexpr __shared_count() noexcept : _M_pi(0)
+      { }
+
+      template<typename _Ptr>
+        explicit
+	__shared_count(_Ptr __p) : _M_pi(0)
+	{
+	  __try
+	    {
+	      _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
+	    }
+	  __catch(...)
+	    {
+	      delete __p;
+	      __throw_exception_again;
+	    }
+	}
+
+      template<typename _Ptr, typename _Deleter>
+	__shared_count(_Ptr __p, _Deleter __d)
+	: __shared_count(__p, std::move(__d), allocator<void>())
+	{ }
+
+      template<typename _Ptr, typename _Deleter, typename _Alloc>
+	__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
+	{
+	  typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
+	  typedef typename allocator_traits<_Alloc>::template
+	    rebind_traits<_Sp_cd_type> _Alloc_traits;
+	  typename _Alloc_traits::allocator_type __a2(__a);
+	  _Sp_cd_type* __mem = 0;
+	  __try
+	    {
+	      __mem = _Alloc_traits::allocate(__a2, 1);
+	      _Alloc_traits::construct(__a2, __mem,
+		  __p, std::move(__d), std::move(__a));
+	      _M_pi = __mem;
+	    }
+	  __catch(...)
+	    {
+	      __d(__p); // Call _Deleter on __p.
+	      if (__mem)
+	        _Alloc_traits::deallocate(__a2, __mem, 1);
+	      __throw_exception_again;
+	    }
+	}
+
+      template<typename _Tp, typename _Alloc, typename... _Args>
+	__shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
+		       _Args&&... __args)
+	: _M_pi(0)
+	{
+	  typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
+	  typedef typename allocator_traits<_Alloc>::template
+	    rebind_traits<_Sp_cp_type> _Alloc_traits;
+	  typename _Alloc_traits::allocator_type __a2(__a);
+	  _Sp_cp_type* __mem = _Alloc_traits::allocate(__a2, 1);
+	  __try
+	    {
+	      _Alloc_traits::construct(__a2, __mem, std::move(__a),
+		    std::forward<_Args>(__args)...);
+	      _M_pi = __mem;
+	    }
+	  __catch(...)
+	    {
+	      _Alloc_traits::deallocate(__a2, __mem, 1);
+	      __throw_exception_again;
+	    }
+	}
+
+#if _GLIBCXX_USE_DEPRECATED
+      // Special case for auto_ptr<_Tp> to provide the strong guarantee.
+      template<typename _Tp>
+        explicit
+	__shared_count(std::auto_ptr<_Tp>&& __r);
+#endif
+
+      // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
+      template<typename _Tp, typename _Del>
+        explicit
+	__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
+	{
+	  using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
+	  using _Del2 = typename conditional<is_reference<_Del>::value,
+	      reference_wrapper<typename remove_reference<_Del>::type>,
+	      _Del>::type;
+	  using _Sp_cd_type
+	    = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
+	  using _Alloc = allocator<_Sp_cd_type>;
+	  using _Alloc_traits = allocator_traits<_Alloc>;
+	  _Alloc __a;
+	  _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
+	  _Alloc_traits::construct(__a, __mem, __r.release(),
+				   __r.get_deleter());  // non-throwing
+	  _M_pi = __mem;
+	}
+
+      // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
+      explicit __shared_count(const __weak_count<_Lp>& __r);
+
+      // Does not throw if __r._M_get_use_count() == 0, caller must check.
+      explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
+
+      ~__shared_count() noexcept
+      {
+	if (_M_pi != nullptr)
+	  _M_pi->_M_release();
+      }
+
+      __shared_count(const __shared_count& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_add_ref_copy();
+      }
+
+      __shared_count&
+      operator=(const __shared_count& __r) noexcept
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	if (__tmp != _M_pi)
+	  {
+	    if (__tmp != 0)
+	      __tmp->_M_add_ref_copy();
+	    if (_M_pi != 0)
+	      _M_pi->_M_release();
+	    _M_pi = __tmp;
+	  }
+	return *this;
+      }
+
+      void
+      _M_swap(__shared_count& __r) noexcept
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	__r._M_pi = _M_pi;
+	_M_pi = __tmp;
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
+
+      bool
+      _M_unique() const noexcept
+      { return this->_M_get_use_count() == 1; }
+
+      void*
+      _M_get_deleter(const std::type_info& __ti) const noexcept
+      { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
+
+      bool
+      _M_less(const __shared_count& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      bool
+      _M_less(const __weak_count<_Lp>& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      // Friend function injected into enclosing namespace and found by ADL
+      friend inline bool
+      operator==(const __shared_count& __a, const __shared_count& __b) noexcept
+      { return __a._M_pi == __b._M_pi; }
+
+    private:
+      friend class __weak_count<_Lp>;
+
+      _Sp_counted_base<_Lp>*  _M_pi;
+    };
+
+
+  template<_Lock_policy _Lp>
+    class __weak_count
+    {
+    public:
+      constexpr __weak_count() noexcept : _M_pi(0)
+      { }
+
+      __weak_count(const __shared_count<_Lp>& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_add_ref();
+      }
+
+      __weak_count(const __weak_count<_Lp>& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_add_ref();
+      }
+
+      ~__weak_count() noexcept
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_release();
+      }
+
+      __weak_count<_Lp>&
+      operator=(const __shared_count<_Lp>& __r) noexcept
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	if (__tmp != 0)
+	  __tmp->_M_weak_add_ref();
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_release();
+	_M_pi = __tmp;
+	return *this;
+      }
+
+      __weak_count<_Lp>&
+      operator=(const __weak_count<_Lp>& __r) noexcept
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	if (__tmp != 0)
+	  __tmp->_M_weak_add_ref();
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_release();
+	_M_pi = __tmp;
+	return *this;
+      }
+
+      void
+      _M_swap(__weak_count<_Lp>& __r) noexcept
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	__r._M_pi = _M_pi;
+	_M_pi = __tmp;
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
+
+      bool
+      _M_less(const __weak_count& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      bool
+      _M_less(const __shared_count<_Lp>& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      // Friend function injected into enclosing namespace and found by ADL
+      friend inline bool
+      operator==(const __weak_count& __a, const __weak_count& __b) noexcept
+      { return __a._M_pi == __b._M_pi; }
+
+    private:
+      friend class __shared_count<_Lp>;
+
+      _Sp_counted_base<_Lp>*  _M_pi;
+    };
+
+  // Now that __weak_count is defined we can define this constructor:
+  template<_Lock_policy _Lp>
+    inline
+    __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
+    : _M_pi(__r._M_pi)
+    {
+      if (_M_pi != nullptr)
+	_M_pi->_M_add_ref_lock();
+      else
+	__throw_bad_weak_ptr();
+    }
+
+  // Now that __weak_count is defined we can define this constructor:
+  template<_Lock_policy _Lp>
+    inline
+    __shared_count<_Lp>::
+    __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
+    : _M_pi(__r._M_pi)
+    {
+      if (_M_pi != nullptr)
+	if (!_M_pi->_M_add_ref_lock_nothrow())
+	  _M_pi = nullptr;
+    }
+
+  // Support for enable_shared_from_this.
+
+  // Friend of __enable_shared_from_this.
+  template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
+    void
+    __enable_shared_from_this_helper(const __shared_count<_Lp>&,
+				     const __enable_shared_from_this<_Tp1,
+				     _Lp>*, const _Tp2*) noexcept;
+
+  // Friend of enable_shared_from_this.
+  template<typename _Tp1, typename _Tp2>
+    void
+    __enable_shared_from_this_helper(const __shared_count<>&,
+				     const enable_shared_from_this<_Tp1>*,
+				     const _Tp2*) noexcept;
+
+  template<_Lock_policy _Lp>
+    inline void
+    __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
+    { }
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr
+    {
+    public:
+      typedef _Tp   element_type;
+
+      constexpr __shared_ptr() noexcept
+      : _M_ptr(0), _M_refcount()
+      { }
+
+      template<typename _Tp1>
+	explicit __shared_ptr(_Tp1* __p)
+        : _M_ptr(__p), _M_refcount(__p)
+	{
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  static_assert( !is_void<_Tp>::value, "incomplete type" );
+	  static_assert( sizeof(_Tp1) > 0, "incomplete type" );
+	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
+	}
+
+      template<typename _Tp1, typename _Deleter>
+	__shared_ptr(_Tp1* __p, _Deleter __d)
+	: _M_ptr(__p), _M_refcount(__p, __d)
+	{
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
+	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
+	}
+
+      template<typename _Tp1, typename _Deleter, typename _Alloc>
+	__shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
+	: _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
+	{
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
+	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
+	}
+
+      template<typename _Deleter>
+	__shared_ptr(nullptr_t __p, _Deleter __d)
+	: _M_ptr(0), _M_refcount(__p, __d)
+	{ }
+
+      template<typename _Deleter, typename _Alloc>
+        __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
+	: _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
+	{ }
+
+      template<typename _Tp1>
+	__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
+	: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
+	{ }
+
+      __shared_ptr(const __shared_ptr&) noexcept = default;
+      __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
+      ~__shared_ptr() = default;
+
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+	: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
+	{ }
+
+      __shared_ptr(__shared_ptr&& __r) noexcept
+      : _M_ptr(__r._M_ptr), _M_refcount()
+      {
+	_M_refcount._M_swap(__r._M_refcount);
+	__r._M_ptr = 0;
+      }
+
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	__shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
+	: _M_ptr(__r._M_ptr), _M_refcount()
+	{
+	  _M_refcount._M_swap(__r._M_refcount);
+	  __r._M_ptr = 0;
+	}
+
+      template<typename _Tp1>
+	explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
+	: _M_refcount(__r._M_refcount) // may throw
+	{
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+
+	  // It is now safe to copy __r._M_ptr, as
+	  // _M_refcount(__r._M_refcount) did not throw.
+	  _M_ptr = __r._M_ptr;
+	}
+
+      // If an exception is thrown this constructor has no effect.
+      template<typename _Tp1, typename _Del>
+	__shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
+	: _M_ptr(__r.get()), _M_refcount()
+	{
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  auto __raw = _S_raw_ptr(__r.get());
+	  _M_refcount = __shared_count<_Lp>(std::move(__r));
+	  __enable_shared_from_this_helper(_M_refcount, __raw, __raw);
+	}
+
+#if _GLIBCXX_USE_DEPRECATED
+      // Postcondition: use_count() == 1 and __r.get() == 0
+      template<typename _Tp1>
+	__shared_ptr(std::auto_ptr<_Tp1>&& __r);
+#endif
+
+      /* TODO: use delegating constructor */
+      constexpr __shared_ptr(nullptr_t) noexcept
+      : _M_ptr(0), _M_refcount()
+      { }
+
+      template<typename _Tp1>
+	__shared_ptr&
+	operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+	{
+	  _M_ptr = __r._M_ptr;
+	  _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
+	  return *this;
+	}
+
+#if _GLIBCXX_USE_DEPRECATED
+      template<typename _Tp1>
+	__shared_ptr&
+	operator=(std::auto_ptr<_Tp1>&& __r)
+	{
+	  __shared_ptr(std::move(__r)).swap(*this);
+	  return *this;
+	}
+#endif
+
+      __shared_ptr&
+      operator=(__shared_ptr&& __r) noexcept
+      {
+	__shared_ptr(std::move(__r)).swap(*this);
+	return *this;
+      }
+
+      template<class _Tp1>
+	__shared_ptr&
+	operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
+	{
+	  __shared_ptr(std::move(__r)).swap(*this);
+	  return *this;
+	}
+
+      template<typename _Tp1, typename _Del>
+	__shared_ptr&
+	operator=(std::unique_ptr<_Tp1, _Del>&& __r)
+	{
+	  __shared_ptr(std::move(__r)).swap(*this);
+	  return *this;
+	}
+
+      void
+      reset() noexcept
+      { __shared_ptr().swap(*this); }
+
+      template<typename _Tp1>
+	void
+	reset(_Tp1* __p) // _Tp1 must be complete.
+	{
+	  // Catch self-reset errors.
+	  _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
+	  __shared_ptr(__p).swap(*this);
+	}
+
+      template<typename _Tp1, typename _Deleter>
+	void
+	reset(_Tp1* __p, _Deleter __d)
+	{ __shared_ptr(__p, __d).swap(*this); }
+
+      template<typename _Tp1, typename _Deleter, typename _Alloc>
+	void
+        reset(_Tp1* __p, _Deleter __d, _Alloc __a)
+        { __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
+
+      // Allow class instantiation when _Tp is [cv-qual] void.
+      typename std::add_lvalue_reference<_Tp>::type
+      operator*() const noexcept
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	return *_M_ptr;
+      }
+
+      _Tp*
+      operator->() const noexcept
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	return _M_ptr;
+      }
+
+      _Tp*
+      get() const noexcept
+      { return _M_ptr; }
+
+      explicit operator bool() const // never throws
+      { return _M_ptr == 0 ? false : true; }
+
+      bool
+      unique() const noexcept
+      { return _M_refcount._M_unique(); }
+
+      long
+      use_count() const noexcept
+      { return _M_refcount._M_get_use_count(); }
+
+      void
+      swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
+      {
+	std::swap(_M_ptr, __other._M_ptr);
+	_M_refcount._M_swap(__other._M_refcount);
+      }
+
+      template<typename _Tp1>
+	bool
+	owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
+	{ return _M_refcount._M_less(__rhs._M_refcount); }
+
+      template<typename _Tp1>
+	bool
+	owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
+	{ return _M_refcount._M_less(__rhs._M_refcount); }
+
+#ifdef __GXX_RTTI
+    protected:
+      // This constructor is non-standard, it is used by allocate_shared.
+      template<typename _Alloc, typename... _Args>
+	__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
+		     _Args&&... __args)
+	: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
+				std::forward<_Args>(__args)...)
+	{
+	  // _M_ptr needs to point to the newly constructed object.
+	  // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
+	  void* __p = _M_refcount._M_get_deleter(typeid(__tag));
+	  _M_ptr = static_cast<_Tp*>(__p);
+	  __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
+	}
+#else
+      template<typename _Alloc>
+        struct _Deleter
+        {
+          void operator()(_Tp* __ptr)
+          {
+	    typedef allocator_traits<_Alloc> _Alloc_traits;
+	    _Alloc_traits::destroy(_M_alloc, __ptr);
+	    _Alloc_traits::deallocate(_M_alloc, __ptr, 1);
+          }
+          _Alloc _M_alloc;
+        };
+
+      template<typename _Alloc, typename... _Args>
+	__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
+		     _Args&&... __args)
+	: _M_ptr(), _M_refcount()
+        {
+	  typedef typename _Alloc::template rebind<_Tp>::other _Alloc2;
+          _Deleter<_Alloc2> __del = { _Alloc2(__a) };
+	  typedef allocator_traits<_Alloc2> __traits;
+          _M_ptr = __traits::allocate(__del._M_alloc, 1);
+	  __try
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 2070. allocate_shared should use allocator_traits<A>::construct
+	      __traits::construct(__del._M_alloc, _M_ptr,
+		                  std::forward<_Args>(__args)...);
+	    }
+	  __catch(...)
+	    {
+	      __traits::deallocate(__del._M_alloc, _M_ptr, 1);
+	      __throw_exception_again;
+	    }
+          __shared_count<_Lp> __count(_M_ptr, __del, __del._M_alloc);
+          _M_refcount._M_swap(__count);
+	  __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
+        }
+#endif
+
+      template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
+	       typename... _Args>
+	friend __shared_ptr<_Tp1, _Lp1>
+	__allocate_shared(const _Alloc& __a, _Args&&... __args);
+
+      // This constructor is used by __weak_ptr::lock() and
+      // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
+      __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
+      : _M_refcount(__r._M_refcount, std::nothrow)
+      {
+	_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
+      }
+
+      friend class __weak_ptr<_Tp, _Lp>;
+
+    private:
+      void*
+      _M_get_deleter(const std::type_info& __ti) const noexcept
+      { return _M_refcount._M_get_deleter(__ti); }
+
+      template<typename _Tp1>
+	static _Tp1*
+	_S_raw_ptr(_Tp1* __ptr)
+	{ return __ptr; }
+
+      template<typename _Tp1>
+	static auto
+	_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
+	{ return std::__addressof(*__ptr); }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+
+      template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
+	friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
+
+      _Tp*	   	   _M_ptr;         // Contained pointer.
+      __shared_count<_Lp>  _M_refcount;    // Reference counter.
+    };
+
+
+  // 20.7.2.2.7 shared_ptr comparisons
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator==(const __shared_ptr<_Tp1, _Lp>& __a,
+	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return __a.get() == __b.get(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !__a; }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !__a; }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
+	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return __a.get() != __b.get(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator<(const __shared_ptr<_Tp1, _Lp>& __a,
+	      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    {
+      typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
+      return std::less<_CT>()(__a.get(), __b.get());
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return std::less<_Tp*>()(__a.get(), nullptr); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return std::less<_Tp*>()(nullptr, __a.get()); }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
+	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return !(__b < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !(nullptr < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator>(const __shared_ptr<_Tp1, _Lp>& __a,
+	      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return (__b < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return std::less<_Tp*>()(nullptr, __a.get()); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return std::less<_Tp*>()(__a.get(), nullptr); }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
+	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return !(__a < __b); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !(nullptr < __a); }
+
+  template<typename _Sp>
+    struct _Sp_less : public binary_function<_Sp, _Sp, bool>
+    {
+      bool
+      operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
+      {
+	typedef typename _Sp::element_type element_type;
+	return std::less<element_type*>()(__lhs.get(), __rhs.get());
+      }
+    };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct less<__shared_ptr<_Tp, _Lp>>
+    : public _Sp_less<__shared_ptr<_Tp, _Lp>>
+    { };
+
+  // 20.7.2.2.8 shared_ptr specialized algorithms.
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
+    { __a.swap(__b); }
+
+  // 20.7.2.2.9 shared_ptr casts
+
+  // The seemingly equivalent code:
+  // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
+  // will eventually result in undefined behaviour, attempting to
+  // delete the same object twice.
+  /// static_pointer_cast
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
+
+  // The seemingly equivalent code:
+  // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
+  // will eventually result in undefined behaviour, attempting to
+  // delete the same object twice.
+  /// const_pointer_cast
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
+
+  // The seemingly equivalent code:
+  // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
+  // will eventually result in undefined behaviour, attempting to
+  // delete the same object twice.
+  /// dynamic_pointer_cast
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
+	return __shared_ptr<_Tp, _Lp>(__r, __p);
+      return __shared_ptr<_Tp, _Lp>();
+    }
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __weak_ptr
+    {
+    public:
+      typedef _Tp element_type;
+
+      constexpr __weak_ptr() noexcept
+      : _M_ptr(0), _M_refcount()
+      { }
+
+      __weak_ptr(const __weak_ptr&) noexcept = default;
+      __weak_ptr& operator=(const __weak_ptr&) noexcept = default;
+      ~__weak_ptr() = default;
+
+      // The "obvious" converting constructor implementation:
+      //
+      //  template<typename _Tp1>
+      //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
+      //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
+      //    { }
+      //
+      // has a serious problem.
+      //
+      //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
+      //  conversion may require access to *__r._M_ptr (virtual inheritance).
+      //
+      // It is not possible to avoid spurious access violations since
+      // in multithreaded programs __r._M_ptr may be invalidated at any point.
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	__weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
+	: _M_refcount(__r._M_refcount)
+        { _M_ptr = __r.lock().get(); }
+
+      template<typename _Tp1, typename = typename
+	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
+	__weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+	: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
+	{ }
+
+      template<typename _Tp1>
+	__weak_ptr&
+	operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
+	{
+	  _M_ptr = __r.lock().get();
+	  _M_refcount = __r._M_refcount;
+	  return *this;
+	}
+
+      template<typename _Tp1>
+	__weak_ptr&
+	operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+	{
+	  _M_ptr = __r._M_ptr;
+	  _M_refcount = __r._M_refcount;
+	  return *this;
+	}
+
+      __shared_ptr<_Tp, _Lp>
+      lock() const noexcept
+      { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
+
+      long
+      use_count() const noexcept
+      { return _M_refcount._M_get_use_count(); }
+
+      bool
+      expired() const noexcept
+      { return _M_refcount._M_get_use_count() == 0; }
+
+      template<typename _Tp1>
+	bool
+	owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
+	{ return _M_refcount._M_less(__rhs._M_refcount); }
+
+      template<typename _Tp1>
+	bool
+	owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
+	{ return _M_refcount._M_less(__rhs._M_refcount); }
+
+      void
+      reset() noexcept
+      { __weak_ptr().swap(*this); }
+
+      void
+      swap(__weak_ptr& __s) noexcept
+      {
+	std::swap(_M_ptr, __s._M_ptr);
+	_M_refcount._M_swap(__s._M_refcount);
+      }
+
+    private:
+      // Used by __enable_shared_from_this.
+      void
+      _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
+      {
+	_M_ptr = __ptr;
+	_M_refcount = __refcount;
+      }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+      friend class __enable_shared_from_this<_Tp, _Lp>;
+      friend class enable_shared_from_this<_Tp>;
+
+      _Tp*	 	 _M_ptr;         // Contained pointer.
+      __weak_count<_Lp>  _M_refcount;    // Reference counter.
+    };
+
+  // 20.7.2.3.6 weak_ptr specialized algorithms.
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
+    { __a.swap(__b); }
+
+  template<typename _Tp, typename _Tp1>
+    struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __lhs, const _Tp& __rhs) const
+      { return __lhs.owner_before(__rhs); }
+
+      bool
+      operator()(const _Tp& __lhs, const _Tp1& __rhs) const
+      { return __lhs.owner_before(__rhs); }
+
+      bool
+      operator()(const _Tp1& __lhs, const _Tp& __rhs) const
+      { return __lhs.owner_before(__rhs); }
+    };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct owner_less<__shared_ptr<_Tp, _Lp>>
+    : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
+    { };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct owner_less<__weak_ptr<_Tp, _Lp>>
+    : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
+    { };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __enable_shared_from_this
+    {
+    protected:
+      constexpr __enable_shared_from_this() noexcept { }
+
+      __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
+
+      __enable_shared_from_this&
+      operator=(const __enable_shared_from_this&) noexcept
+      { return *this; }
+
+      ~__enable_shared_from_this() { }
+
+    public:
+      __shared_ptr<_Tp, _Lp>
+      shared_from_this()
+      { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
+
+      __shared_ptr<const _Tp, _Lp>
+      shared_from_this() const
+      { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
+
+    private:
+      template<typename _Tp1>
+	void
+	_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
+	{ _M_weak_this._M_assign(__p, __n); }
+
+      template<typename _Tp1>
+	friend void
+	__enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
+					 const __enable_shared_from_this* __pe,
+					 const _Tp1* __px) noexcept
+	{
+	  if (__pe != 0)
+	    __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
+	}
+
+      mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
+    };
+
+
+  template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
+    inline __shared_ptr<_Tp, _Lp>
+    __allocate_shared(const _Alloc& __a, _Args&&... __args)
+    {
+      return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
+				    std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp, typename... _Args>
+    inline __shared_ptr<_Tp, _Lp>
+    __make_shared(_Args&&... __args)
+    {
+      typedef typename std::remove_const<_Tp>::type _Tp_nc;
+      return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
+					      std::forward<_Args>(__args)...);
+    }
+
+  /// std::hash specialization for __shared_ptr.
+  template<typename _Tp, _Lock_policy _Lp>
+    struct hash<__shared_ptr<_Tp, _Lp>>
+    : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
+    {
+      size_t
+      operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
+      { return std::hash<_Tp*>()(__s.get()); }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _SHARED_PTR_BASE_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/slice_array.h b/gcc-4.9/libstdc++-v3/include/bits/slice_array.h
new file mode 100644
index 0000000..c98dfec
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/slice_array.h
@@ -0,0 +1,274 @@
+// The template and inlines for the -*- C++ -*- slice_array class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/slice_array.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _SLICE_ARRAY_H
+#define _SLICE_ARRAY_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup numeric_arrays
+   * @{
+   */
+
+  /**
+   *  @brief  Class defining one-dimensional subset of an array.
+   *
+   *  The slice class represents a one-dimensional subset of an array,
+   *  specified by three parameters: start offset, size, and stride.  The
+   *  start offset is the index of the first element of the array that is part
+   *  of the subset.  The size is the total number of elements in the subset.
+   *  Stride is the distance between each successive array element to include
+   *  in the subset.
+   *
+   *  For example, with an array of size 10, and a slice with offset 1, size 3
+   *  and stride 2, the subset consists of array elements 1, 3, and 5.
+   */
+  class slice
+  {
+  public:
+    ///  Construct an empty slice.
+    slice();
+
+    /**
+     *  @brief  Construct a slice.
+     *
+     *  @param  __o  Offset in array of first element.
+     *  @param  __d  Number of elements in slice.
+     *  @param  __s  Stride between array elements.
+     */
+    slice(size_t __o, size_t __d, size_t __s);
+
+    ///  Return array offset of first slice element.
+    size_t start() const;
+    ///  Return size of slice.
+    size_t size() const;
+    ///  Return array stride of slice.
+    size_t stride() const;
+
+  private:
+    size_t _M_off;                      // offset
+    size_t _M_sz;			// size
+    size_t _M_st;			// stride unit
+  };
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 543. valarray slice default constructor
+  inline
+  slice::slice() 
+  : _M_off(0), _M_sz(0), _M_st(0) {}
+
+  inline
+  slice::slice(size_t __o, size_t __d, size_t __s)
+  : _M_off(__o), _M_sz(__d), _M_st(__s) {}
+
+  inline size_t
+  slice::start() const
+  { return _M_off; }
+
+  inline size_t
+  slice::size() const
+  { return _M_sz; }
+
+  inline size_t
+  slice::stride() const
+  { return _M_st; }
+
+  /**
+   *  @brief  Reference to one-dimensional subset of an array.
+   *
+   *  A slice_array is a reference to the actual elements of an array
+   *  specified by a slice.  The way to get a slice_array is to call
+   *  operator[](slice) on a valarray.  The returned slice_array then permits
+   *  carrying operations out on the referenced subset of elements in the
+   *  original valarray.  For example, operator+=(valarray) will add values
+   *  to the subset of elements in the underlying valarray this slice_array
+   *  refers to.
+   *
+   *  @param  Tp  Element type.
+   */
+  template<typename _Tp>
+    class slice_array
+    {
+    public:
+      typedef _Tp value_type;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 253. valarray helper functions are almost entirely useless
+
+      ///  Copy constructor.  Both slices refer to the same underlying array.
+      slice_array(const slice_array&);
+
+      ///  Assignment operator.  Assigns slice elements to corresponding
+      ///  elements of @a a.
+      slice_array& operator=(const slice_array&);
+
+      ///  Assign slice elements to corresponding elements of @a v.
+      void operator=(const valarray<_Tp>&) const;
+      ///  Multiply slice elements by corresponding elements of @a v.
+      void operator*=(const valarray<_Tp>&) const;
+      ///  Divide slice elements by corresponding elements of @a v.
+      void operator/=(const valarray<_Tp>&) const;
+      ///  Modulo slice elements by corresponding elements of @a v.
+      void operator%=(const valarray<_Tp>&) const;
+      ///  Add corresponding elements of @a v to slice elements.
+      void operator+=(const valarray<_Tp>&) const;
+      ///  Subtract corresponding elements of @a v from slice elements.
+      void operator-=(const valarray<_Tp>&) const;
+      ///  Logical xor slice elements with corresponding elements of @a v.
+      void operator^=(const valarray<_Tp>&) const;
+      ///  Logical and slice elements with corresponding elements of @a v.
+      void operator&=(const valarray<_Tp>&) const;
+      ///  Logical or slice elements with corresponding elements of @a v.
+      void operator|=(const valarray<_Tp>&) const;
+      ///  Left shift slice elements by corresponding elements of @a v.
+      void operator<<=(const valarray<_Tp>&) const;
+      ///  Right shift slice elements by corresponding elements of @a v.
+      void operator>>=(const valarray<_Tp>&) const;
+      ///  Assign all slice elements to @a t.
+      void operator=(const _Tp &) const;
+      //        ~slice_array ();
+
+      template<class _Dom>
+        void operator=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator*=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator/=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator%=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator+=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator-=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator^=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator&=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator|=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator<<=(const _Expr<_Dom, _Tp>&) const;
+      template<class _Dom>
+	void operator>>=(const _Expr<_Dom, _Tp>&) const;
+
+    private:
+      friend class valarray<_Tp>;
+      slice_array(_Array<_Tp>, const slice&);
+
+      const size_t      _M_sz;
+      const size_t      _M_stride;
+      const _Array<_Tp> _M_array;
+
+      // not implemented
+      slice_array();
+    };
+
+  template<typename _Tp>
+    inline
+    slice_array<_Tp>::slice_array(_Array<_Tp> __a, const slice& __s)
+    : _M_sz(__s.size()), _M_stride(__s.stride()),
+      _M_array(__a.begin() + __s.start()) {}
+
+  template<typename _Tp>
+    inline
+    slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
+    : _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}
+
+  //    template<typename _Tp>
+  //    inline slice_array<_Tp>::~slice_array () {}
+
+  template<typename _Tp>
+    inline slice_array<_Tp>&
+    slice_array<_Tp>::operator=(const slice_array<_Tp>& __a)
+    {
+      std::__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride,
+			   _M_array, _M_stride);
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline void
+    slice_array<_Tp>::operator=(const _Tp& __t) const
+    { std::__valarray_fill(_M_array, _M_sz, _M_stride, __t); }
+
+  template<typename _Tp>
+    inline void
+    slice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
+    { std::__valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); }
+
+  template<typename _Tp>
+  template<class _Dom>
+    inline void
+    slice_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const
+    { std::__valarray_copy(__e, _M_sz, _M_array, _M_stride); }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(_Op,_Name)				\
+  template<typename _Tp>						\
+    inline void								\
+    slice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const	\
+    {									\
+      _Array_augmented_##_Name(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v));\
+    }									\
+									\
+  template<typename _Tp>                                                \
+    template<class _Dom>				                \
+      inline void							\
+      slice_array<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) const\
+      {									\
+	  _Array_augmented_##_Name(_M_array, _M_stride, __e, _M_sz);	\
+      }
+
+
+_DEFINE_VALARRAY_OPERATOR(*, __multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, __divides)
+_DEFINE_VALARRAY_OPERATOR(%, __modulus)
+_DEFINE_VALARRAY_OPERATOR(+, __plus)
+_DEFINE_VALARRAY_OPERATOR(-, __minus)
+_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
+_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
+_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
+_DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR
+
+  // @} group numeric_arrays
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _SLICE_ARRAY_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/sstream.tcc b/gcc-4.9/libstdc++-v3/include/bits/sstream.tcc
new file mode 100644
index 0000000..736466e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/sstream.tcc
@@ -0,0 +1,288 @@
+// String based streams -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/sstream.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{sstream}
+ */
+
+//
+// ISO C++ 14882: 27.7  String-based streams
+//
+
+#ifndef _SSTREAM_TCC
+#define _SSTREAM_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      if (this->eback() < this->gptr())
+	{
+	  // Try to put back __c into input sequence in one of three ways.
+	  // Order these tests done in is unspecified by the standard.
+	  const bool __testeof = traits_type::eq_int_type(__c, __ret);
+	  if (!__testeof)
+	    {
+	      const bool __testeq = traits_type::eq(traits_type::
+						    to_char_type(__c),
+						    this->gptr()[-1]);	  
+	      const bool __testout = this->_M_mode & ios_base::out;
+	      if (__testeq || __testout)
+		{
+		  this->gbump(-1);
+		  if (!__testeq)
+		    *this->gptr() = traits_type::to_char_type(__c);
+		  __ret = __c;
+		}
+	    }
+	  else
+	    {
+	      this->gbump(-1);
+	      __ret = traits_type::not_eof(__c);
+	    }
+	}
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      const bool __testout = this->_M_mode & ios_base::out;
+      if (__builtin_expect(!__testout, false))
+	return traits_type::eof();
+
+      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      if (__builtin_expect(__testeof, false))
+	return traits_type::not_eof(__c);
+
+      const __size_type __capacity = _M_string.capacity();
+      const __size_type __max_size = _M_string.max_size();
+      const bool __testput = this->pptr() < this->epptr();
+      if (__builtin_expect(!__testput && __capacity == __max_size, false))
+	return traits_type::eof();
+
+      // Try to append __c into output sequence in one of two ways.
+      // Order these tests done in is unspecified by the standard.
+      const char_type __conv = traits_type::to_char_type(__c);
+      if (!__testput)
+	{
+	  // NB: Start ostringstream buffers at 512 chars.  This is an
+	  // experimental value (pronounced "arbitrary" in some of the
+	  // hipper English-speaking countries), and can be changed to
+	  // suit particular needs.
+	  //
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 169. Bad efficiency of overflow() mandated
+	  // 432. stringbuf::overflow() makes only one write position
+	  //      available
+	  const __size_type __opt_len = std::max(__size_type(2 * __capacity),
+						 __size_type(512));
+	  const __size_type __len = std::min(__opt_len, __max_size);
+	  __string_type __tmp;
+	  __tmp.reserve(__len);
+	  if (this->pbase())
+	    __tmp.assign(this->pbase(), this->epptr() - this->pbase());
+	  __tmp.push_back(__conv);
+	  _M_string.swap(__tmp);
+	  _M_sync(const_cast<char_type*>(_M_string.data()),
+		  this->gptr() - this->eback(), this->pptr() - this->pbase());
+	}
+      else
+	*this->pptr() = __conv;
+      this->pbump(1);
+      return __c;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = this->_M_mode & ios_base::in;
+      if (__testin)
+	{
+	  // Update egptr() to match the actual string end.
+	  _M_update_egptr();
+
+	  if (this->gptr() < this->egptr())
+	    __ret = traits_type::to_int_type(*this->gptr());
+	}
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __ret =  pos_type(off_type(-1));
+      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const bool __testboth = __testin && __testout && __way != ios_base::cur;
+      __testin &= !(__mode & ios_base::out);
+      __testout &= !(__mode & ios_base::in);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 453. basic_stringbuf::seekoff need not always fail for an empty stream.
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !__off) && (__testin || __testout || __testboth))
+	{
+	  _M_update_egptr();
+
+	  off_type __newoffi = __off;
+	  off_type __newoffo = __newoffi;
+	  if (__way == ios_base::cur)
+	    {
+	      __newoffi += this->gptr() - __beg;
+	      __newoffo += this->pptr() - __beg;
+	    }
+	  else if (__way == ios_base::end)
+	    __newoffo = __newoffi += this->egptr() - __beg;
+
+	  if ((__testin || __testboth)
+	      && __newoffi >= 0
+	      && this->egptr() - __beg >= __newoffi)
+	    {
+	      this->setg(this->eback(), this->eback() + __newoffi,
+			 this->egptr());
+	      __ret = pos_type(__newoffi);
+	    }
+	  if ((__testout || __testboth)
+	      && __newoffo >= 0
+	      && this->egptr() - __beg >= __newoffo)
+	    {
+	      _M_pbump(this->pbase(), this->epptr(), __newoffo);
+	      __ret = pos_type(__newoffo);
+	    }
+	}
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __ret =  pos_type(off_type(-1));
+      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !off_type(__sp)) && (__testin || __testout))
+	{
+	  _M_update_egptr();
+
+	  const off_type __pos(__sp);
+	  const bool __testpos = (0 <= __pos
+				  && __pos <= this->egptr() - __beg);
+	  if (__testpos)
+	    {
+	      if (__testin)
+		this->setg(this->eback(), this->eback() + __pos,
+			   this->egptr());
+	      if (__testout)
+		_M_pbump(this->pbase(), this->epptr(), __pos);
+	      __ret = __sp;
+	    }
+	}
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_sync(char_type* __base, __size_type __i, __size_type __o)
+    {
+      const bool __testin = _M_mode & ios_base::in;
+      const bool __testout = _M_mode & ios_base::out;
+      char_type* __endg = __base + _M_string.size();
+      char_type* __endp = __base + _M_string.capacity();
+
+      if (__base != _M_string.data())
+	{
+	  // setbuf: __i == size of buffer area (_M_string.size() == 0).
+	  __endg += __i;
+	  __i = 0;
+	  __endp = __endg;
+	}
+
+      if (__testin)
+	this->setg(__base, __base + __i, __endg);
+      if (__testout)
+	{
+	  _M_pbump(__base, __endp, __o);
+	  // egptr() always tracks the string end.  When !__testin,
+	  // for the correct functioning of the streambuf inlines
+	  // the other get area pointers are identical.
+	  if (!__testin)
+	    this->setg(__endg, __endg, __endg);
+	}
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
+    {
+      this->setp(__pbeg, __pend);
+      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
+	{
+	  this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
+	  __off -= __gnu_cxx::__numeric_traits<int>::__max;
+	}
+      this->pbump(__off);
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class basic_stringbuf<char>;
+  extern template class basic_istringstream<char>;
+  extern template class basic_ostringstream<char>;
+  extern template class basic_stringstream<char>;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_stringbuf<wchar_t>;
+  extern template class basic_istringstream<wchar_t>;
+  extern template class basic_ostringstream<wchar_t>;
+  extern template class basic_stringstream<wchar_t>;
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_algo.h b/gcc-4.9/libstdc++-v3/include/bits/stl_algo.h
new file mode 100644
index 0000000..4c6ca8a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_algo.h
@@ -0,0 +1,5518 @@
+// Algorithm implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_algo.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{algorithm}
+ */
+
+#ifndef _STL_ALGO_H
+#define _STL_ALGO_H 1
+
+#include <cstdlib>             // for rand
+#include <bits/algorithmfwd.h>
+#include <bits/stl_heap.h>
+#include <bits/stl_tempbuf.h>  // for _Temporary_buffer
+#include <bits/predefined_ops.h>
+
+#if __cplusplus >= 201103L
+#include <random>     // for std::uniform_int_distribution
+#endif
+
+// See concept_check.h for the __glibcxx_*_requires macros.
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// Swaps the median value of *__a, *__b and *__c under __comp to *__result
+  template<typename _Iterator, typename _Compare>
+    void
+    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
+			   _Iterator __c, _Compare __comp)
+    {
+      if (__comp(__a, __b))
+	{
+	  if (__comp(__b, __c))
+	    std::iter_swap(__result, __b);
+	  else if (__comp(__a, __c))
+	    std::iter_swap(__result, __c);
+	  else
+	    std::iter_swap(__result, __a);
+	}
+      else if (__comp(__a, __c))
+	std::iter_swap(__result, __a);
+      else if (__comp(__b, __c))
+	std::iter_swap(__result, __c);
+      else
+	std::iter_swap(__result, __b);
+    }
+
+  /// This is an overload used by find algos for the Input Iterator case.
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if(_InputIterator __first, _InputIterator __last,
+	      _Predicate __pred, input_iterator_tag)
+    {
+      while (__first != __last && !__pred(__first))
+	++__first;
+      return __first;
+    }
+
+  /// This is an overload used by find algos for the RAI case.
+  template<typename _RandomAccessIterator, typename _Predicate>
+    _RandomAccessIterator
+    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	      _Predicate __pred, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+	__trip_count = (__last - __first) >> 2;
+
+      for (; __trip_count > 0; --__trip_count)
+	{
+	  if (__pred(__first))
+	    return __first;
+	  ++__first;
+
+	  if (__pred(__first))
+	    return __first;
+	  ++__first;
+
+	  if (__pred(__first))
+	    return __first;
+	  ++__first;
+
+	  if (__pred(__first))
+	    return __first;
+	  ++__first;
+	}
+
+      switch (__last - __first)
+	{
+	case 3:
+	  if (__pred(__first))
+	    return __first;
+	  ++__first;
+	case 2:
+	  if (__pred(__first))
+	    return __first;
+	  ++__first;
+	case 1:
+	  if (__pred(__first))
+	    return __first;
+	  ++__first;
+	case 0:
+	default:
+	  return __last;
+	}
+    }
+
+  template<typename _Iterator, typename _Predicate>
+    inline _Iterator
+    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
+    {
+      return __find_if(__first, __last, __pred,
+		       std::__iterator_category(__first));
+    }
+
+  /// Provided for stable_partition to use.
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if_not(_InputIterator __first, _InputIterator __last,
+		  _Predicate __pred)
+    {
+      return std::__find_if(__first, __last,
+			    __gnu_cxx::__ops::__negate(__pred),
+			    std::__iterator_category(__first));
+    }
+
+  /// Like find_if_not(), but uses and updates a count of the
+  /// remaining range length instead of comparing against an end
+  /// iterator.
+  template<typename _InputIterator, typename _Predicate, typename _Distance>
+    _InputIterator
+    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
+    {
+      for (; __len; --__len, ++__first)
+	if (!__pred(__first))
+	  break;
+      return __first;
+    }
+
+  // set_difference
+  // set_intersection
+  // set_symmetric_difference
+  // set_union
+  // for_each
+  // find
+  // find_if
+  // find_first_of
+  // adjacent_find
+  // count
+  // count_if
+  // search
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    _ForwardIterator1
+    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+	     _BinaryPredicate  __predicate)
+    {
+      // Test for empty ranges
+      if (__first1 == __last1 || __first2 == __last2)
+	return __first1;
+
+      // Test for a pattern of length 1.
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+	return std::__find_if(__first1, __last1,
+		__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+      // General case.
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+
+      for (;;)
+	{
+	  __first1 =
+	    std::__find_if(__first1, __last1,
+		__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+	  if (__first1 == __last1)
+	    return __last1;
+
+	  __p = __p1;
+	  __current = __first1;
+	  if (++__current == __last1)
+	    return __last1;
+
+	  while (__predicate(__current, __p))
+	    {
+	      if (++__p == __last2)
+		return __first1;
+	      if (++__current == __last1)
+		return __last1;
+	    }
+	  ++__first1;
+	}
+      return __first1;
+    }
+
+  // search_n
+
+  /**
+   *  This is an helper function for search_n overloaded for forward iterators.
+  */
+  template<typename _ForwardIterator, typename _Integer,
+	   typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
+		   _Integer __count, _UnaryPredicate __unary_pred,
+		   std::forward_iterator_tag)
+    {
+      __first = std::__find_if(__first, __last, __unary_pred);
+      while (__first != __last)
+	{
+	  typename iterator_traits<_ForwardIterator>::difference_type
+	    __n = __count;
+	  _ForwardIterator __i = __first;
+	  ++__i;
+	  while (__i != __last && __n != 1 && __unary_pred(__i))
+	    {
+	      ++__i;
+	      --__n;
+	    }
+	  if (__n == 1)
+	    return __first;
+	  if (__i == __last)
+	    return __last;
+	  __first = std::__find_if(++__i, __last, __unary_pred);
+	}
+      return __last;
+    }
+
+  /**
+   *  This is an helper function for search_n overloaded for random access
+   *  iterators.
+  */
+  template<typename _RandomAccessIter, typename _Integer,
+	   typename _UnaryPredicate>
+    _RandomAccessIter
+    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
+		   _Integer __count, _UnaryPredicate __unary_pred,
+		   std::random_access_iterator_tag)
+    {
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+	_DistanceType;
+
+      _DistanceType __tailSize = __last - __first;
+      _DistanceType __remainder = __count;
+
+      while (__remainder <= __tailSize) // the main loop...
+	{
+	  __first += __remainder;
+	  __tailSize -= __remainder;
+	  // __first here is always pointing to one past the last element of
+	  // next possible match.
+	  _RandomAccessIter __backTrack = __first; 
+	  while (__unary_pred(--__backTrack))
+	    {
+	      if (--__remainder == 0)
+	        return (__first - __count); // Success
+	    }
+	  __remainder = __count + 1 - (__first - __backTrack);
+	}
+      return __last; // Failure
+    }
+
+  template<typename _ForwardIterator, typename _Integer,
+           typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+	       _Integer __count,
+	       _UnaryPredicate __unary_pred)
+    {
+      if (__count <= 0)
+	return __first;
+
+      if (__count == 1)
+	return std::__find_if(__first, __last, __unary_pred);
+
+      return std::__search_n_aux(__first, __last, __count, __unary_pred,
+				 std::__iterator_category(__first));
+    }
+
+  // find_end for forward iterators.
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+	       forward_iterator_tag, forward_iterator_tag,
+	       _BinaryPredicate __comp)
+    {
+      if (__first2 == __last2)
+	return __last1;
+
+      _ForwardIterator1 __result = __last1;
+      while (1)
+	{
+	  _ForwardIterator1 __new_result
+	    = std::__search(__first1, __last1, __first2, __last2, __comp);
+	  if (__new_result == __last1)
+	    return __result;
+	  else
+	    {
+	      __result = __new_result;
+	      __first1 = __new_result;
+	      ++__first1;
+	    }
+	}
+    }
+
+  // find_end for bidirectional iterators (much faster).
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+	   typename _BinaryPredicate>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+	       _BidirectionalIterator1 __last1,
+	       _BidirectionalIterator2 __first2,
+	       _BidirectionalIterator2 __last2,
+	       bidirectional_iterator_tag, bidirectional_iterator_tag,
+	       _BinaryPredicate __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator1>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator2>)
+
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
+					      _RevIterator2(__last2), __rlast2,
+					      __comp);
+
+      if (__rresult == __rlast1)
+	return __last1;
+      else
+	{
+	  _BidirectionalIterator1 __result = __rresult.base();
+	  std::advance(__result, -std::distance(__first2, __last2));
+	  return __result;
+	}
+    }
+
+  /**
+   *  @brief  Find last matching subsequence in a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of range to search.
+   *  @param  __last1   End of range to search.
+   *  @param  __first2  Start of sequence to match.
+   *  @param  __last2   End of sequence to match.
+   *  @return   The last iterator @c i in the range
+   *  @p [__first1,__last1-(__last2-__first2)) such that @c *(i+N) ==
+   *  @p *(__first2+N) for each @c N in the range @p
+   *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
+   *
+   *  Searches the range @p [__first1,__last1) for a sub-sequence that
+   *  compares equal value-by-value with the sequence given by @p
+   *  [__first2,__last2) and returns an iterator to the __first
+   *  element of the sub-sequence, or @p __last1 if the sub-sequence
+   *  is not found.  The sub-sequence will be the last such
+   *  subsequence contained in [__first1,__last1).
+   *
+   *  Because the sub-sequence must lie completely within the range @p
+   *  [__first1,__last1) it must start at a position less than @p
+   *  __last1-(__last2-__first2) where @p __last2-__first2 is the
+   *  length of the sub-sequence.  This means that the returned
+   *  iterator @c i will be in the range @p
+   *  [__first1,__last1-(__last2-__first2))
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+			     std::__iterator_category(__first1),
+			     std::__iterator_category(__first2),
+			     __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief  Find last matching subsequence in a sequence using a predicate.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of range to search.
+   *  @param  __last1   End of range to search.
+   *  @param  __first2  Start of sequence to match.
+   *  @param  __last2   End of sequence to match.
+   *  @param  __comp    The predicate to use.
+   *  @return The last iterator @c i in the range @p
+   *  [__first1,__last1-(__last2-__first2)) such that @c
+   *  predicate(*(i+N), @p (__first2+N)) is true for each @c N in the
+   *  range @p [0,__last2-__first2), or @p __last1 if no such iterator
+   *  exists.
+   *
+   *  Searches the range @p [__first1,__last1) for a sub-sequence that
+   *  compares equal value-by-value with the sequence given by @p
+   *  [__first2,__last2) using comp as a predicate and returns an
+   *  iterator to the first element of the sub-sequence, or @p __last1
+   *  if the sub-sequence is not found.  The sub-sequence will be the
+   *  last such subsequence contained in [__first,__last1).
+   *
+   *  Because the sub-sequence must lie completely within the range @p
+   *  [__first1,__last1) it must start at a position less than @p
+   *  __last1-(__last2-__first2) where @p __last2-__first2 is the
+   *  length of the sub-sequence.  This means that the returned
+   *  iterator @c i will be in the range @p
+   *  [__first1,__last1-(__last2-__first2))
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+	     _BinaryPredicate __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+			     std::__iterator_category(__first1),
+			     std::__iterator_category(__first2),
+			     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief  Checks that a predicate is true for all the elements
+   *          of a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __pred    A predicate.
+   *  @return  True if the check is true, false otherwise.
+   *
+   *  Returns true if @p __pred is true for each element in the range
+   *  @p [__first,__last), and false otherwise.
+  */
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if_not(__first, __last, __pred); }
+
+  /**
+   *  @brief  Checks that a predicate is false for all the elements
+   *          of a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __pred    A predicate.
+   *  @return  True if the check is true, false otherwise.
+   *
+   *  Returns true if @p __pred is false for each element in the range
+   *  @p [__first,__last), and false otherwise.
+  */
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == _GLIBCXX_STD_A::find_if(__first, __last, __pred); }
+
+  /**
+   *  @brief  Checks that a predicate is false for at least an element
+   *          of a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __pred    A predicate.
+   *  @return  True if the check is true, false otherwise.
+   *
+   *  Returns true if an element exists in the range @p
+   *  [__first,__last) such that @p __pred is true, and false
+   *  otherwise.
+  */
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return !std::none_of(__first, __last, __pred); }
+
+  /**
+   *  @brief  Find the first element in a sequence for which a
+   *          predicate is false.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __pred   A predicate.
+   *  @return   The first iterator @c i in the range @p [__first,__last)
+   *  such that @p __pred(*i) is false, or @p __last if no such iterator exists.
+  */
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if_not(_InputIterator __first, _InputIterator __last,
+		_Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	      typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+      return std::__find_if_not(__first, __last,
+				__gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  /**
+   *  @brief  Checks whether the sequence is partitioned.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __pred   A predicate.
+   *  @return  True if the range @p [__first,__last) is partioned by @p __pred,
+   *  i.e. if all elements that satisfy @p __pred appear before those that
+   *  do not.
+  */
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    is_partitioned(_InputIterator __first, _InputIterator __last,
+		   _Predicate __pred)
+    {
+      __first = std::find_if_not(__first, __last, __pred);
+      return std::none_of(__first, __last, __pred);
+    }
+
+  /**
+   *  @brief  Find the partition point of a partitioned range.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __pred    A predicate.
+   *  @return  An iterator @p mid such that @p all_of(__first, mid, __pred)
+   *           and @p none_of(mid, __last, __pred) are both true.
+  */
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    partition_point(_ForwardIterator __first, _ForwardIterator __last,
+		    _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	      typename iterator_traits<_ForwardIterator>::value_type>)
+
+      // A specific debug-mode test will be necessary...
+      __glibcxx_requires_valid_range(__first, __last);
+
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle;
+
+      while (__len > 0)
+	{
+	  __half = __len >> 1;
+	  __middle = __first;
+	  std::advance(__middle, __half);
+	  if (__pred(*__middle))
+	    {
+	      __first = __middle;
+	      ++__first;
+	      __len = __len - __half - 1;
+	    }
+	  else
+	    __len = __half;
+	}
+      return __first;
+    }
+#endif
+
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Predicate>
+    _OutputIterator
+    __remove_copy_if(_InputIterator __first, _InputIterator __last,
+		     _OutputIterator __result, _Predicate __pred)
+    {
+      for (; __first != __last; ++__first)
+	if (!__pred(__first))
+	  {
+	    *__result = *__first;
+	    ++__result;
+	  }
+      return __result;
+    }
+
+  /**
+   *  @brief Copy a sequence, removing elements of a given value.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __result  An output iterator.
+   *  @param  __value   The value to be removed.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [__first,__last) not equal
+   *  to @p __value to the range beginning at @p __result.
+   *  remove_copy() is stable, so the relative order of elements that
+   *  are copied is unchanged.
+  */
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result, const _Tp& __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_InputIterator>::value_type, _Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__remove_copy_if(__first, __last, __result,
+	__gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+
+  /**
+   *  @brief Copy a sequence, removing elements for which a predicate is true.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __result  An output iterator.
+   *  @param  __pred    A predicate.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [__first,__last) for which
+   *  @p __pred returns false to the range beginning at @p __result.
+   *
+   *  remove_copy_if() is stable, so the relative order of elements that are
+   *  copied is unchanged.
+  */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Predicate>
+    inline _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+		   _OutputIterator __result, _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__remove_copy_if(__first, __last, __result,
+				   __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief Copy the elements of a sequence for which a predicate is true.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __result  An output iterator.
+   *  @param  __pred    A predicate.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [__first,__last) for which
+   *  @p __pred returns true to the range beginning at @p __result.
+   *
+   *  copy_if() is stable, so the relative order of elements that are
+   *  copied is unchanged.
+  */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Predicate>
+    _OutputIterator
+    copy_if(_InputIterator __first, _InputIterator __last,
+	    _OutputIterator __result, _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first)
+	if (__pred(*__first))
+	  {
+	    *__result = *__first;
+	    ++__result;
+	  }
+      return __result;
+    }
+
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    _OutputIterator
+    __copy_n(_InputIterator __first, _Size __n,
+	     _OutputIterator __result, input_iterator_tag)
+    {
+      if (__n > 0)
+	{
+	  while (true)
+	    {
+	      *__result = *__first;
+	      ++__result;
+	      if (--__n > 0)
+		++__first;
+	      else
+		break;
+	    }
+	}
+      return __result;
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+	   typename _OutputIterator>
+    inline _OutputIterator
+    __copy_n(_RandomAccessIterator __first, _Size __n,
+	     _OutputIterator __result, random_access_iterator_tag)
+    { return std::copy(__first, __first + __n, __result); }
+
+  /**
+   *  @brief Copies the range [first,first+n) into [result,result+n).
+   *  @ingroup mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __n      The number of elements to copy.
+   *  @param  __result An output iterator.
+   *  @return  result+n.
+   *
+   *  This inline function will boil down to a call to @c memmove whenever
+   *  possible.  Failing that, if random access iterators are passed, then the
+   *  loop count will be known (and therefore a candidate for compiler
+   *  optimizations such as unrolling).
+  */
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    inline _OutputIterator
+    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+
+      return std::__copy_n(__first, __n, __result,
+			   std::__iterator_category(__first));
+    }
+
+  /**
+   *  @brief Copy the elements of a sequence to separate output sequences
+   *         depending on the truth value of a predicate.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __out_true   An output iterator.
+   *  @param  __out_false  An output iterator.
+   *  @param  __pred    A predicate.
+   *  @return   A pair designating the ends of the resulting sequences.
+   *
+   *  Copies each element in the range @p [__first,__last) for which
+   *  @p __pred returns true to the range beginning at @p out_true
+   *  and each element for which @p __pred returns false to @p __out_false.
+  */
+  template<typename _InputIterator, typename _OutputIterator1,
+	   typename _OutputIterator2, typename _Predicate>
+    pair<_OutputIterator1, _OutputIterator2>
+    partition_copy(_InputIterator __first, _InputIterator __last,
+		   _OutputIterator1 __out_true, _OutputIterator2 __out_false,
+		   _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+      
+      for (; __first != __last; ++__first)
+	if (__pred(*__first))
+	  {
+	    *__out_true = *__first;
+	    ++__out_true;
+	  }
+	else
+	  {
+	    *__out_false = *__first;
+	    ++__out_false;
+	  }
+
+      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
+    }
+#endif
+
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
+		_Predicate __pred)
+    {
+      __first = std::__find_if(__first, __last, __pred);
+      if (__first == __last)
+        return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for (; __first != __last; ++__first)
+        if (!__pred(__first))
+          {
+            *__result = _GLIBCXX_MOVE(*__first);
+            ++__result;
+          }
+      return __result;
+    }
+
+  /**
+   *  @brief Remove elements from a sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __value  The value to be removed.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  All elements equal to @p __value are removed from the range
+   *  @p [__first,__last).
+   *
+   *  remove() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *
+   *  Elements between the end of the resulting sequence and @p __last
+   *  are still present, but their value is unspecified.
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
+	   const _Tp& __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__remove_if(__first, __last,
+		__gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+
+  /**
+   *  @brief Remove elements from a sequence using a predicate.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A forward iterator.
+   *  @param  __last   A forward iterator.
+   *  @param  __pred   A predicate.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  All elements for which @p __pred returns true are removed from the range
+   *  @p [__first,__last).
+   *
+   *  remove_if() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *
+   *  Elements between the end of the resulting sequence and @p __last
+   *  are still present, but their value is unspecified.
+  */
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
+	      _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__remove_if(__first, __last,
+			      __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+		    _BinaryPredicate __binary_pred)
+    {
+      if (__first == __last)
+	return __last;
+      _ForwardIterator __next = __first;
+      while (++__next != __last)
+	{
+	  if (__binary_pred(__first, __next))
+	    return __first;
+	  __first = __next;
+	}
+      return __last;
+    }
+
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    __unique(_ForwardIterator __first, _ForwardIterator __last,
+	     _BinaryPredicate __binary_pred)
+    {
+      // Skip the beginning, if already unique.
+      __first = std::__adjacent_find(__first, __last, __binary_pred);
+      if (__first == __last)
+	return __last;
+
+      // Do the real copy work.
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+	if (!__binary_pred(__dest, __first))
+	  *++__dest = _GLIBCXX_MOVE(*__first);
+      return ++__dest;
+    }
+
+  /**
+   *  @brief Remove consecutive duplicate values from a sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A forward iterator.
+   *  @param  __last   A forward iterator.
+   *  @return  An iterator designating the end of the resulting sequence.
+   *
+   *  Removes all but the first element from each group of consecutive
+   *  values that compare equal.
+   *  unique() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *  Elements between the end of the resulting sequence and @p __last
+   *  are still present, but their value is unspecified.
+  */
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_EqualityComparableConcept<
+		     typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__unique(__first, __last,
+			   __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief Remove consecutive values from a sequence using a predicate.
+   *  @ingroup mutating_algorithms
+   *  @param  __first        A forward iterator.
+   *  @param  __last         A forward iterator.
+   *  @param  __binary_pred  A binary predicate.
+   *  @return  An iterator designating the end of the resulting sequence.
+   *
+   *  Removes all but the first element from each group of consecutive
+   *  values for which @p __binary_pred returns true.
+   *  unique() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *  Elements between the end of the resulting sequence and @p __last
+   *  are still present, but their value is unspecified.
+  */
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
+           _BinaryPredicate __binary_pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+		typename iterator_traits<_ForwardIterator>::value_type,
+		typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__unique(__first, __last,
+			   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+  /**
+   *  This is an uglified
+   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
+   *              _BinaryPredicate)
+   *  overloaded for forward iterators and output iterator as result.
+  */
+  template<typename _ForwardIterator, typename _OutputIterator,
+	   typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+		  _OutputIterator __result, _BinaryPredicate __binary_pred,
+		  forward_iterator_tag, output_iterator_tag)
+    {
+      // concept requirements -- iterators already checked
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	  typename iterator_traits<_ForwardIterator>::value_type,
+	  typename iterator_traits<_ForwardIterator>::value_type>)
+
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+	if (!__binary_pred(__first, __next))
+	  {
+	    __first = __next;
+	    *++__result = *__first;
+	  }
+      return ++__result;
+    }
+
+  /**
+   *  This is an uglified
+   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
+   *              _BinaryPredicate)
+   *  overloaded for input iterators and output iterator as result.
+  */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+		  _OutputIterator __result, _BinaryPredicate __binary_pred,
+		  input_iterator_tag, output_iterator_tag)
+    {
+      // concept requirements -- iterators already checked
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	  typename iterator_traits<_InputIterator>::value_type,
+	  typename iterator_traits<_InputIterator>::value_type>)
+
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
+	__rebound_pred
+	= __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
+      *__result = __value;
+      while (++__first != __last)
+	if (!__rebound_pred(__first, __value))
+	  {
+	    __value = *__first;
+	    *++__result = __value;
+	  }
+      return ++__result;
+    }
+
+  /**
+   *  This is an uglified
+   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
+   *              _BinaryPredicate)
+   *  overloaded for input iterators and forward iterator as result.
+  */
+  template<typename _InputIterator, typename _ForwardIterator,
+	   typename _BinaryPredicate>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+		  _ForwardIterator __result, _BinaryPredicate __binary_pred,
+		  input_iterator_tag, forward_iterator_tag)
+    {
+      // concept requirements -- iterators already checked
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	  typename iterator_traits<_ForwardIterator>::value_type,
+	  typename iterator_traits<_InputIterator>::value_type>)
+      *__result = *__first;
+      while (++__first != __last)
+	if (!__binary_pred(__result, __first))
+	  *++__result = *__first;
+      return ++__result;
+    }
+
+  /**
+   *  This is an uglified reverse(_BidirectionalIterator,
+   *                              _BidirectionalIterator)
+   *  overloaded for bidirectional iterators.
+  */
+  template<typename _BidirectionalIterator>
+    void
+    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
+	      bidirectional_iterator_tag)
+    {
+      while (true)
+	if (__first == __last || __first == --__last)
+	  return;
+	else
+	  {
+	    std::iter_swap(__first, __last);
+	    ++__first;
+	  }
+    }
+
+  /**
+   *  This is an uglified reverse(_BidirectionalIterator,
+   *                              _BidirectionalIterator)
+   *  overloaded for random access iterators.
+  */
+  template<typename _RandomAccessIterator>
+    void
+    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	      random_access_iterator_tag)
+    {
+      if (__first == __last)
+	return;
+      --__last;
+      while (__first < __last)
+	{
+	  std::iter_swap(__first, __last);
+	  ++__first;
+	  --__last;
+	}
+    }
+
+  /**
+   *  @brief Reverse a sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A bidirectional iterator.
+   *  @param  __last   A bidirectional iterator.
+   *  @return   reverse() returns no value.
+   *
+   *  Reverses the order of the elements in the range @p [__first,__last),
+   *  so that the first element becomes the last etc.
+   *  For every @c i such that @p 0<=i<=(__last-__first)/2), @p reverse()
+   *  swaps @p *(__first+i) and @p *(__last-(i+1))
+  */
+  template<typename _BidirectionalIterator>
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+
+  /**
+   *  @brief Copy a sequence, reversing its elements.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A bidirectional iterator.
+   *  @param  __last    A bidirectional iterator.
+   *  @param  __result  An output iterator.
+   *  @return  An iterator designating the end of the resulting sequence.
+   *
+   *  Copies the elements in the range @p [__first,__last) to the
+   *  range @p [__result,__result+(__last-__first)) such that the
+   *  order of the elements is reversed.  For every @c i such that @p
+   *  0<=i<=(__last-__first), @p reverse_copy() performs the
+   *  assignment @p *(__result+(__last-__first)-1-i) = *(__first+i).
+   *  The ranges @p [__first,__last) and @p
+   *  [__result,__result+(__last-__first)) must not overlap.
+  */
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+		 _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_BidirectionalIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      while (__first != __last)
+	{
+	  --__last;
+	  *__result = *__last;
+	  ++__result;
+	}
+      return __result;
+    }
+
+  /**
+   *  This is a helper function for the rotate algorithm specialized on RAIs.
+   *  It returns the greatest common divisor of two integer values.
+  */
+  template<typename _EuclideanRingElement>
+    _EuclideanRingElement
+    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
+    {
+      while (__n != 0)
+	{
+	  _EuclideanRingElement __t = __m % __n;
+	  __m = __n;
+	  __n = __t;
+	}
+      return __m;
+    }
+
+  /// This is a helper function for the rotate algorithm.
+  template<typename _ForwardIterator>
+    void
+    __rotate(_ForwardIterator __first,
+	     _ForwardIterator __middle,
+	     _ForwardIterator __last,
+	     forward_iterator_tag)
+    {
+      if (__first == __middle || __last  == __middle)
+	return;
+
+      _ForwardIterator __first2 = __middle;
+      do
+	{
+	  std::iter_swap(__first, __first2);
+	  ++__first;
+	  ++__first2;
+	  if (__first == __middle)
+	    __middle = __first2;
+	}
+      while (__first2 != __last);
+
+      __first2 = __middle;
+
+      while (__first2 != __last)
+	{
+	  std::iter_swap(__first, __first2);
+	  ++__first;
+	  ++__first2;
+	  if (__first == __middle)
+	    __middle = __first2;
+	  else if (__first2 == __last)
+	    __first2 = __middle;
+	}
+    }
+
+   /// This is a helper function for the rotate algorithm.
+  template<typename _BidirectionalIterator>
+    void
+    __rotate(_BidirectionalIterator __first,
+	     _BidirectionalIterator __middle,
+	     _BidirectionalIterator __last,
+	      bidirectional_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+
+      if (__first == __middle || __last  == __middle)
+	return;
+
+      std::__reverse(__first,  __middle, bidirectional_iterator_tag());
+      std::__reverse(__middle, __last,   bidirectional_iterator_tag());
+
+      while (__first != __middle && __middle != __last)
+	{
+	  std::iter_swap(__first, --__last);
+	  ++__first;
+	}
+
+      if (__first == __middle)
+	std::__reverse(__middle, __last,   bidirectional_iterator_tag());
+      else
+	std::__reverse(__first,  __middle, bidirectional_iterator_tag());
+    }
+
+  /// This is a helper function for the rotate algorithm.
+  template<typename _RandomAccessIterator>
+    void
+    __rotate(_RandomAccessIterator __first,
+	     _RandomAccessIterator __middle,
+	     _RandomAccessIterator __last,
+	     random_access_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+
+      if (__first == __middle || __last  == __middle)
+	return;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
+
+      _Distance __n = __last   - __first;
+      _Distance __k = __middle - __first;
+
+      if (__k == __n - __k)
+	{
+	  std::swap_ranges(__first, __middle, __middle);
+	  return;
+	}
+
+      _RandomAccessIterator __p = __first;
+
+      for (;;)
+	{
+	  if (__k < __n - __k)
+	    {
+	      if (__is_pod(_ValueType) && __k == 1)
+		{
+		  _ValueType __t = _GLIBCXX_MOVE(*__p);
+		  _GLIBCXX_MOVE3(__p + 1, __p + __n, __p);
+		  *(__p + __n - 1) = _GLIBCXX_MOVE(__t);
+		  return;
+		}
+	      _RandomAccessIterator __q = __p + __k;
+	      for (_Distance __i = 0; __i < __n - __k; ++ __i)
+		{
+		  std::iter_swap(__p, __q);
+		  ++__p;
+		  ++__q;
+		}
+	      __n %= __k;
+	      if (__n == 0)
+		return;
+	      std::swap(__n, __k);
+	      __k = __n - __k;
+	    }
+	  else
+	    {
+	      __k = __n - __k;
+	      if (__is_pod(_ValueType) && __k == 1)
+		{
+		  _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1));
+		  _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n);
+		  *__p = _GLIBCXX_MOVE(__t);
+		  return;
+		}
+	      _RandomAccessIterator __q = __p + __n;
+	      __p = __q - __k;
+	      for (_Distance __i = 0; __i < __n - __k; ++ __i)
+		{
+		  --__p;
+		  --__q;
+		  std::iter_swap(__p, __q);
+		}
+	      __n %= __k;
+	      if (__n == 0)
+		return;
+	      std::swap(__n, __k);
+	    }
+	}
+    }
+
+  /**
+   *  @brief Rotate the elements of a sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A forward iterator.
+   *  @param  __middle  A forward iterator.
+   *  @param  __last    A forward iterator.
+   *  @return  Nothing.
+   *
+   *  Rotates the elements of the range @p [__first,__last) by 
+   *  @p (__middle - __first) positions so that the element at @p __middle
+   *  is moved to @p __first, the element at @p __middle+1 is moved to
+   *  @p __first+1 and so on for each element in the range
+   *  @p [__first,__last).
+   *
+   *  This effectively swaps the ranges @p [__first,__middle) and
+   *  @p [__middle,__last).
+   *
+   *  Performs
+   *   @p *(__first+(n+(__last-__middle))%(__last-__first))=*(__first+n)
+   *  for each @p n in the range @p [0,__last-__first).
+  */
+  template<typename _ForwardIterator>
+    inline void
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+	   _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_requires_valid_range(__first, __middle);
+      __glibcxx_requires_valid_range(__middle, __last);
+
+      std::__rotate(__first, __middle, __last,
+		    std::__iterator_category(__first));
+    }
+
+  /**
+   *  @brief Copy a sequence, rotating its elements.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A forward iterator.
+   *  @param  __middle  A forward iterator.
+   *  @param  __last    A forward iterator.
+   *  @param  __result  An output iterator.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies the elements of the range @p [__first,__last) to the
+   *  range beginning at @result, rotating the copied elements by 
+   *  @p (__middle-__first) positions so that the element at @p __middle
+   *  is moved to @p __result, the element at @p __middle+1 is moved
+   *  to @p __result+1 and so on for each element in the range @p
+   *  [__first,__last).
+   *
+   *  Performs 
+   *  @p *(__result+(n+(__last-__middle))%(__last-__first))=*(__first+n)
+   *  for each @p n in the range @p [0,__last-__first).
+  */
+  template<typename _ForwardIterator, typename _OutputIterator>
+    inline _OutputIterator
+    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+                _ForwardIterator __last, _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __middle);
+      __glibcxx_requires_valid_range(__middle, __last);
+
+      return std::copy(__first, __middle,
+                       std::copy(__middle, __last, __result));
+    }
+
+  /// This is a helper function...
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __partition(_ForwardIterator __first, _ForwardIterator __last,
+		_Predicate __pred, forward_iterator_tag)
+    {
+      if (__first == __last)
+	return __first;
+
+      while (__pred(*__first))
+	if (++__first == __last)
+	  return __first;
+
+      _ForwardIterator __next = __first;
+
+      while (++__next != __last)
+	if (__pred(*__next))
+	  {
+	    std::iter_swap(__first, __next);
+	    ++__first;
+	  }
+
+      return __first;
+    }
+
+  /// This is a helper function...
+  template<typename _BidirectionalIterator, typename _Predicate>
+    _BidirectionalIterator
+    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
+		_Predicate __pred, bidirectional_iterator_tag)
+    {
+      while (true)
+	{
+	  while (true)
+	    if (__first == __last)
+	      return __first;
+	    else if (__pred(*__first))
+	      ++__first;
+	    else
+	      break;
+	  --__last;
+	  while (true)
+	    if (__first == __last)
+	      return __first;
+	    else if (!bool(__pred(*__last)))
+	      --__last;
+	    else
+	      break;
+	  std::iter_swap(__first, __last);
+	  ++__first;
+	}
+    }
+
+  // partition
+
+  /// This is a helper function...
+  /// Requires __len != 0 and !__pred(*__first),
+  /// same as __stable_partition_adaptive.
+  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
+    _ForwardIterator
+    __inplace_stable_partition(_ForwardIterator __first,
+			       _Predicate __pred, _Distance __len)
+    {
+      if (__len == 1)
+	return __first;
+      _ForwardIterator __middle = __first;
+      std::advance(__middle, __len / 2);
+      _ForwardIterator __left_split =
+	std::__inplace_stable_partition(__first, __pred, __len / 2);
+      // Advance past true-predicate values to satisfy this
+      // function's preconditions.
+      _Distance __right_len = __len - __len / 2;
+      _ForwardIterator __right_split =
+	std::__find_if_not_n(__middle, __right_len, __pred);
+      if (__right_len)
+	__right_split = std::__inplace_stable_partition(__middle,
+							__pred,
+							__right_len);
+      std::rotate(__left_split, __middle, __right_split);
+      std::advance(__left_split, std::distance(__middle, __right_split));
+      return __left_split;
+    }
+
+  /// This is a helper function...
+  /// Requires __first != __last and !__pred(__first)
+  /// and __len == distance(__first, __last).
+  ///
+  /// !__pred(__first) allows us to guarantee that we don't
+  /// move-assign an element onto itself.
+  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
+	   typename _Distance>
+    _ForwardIterator
+    __stable_partition_adaptive(_ForwardIterator __first,
+				_ForwardIterator __last,
+				_Predicate __pred, _Distance __len,
+				_Pointer __buffer,
+				_Distance __buffer_size)
+    {
+      if (__len <= __buffer_size)
+	{
+	  _ForwardIterator __result1 = __first;
+	  _Pointer __result2 = __buffer;
+	  // The precondition guarantees that !__pred(__first), so
+	  // move that element to the buffer before starting the loop.
+	  // This ensures that we only call __pred once per element.
+	  *__result2 = _GLIBCXX_MOVE(*__first);
+	  ++__result2;
+	  ++__first;
+	  for (; __first != __last; ++__first)
+	    if (__pred(__first))
+	      {
+		*__result1 = _GLIBCXX_MOVE(*__first);
+		++__result1;
+	      }
+	    else
+	      {
+		*__result2 = _GLIBCXX_MOVE(*__first);
+		++__result2;
+	      }
+	  _GLIBCXX_MOVE3(__buffer, __result2, __result1);
+	  return __result1;
+	}
+      else
+	{
+	  _ForwardIterator __middle = __first;
+	  std::advance(__middle, __len / 2);
+	  _ForwardIterator __left_split =
+	    std::__stable_partition_adaptive(__first, __middle, __pred,
+					     __len / 2, __buffer,
+					     __buffer_size);
+	  // Advance past true-predicate values to satisfy this
+	  // function's preconditions.
+	  _Distance __right_len = __len - __len / 2;
+	  _ForwardIterator __right_split =
+	    std::__find_if_not_n(__middle, __right_len, __pred);
+	  if (__right_len)
+	    __right_split =
+	      std::__stable_partition_adaptive(__right_split, __last, __pred,
+					       __right_len,
+					       __buffer, __buffer_size);
+	  std::rotate(__left_split, __middle, __right_split);
+	  std::advance(__left_split, std::distance(__middle, __right_split));
+	  return __left_split;
+	}
+    }
+
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+		       _Predicate __pred)
+    {
+      __first = std::__find_if_not(__first, __last, __pred);
+
+      if (__first == __last)
+	return __first;
+
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
+
+      _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
+      if (__buf.size() > 0)
+	return
+	  std::__stable_partition_adaptive(__first, __last, __pred,
+					   _DistanceType(__buf.requested_size()),
+					   __buf.begin(),
+					   _DistanceType(__buf.size()));
+      else
+	return
+	  std::__inplace_stable_partition(__first, __pred,
+					  _DistanceType(__buf.requested_size()));
+    }
+
+  /**
+   *  @brief Move elements for which a predicate is true to the beginning
+   *         of a sequence, preserving relative ordering.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A forward iterator.
+   *  @param  __last    A forward iterator.
+   *  @param  __pred    A predicate functor.
+   *  @return  An iterator @p middle such that @p __pred(i) is true for each
+   *  iterator @p i in the range @p [first,middle) and false for each @p i
+   *  in the range @p [middle,last).
+   *
+   *  Performs the same function as @p partition() with the additional
+   *  guarantee that the relative ordering of elements in each group is
+   *  preserved, so any two elements @p x and @p y in the range
+   *  @p [__first,__last) such that @p __pred(x)==__pred(y) will have the same
+   *  relative ordering after calling @p stable_partition().
+  */
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+		     _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__stable_partition(__first, __last,
+				     __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  /// This is a helper function for the sort routines.
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __heap_select(_RandomAccessIterator __first,
+		  _RandomAccessIterator __middle,
+		  _RandomAccessIterator __last, _Compare __comp)
+    {
+      std::__make_heap(__first, __middle, __comp);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+	if (__comp(__i, __first))
+	  std::__pop_heap(__first, __middle, __i, __comp);
+    }
+
+  // partial_sort
+
+  template<typename _InputIterator, typename _RandomAccessIterator,
+	   typename _Compare>
+    _RandomAccessIterator
+    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
+			_RandomAccessIterator __result_first,
+			_RandomAccessIterator __result_last,
+			_Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+	_InputValueType;
+      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
+      typedef typename _RItTraits::difference_type _DistanceType;
+
+      if (__result_first == __result_last)
+	return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while (__first != __last && __result_real_last != __result_last)
+	{
+	  *__result_real_last = *__first;
+	  ++__result_real_last;
+	  ++__first;
+	}
+      
+      std::__make_heap(__result_first, __result_real_last, __comp);
+      while (__first != __last)
+	{
+	  if (__comp(__first, __result_first))
+	    std::__adjust_heap(__result_first, _DistanceType(0),
+			       _DistanceType(__result_real_last
+					     - __result_first),
+			       _InputValueType(*__first), __comp);
+	  ++__first;
+	}
+      std::__sort_heap(__result_first, __result_real_last, __comp);
+      return __result_real_last;
+    }
+
+  /**
+   *  @brief Copy the smallest elements of a sequence.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __result_first   A random-access iterator.
+   *  @param  __result_last    Another random-access iterator.
+   *  @return   An iterator indicating the end of the resulting sequence.
+   *
+   *  Copies and sorts the smallest N values from the range @p [__first,__last)
+   *  to the range beginning at @p __result_first, where the number of
+   *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
+   *  @p (__result_last-__result_first).
+   *  After the sort if @e i and @e j are iterators in the range
+   *  @p [__result_first,__result_first+N) such that i precedes j then
+   *  *j<*i is false.
+   *  The value returned is @p __result_first+N.
+  */
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+		      _RandomAccessIterator __result_first,
+		      _RandomAccessIterator __result_last)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+	_InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
+
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
+				  _OutputValueType>)
+      __glibcxx_function_requires(_LessThanOpConcept<_InputValueType,
+				                     _OutputValueType>)
+      __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_valid_range(__result_first, __result_last);
+
+      return std::__partial_sort_copy(__first, __last,
+				      __result_first, __result_last,
+				      __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Copy the smallest elements of a sequence using a predicate for
+   *         comparison.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    Another input iterator.
+   *  @param  __result_first   A random-access iterator.
+   *  @param  __result_last    Another random-access iterator.
+   *  @param  __comp    A comparison functor.
+   *  @return   An iterator indicating the end of the resulting sequence.
+   *
+   *  Copies and sorts the smallest N values from the range @p [__first,__last)
+   *  to the range beginning at @p result_first, where the number of
+   *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
+   *  @p (__result_last-__result_first).
+   *  After the sort if @e i and @e j are iterators in the range
+   *  @p [__result_first,__result_first+N) such that i precedes j then
+   *  @p __comp(*j,*i) is false.
+   *  The value returned is @p __result_first+N.
+  */
+  template<typename _InputIterator, typename _RandomAccessIterator,
+	   typename _Compare>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+		      _RandomAccessIterator __result_first,
+		      _RandomAccessIterator __result_last,
+		      _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+	_InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
+
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
+				  _OutputValueType>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _InputValueType, _OutputValueType>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _OutputValueType, _OutputValueType>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_valid_range(__result_first, __result_last);
+
+      return std::__partial_sort_copy(__first, __last,
+				      __result_first, __result_last,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  /// This is a helper function for the sort routine.
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last,
+			      _Compare __comp)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+	__val = _GLIBCXX_MOVE(*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__comp(__val, __next))
+	{
+	  *__last = _GLIBCXX_MOVE(*__next);
+	  __last = __next;
+	  --__next;
+	}
+      *__last = _GLIBCXX_MOVE(__val);
+    }
+
+  /// This is a helper function for the sort routine.
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+		     _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__first == __last) return;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+	{
+	  if (__comp(__i, __first))
+	    {
+	      typename iterator_traits<_RandomAccessIterator>::value_type
+		__val = _GLIBCXX_MOVE(*__i);
+	      _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
+	      *__first = _GLIBCXX_MOVE(__val);
+	    }
+	  else
+	    std::__unguarded_linear_insert(__i,
+				__gnu_cxx::__ops::__val_comp_iter(__comp));
+	}
+    }
+
+  /// This is a helper function for the sort routine.
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+			       _RandomAccessIterator __last, _Compare __comp)
+    {
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+	std::__unguarded_linear_insert(__i,
+				__gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+  /**
+   *  @doctodo
+   *  This controls some aspect of the sort routines.
+  */
+  enum { _S_threshold = 16 };
+
+  /// This is a helper function for the sort routine.
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first > int(_S_threshold))
+	{
+	  std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
+	  std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
+					  __comp);
+	}
+      else
+	std::__insertion_sort(__first, __last, __comp);
+    }
+
+  /// This is a helper function...
+  template<typename _RandomAccessIterator, typename _Compare>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+			  _RandomAccessIterator __last,
+			  _RandomAccessIterator __pivot, _Compare __comp)
+    {
+      while (true)
+	{
+	  while (__comp(__first, __pivot))
+	    ++__first;
+	  --__last;
+	  while (__comp(__pivot, __last))
+	    --__last;
+	  if (!(__first < __last))
+	    return __first;
+	  std::iter_swap(__first, __last);
+	  ++__first;
+	}
+    }
+
+  /// This is a helper function...
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+				_RandomAccessIterator __last, _Compare __comp)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
+				  __comp);
+      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __partial_sort(_RandomAccessIterator __first,
+		   _RandomAccessIterator __middle,
+		   _RandomAccessIterator __last,
+		   _Compare __comp)
+    {
+      std::__heap_select(__first, __middle, __last, __comp);
+      std::__sort_heap(__first, __middle, __comp);
+    }
+
+  /// This is a helper function for the sort routine.
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+		     _RandomAccessIterator __last,
+		     _Size __depth_limit, _Compare __comp)
+    {
+      while (__last - __first > int(_S_threshold))
+	{
+	  if (__depth_limit == 0)
+	    {
+	      std::__partial_sort(__first, __last, __last, __comp);
+	      return;
+	    }
+	  --__depth_limit;
+	  _RandomAccessIterator __cut =
+	    std::__unguarded_partition_pivot(__first, __last, __comp);
+	  std::__introsort_loop(__cut, __last, __depth_limit, __comp);
+	  __last = __cut;
+	}
+    }
+
+  // sort
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	   _Compare __comp)
+    {
+      if (__first != __last)
+	{
+	  std::__introsort_loop(__first, __last,
+				std::__lg(__last - __first) * 2,
+				__comp);
+	  std::__final_insertion_sort(__first, __last, __comp);
+	}
+    }
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+		  _RandomAccessIterator __last, _Size __depth_limit,
+		  _Compare __comp)
+    {
+      while (__last - __first > 3)
+	{
+	  if (__depth_limit == 0)
+	    {
+	      std::__heap_select(__first, __nth + 1, __last, __comp);
+	      // Place the nth largest element in its final position.
+	      std::iter_swap(__first, __nth);
+	      return;
+	    }
+	  --__depth_limit;
+	  _RandomAccessIterator __cut =
+	    std::__unguarded_partition_pivot(__first, __last, __comp);
+	  if (__cut <= __nth)
+	    __first = __cut;
+	  else
+	    __last = __cut;
+	}
+      std::__insertion_sort(__first, __last, __comp);
+    }
+
+  // nth_element
+
+  // lower_bound moved to stl_algobase.h
+
+  /**
+   *  @brief Finds the first position in which @p __val could be inserted
+   *         without changing the ordering.
+   *  @ingroup binary_search_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @param  __comp    A functor to use for comparisons.
+   *  @return An iterator pointing to the first element <em>not less
+   *           than</em> @p __val, or end() if every element is less
+   *           than @p __val.
+   *  @ingroup binary_search_algorithms
+   *
+   *  The comparison function should have the same effects on ordering as
+   *  the function used for the initial sort.
+  */
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _ValueType, _Tp>)
+      __glibcxx_requires_partitioned_lower_pred(__first, __last,
+						__val, __comp);
+
+      return std::__lower_bound(__first, __last, __val,
+				__gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+		  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+	{
+	  _DistanceType __half = __len >> 1;
+	  _ForwardIterator __middle = __first;
+	  std::advance(__middle, __half);
+	  if (__comp(__val, __middle))
+	    __len = __half;
+	  else
+	    {
+	      __first = __middle;
+	      ++__first;
+	      __len = __len - __half - 1;
+	    }
+	}
+      return __first;
+    }
+
+  /**
+   *  @brief Finds the last position in which @p __val could be inserted
+   *         without changing the ordering.
+   *  @ingroup binary_search_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @return  An iterator pointing to the first element greater than @p __val,
+   *           or end() if no elements are greater than @p __val.
+   *  @ingroup binary_search_algorithms
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
+      __glibcxx_requires_partitioned_upper(__first, __last, __val);
+
+      return std::__upper_bound(__first, __last, __val,
+				__gnu_cxx::__ops::__val_less_iter());
+    }
+
+  /**
+   *  @brief Finds the last position in which @p __val could be inserted
+   *         without changing the ordering.
+   *  @ingroup binary_search_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @param  __comp    A functor to use for comparisons.
+   *  @return  An iterator pointing to the first element greater than @p __val,
+   *           or end() if no elements are greater than @p __val.
+   *  @ingroup binary_search_algorithms
+   *
+   *  The comparison function should have the same effects on ordering as
+   *  the function used for the initial sort.
+  */
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _Tp, _ValueType>)
+      __glibcxx_requires_partitioned_upper_pred(__first, __last,
+						__val, __comp);
+
+      return std::__upper_bound(__first, __last, __val,
+				__gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp,
+	   typename _CompareItTp, typename _CompareTpIt>
+    pair<_ForwardIterator, _ForwardIterator>
+    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
+		  const _Tp& __val,
+		  _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+	{
+	  _DistanceType __half = __len >> 1;
+	  _ForwardIterator __middle = __first;
+	  std::advance(__middle, __half);
+	  if (__comp_it_val(__middle, __val))
+	    {
+	      __first = __middle;
+	      ++__first;
+	      __len = __len - __half - 1;
+	    }
+	  else if (__comp_val_it(__val, __middle))
+	    __len = __half;
+	  else
+	    {
+	      _ForwardIterator __left
+		= std::__lower_bound(__first, __middle, __val, __comp_it_val);
+	      std::advance(__first, __len);
+	      _ForwardIterator __right
+		= std::__upper_bound(++__middle, __first, __val, __comp_val_it);
+	      return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+	    }
+	}
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+
+  /**
+   *  @brief Finds the largest subrange in which @p __val could be inserted
+   *         at any place in it without changing the ordering.
+   *  @ingroup binary_search_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @return  An pair of iterators defining the subrange.
+   *  @ingroup binary_search_algorithms
+   *
+   *  This is equivalent to
+   *  @code
+   *    std::make_pair(lower_bound(__first, __last, __val),
+   *                   upper_bound(__first, __last, __val))
+   *  @endcode
+   *  but does not actually call those functions.
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanOpConcept<_ValueType, _Tp>)
+      __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
+      __glibcxx_requires_partitioned_lower(__first, __last, __val);
+      __glibcxx_requires_partitioned_upper(__first, __last, __val);      
+
+      return std::__equal_range(__first, __last, __val,
+				__gnu_cxx::__ops::__iter_less_val(),
+				__gnu_cxx::__ops::__val_less_iter());
+    }
+
+  /**
+   *  @brief Finds the largest subrange in which @p __val could be inserted
+   *         at any place in it without changing the ordering.
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @param  __comp    A functor to use for comparisons.
+   *  @return  An pair of iterators defining the subrange.
+   *  @ingroup binary_search_algorithms
+   *
+   *  This is equivalent to
+   *  @code
+   *    std::make_pair(lower_bound(__first, __last, __val, __comp),
+   *                   upper_bound(__first, __last, __val, __comp))
+   *  @endcode
+   *  but does not actually call those functions.
+  */
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _ValueType, _Tp>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _Tp, _ValueType>)
+      __glibcxx_requires_partitioned_lower_pred(__first, __last,
+						__val, __comp);
+      __glibcxx_requires_partitioned_upper_pred(__first, __last,
+						__val, __comp);
+
+      return std::__equal_range(__first, __last, __val,
+				__gnu_cxx::__ops::__iter_comp_val(__comp),
+				__gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+  /**
+   *  @brief Determines whether an element exists in a range.
+   *  @ingroup binary_search_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @return True if @p __val (or its equivalent) is in [@p
+   *  __first,@p __last ].
+   *
+   *  Note that this does not actually return an iterator to @p __val.  For
+   *  that, use std::find or a container's specialized find member functions.
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+                  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
+      __glibcxx_requires_partitioned_lower(__first, __last, __val);
+      __glibcxx_requires_partitioned_upper(__first, __last, __val);
+
+      _ForwardIterator __i
+	= std::__lower_bound(__first, __last, __val,
+			     __gnu_cxx::__ops::__iter_less_val());
+      return __i != __last && !(__val < *__i);
+    }
+
+  /**
+   *  @brief Determines whether an element exists in a range.
+   *  @ingroup binary_search_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @param  __comp    A functor to use for comparisons.
+   *  @return  True if @p __val (or its equivalent) is in @p [__first,__last].
+   *
+   *  Note that this does not actually return an iterator to @p __val.  For
+   *  that, use std::find or a container's specialized find member functions.
+   *
+   *  The comparison function should have the same effects on ordering as
+   *  the function used for the initial sort.
+  */
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+                  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _Tp, _ValueType>)
+      __glibcxx_requires_partitioned_lower_pred(__first, __last,
+						__val, __comp);
+      __glibcxx_requires_partitioned_upper_pred(__first, __last,
+						__val, __comp);
+
+      _ForwardIterator __i
+	= std::__lower_bound(__first, __last, __val,
+			     __gnu_cxx::__ops::__iter_comp_val(__comp));
+      return __i != __last && !bool(__comp(__val, *__i));
+    }
+
+  // merge
+
+  /// This is a helper function for the __merge_adaptive routines.
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
+    void
+    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
+			  _InputIterator2 __first2, _InputIterator2 __last2,
+			  _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (__comp(__first2, __first1))
+	    {
+	      *__result = _GLIBCXX_MOVE(*__first2);
+	      ++__first2;
+	    }
+	  else
+	    {
+	      *__result = _GLIBCXX_MOVE(*__first1);
+	      ++__first1;
+	    }
+	  ++__result;
+	}
+      if (__first1 != __last1)
+	_GLIBCXX_MOVE3(__first1, __last1, __result);
+    }
+
+  /// This is a helper function for the __merge_adaptive routines.
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+	   typename _BidirectionalIterator3, typename _Compare>
+    void
+    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
+				   _BidirectionalIterator1 __last1,
+				   _BidirectionalIterator2 __first2,
+				   _BidirectionalIterator2 __last2,
+				   _BidirectionalIterator3 __result,
+				   _Compare __comp)
+    {
+      if (__first1 == __last1)
+	{
+	  _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result);
+	  return;
+	}
+      else if (__first2 == __last2)
+	return;
+
+      --__last1;
+      --__last2;
+      while (true)
+	{
+	  if (__comp(__last2, __last1))
+	    {
+	      *--__result = _GLIBCXX_MOVE(*__last1);
+	      if (__first1 == __last1)
+		{
+		  _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result);
+		  return;
+		}
+	      --__last1;
+	    }
+	  else
+	    {
+	      *--__result = _GLIBCXX_MOVE(*__last2);
+	      if (__first2 == __last2)
+		return;
+	      --__last2;
+	    }
+	}
+    }
+
+  /// This is a helper function for the merge routines.
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+	   typename _Distance>
+    _BidirectionalIterator1
+    __rotate_adaptive(_BidirectionalIterator1 __first,
+		      _BidirectionalIterator1 __middle,
+		      _BidirectionalIterator1 __last,
+		      _Distance __len1, _Distance __len2,
+		      _BidirectionalIterator2 __buffer,
+		      _Distance __buffer_size)
+    {
+      _BidirectionalIterator2 __buffer_end;
+      if (__len1 > __len2 && __len2 <= __buffer_size)
+	{
+	  if (__len2)
+	    {
+	      __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
+	      _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last);
+	      return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first);
+	    }
+	  else
+	    return __first;
+	}
+      else if (__len1 <= __buffer_size)
+	{
+	  if (__len1)
+	    {
+	      __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
+	      _GLIBCXX_MOVE3(__middle, __last, __first);
+	      return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last);
+	    }
+	  else
+	    return __last;
+	}
+      else
+	{
+	  std::rotate(__first, __middle, __last);
+	  std::advance(__first, std::distance(__middle, __last));
+	  return __first;
+	}
+    }
+
+  /// This is a helper function for the merge routines.
+  template<typename _BidirectionalIterator, typename _Distance, 
+	   typename _Pointer, typename _Compare>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+                     _BidirectionalIterator __middle,
+		     _BidirectionalIterator __last,
+		     _Distance __len1, _Distance __len2,
+		     _Pointer __buffer, _Distance __buffer_size,
+		     _Compare __comp)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+	{
+	  _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
+	  std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
+				     __first, __comp);
+	}
+      else if (__len2 <= __buffer_size)
+	{
+	  _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
+	  std::__move_merge_adaptive_backward(__first, __middle, __buffer,
+					      __buffer_end, __last, __comp);
+	}
+      else
+	{
+	  _BidirectionalIterator __first_cut = __first;
+	  _BidirectionalIterator __second_cut = __middle;
+	  _Distance __len11 = 0;
+	  _Distance __len22 = 0;
+	  if (__len1 > __len2)
+	    {
+	      __len11 = __len1 / 2;
+	      std::advance(__first_cut, __len11);
+	      __second_cut
+		= std::__lower_bound(__middle, __last, *__first_cut,
+				     __gnu_cxx::__ops::__iter_comp_val(__comp));
+	      __len22 = std::distance(__middle, __second_cut);
+	    }
+	  else
+	    {
+	      __len22 = __len2 / 2;
+	      std::advance(__second_cut, __len22);
+	      __first_cut
+		= std::__upper_bound(__first, __middle, *__second_cut,
+				     __gnu_cxx::__ops::__val_comp_iter(__comp));
+	      __len11 = std::distance(__first, __first_cut);
+	    }
+	  _BidirectionalIterator __new_middle
+	    = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+				     __len1 - __len11, __len22, __buffer,
+				     __buffer_size);
+	  std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+				__len22, __buffer, __buffer_size, __comp);
+	  std::__merge_adaptive(__new_middle, __second_cut, __last,
+				__len1 - __len11,
+				__len2 - __len22, __buffer,
+				__buffer_size, __comp);
+	}
+    }
+
+  /// This is a helper function for the merge routines.
+  template<typename _BidirectionalIterator, typename _Distance,
+	   typename _Compare>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+                           _BidirectionalIterator __middle,
+			   _BidirectionalIterator __last,
+			   _Distance __len1, _Distance __len2,
+			   _Compare __comp)
+    {
+      if (__len1 == 0 || __len2 == 0)
+	return;
+      if (__len1 + __len2 == 2)
+	{
+	  if (__comp(__middle, __first))
+	    std::iter_swap(__first, __middle);
+	  return;
+	}
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+	{
+	  __len11 = __len1 / 2;
+	  std::advance(__first_cut, __len11);
+	  __second_cut
+	    = std::__lower_bound(__middle, __last, *__first_cut,
+				 __gnu_cxx::__ops::__iter_comp_val(__comp));
+	  __len22 = std::distance(__middle, __second_cut);
+	}
+      else
+	{
+	  __len22 = __len2 / 2;
+	  std::advance(__second_cut, __len22);
+	  __first_cut
+	    = std::__upper_bound(__first, __middle, *__second_cut,
+				 __gnu_cxx::__ops::__val_comp_iter(__comp));
+	  __len11 = std::distance(__first, __first_cut);
+	}
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+				  __len11, __len22, __comp);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+				  __len1 - __len11, __len2 - __len22, __comp);
+    }
+
+  template<typename _BidirectionalIterator, typename _Compare>
+    void
+    __inplace_merge(_BidirectionalIterator __first,
+		    _BidirectionalIterator __middle,
+		    _BidirectionalIterator __last,
+		    _Compare __comp)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+          _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+          _DistanceType;
+
+      if (__first == __middle || __middle == __last)
+	return;
+
+      const _DistanceType __len1 = std::distance(__first, __middle);
+      const _DistanceType __len2 = std::distance(__middle, __last);
+
+      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+
+      if (__buf.begin() == 0)
+	std::__merge_without_buffer
+	  (__first, __middle, __last, __len1, __len2, __comp);
+      else
+	std::__merge_adaptive
+	  (__first, __middle, __last, __len1, __len2, __buf.begin(),
+	   _DistanceType(__buf.size()), __comp);
+    }
+
+  /**
+   *  @brief Merges two sorted ranges in place.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __middle  Another iterator.
+   *  @param  __last    Another iterator.
+   *  @return  Nothing.
+   *
+   *  Merges two sorted and consecutive ranges, [__first,__middle) and
+   *  [__middle,__last), and puts the result in [__first,__last).  The
+   *  output will be sorted.  The sort is @e stable, that is, for
+   *  equivalent elements in the two ranges, elements from the first
+   *  range will always come before elements from the second.
+   *
+   *  If enough additional memory is available, this takes (__last-__first)-1
+   *  comparisons.  Otherwise an NlogN algorithm is used, where N is
+   *  distance(__first,__last).
+  */
+  template<typename _BidirectionalIterator>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+		  _BidirectionalIterator __middle,
+		  _BidirectionalIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
+	    _BidirectionalIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
+      __glibcxx_requires_sorted(__first, __middle);
+      __glibcxx_requires_sorted(__middle, __last);
+
+      std::__inplace_merge(__first, __middle, __last,
+			   __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Merges two sorted ranges in place.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __middle  Another iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __comp    A functor to use for comparisons.
+   *  @return  Nothing.
+   *
+   *  Merges two sorted and consecutive ranges, [__first,__middle) and
+   *  [middle,last), and puts the result in [__first,__last).  The output will
+   *  be sorted.  The sort is @e stable, that is, for equivalent
+   *  elements in the two ranges, elements from the first range will always
+   *  come before elements from the second.
+   *
+   *  If enough additional memory is available, this takes (__last-__first)-1
+   *  comparisons.  Otherwise an NlogN algorithm is used, where N is
+   *  distance(__first,__last).
+   *
+   *  The comparison function should have the same effects on ordering as
+   *  the function used for the initial sort.
+  */
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+		  _BidirectionalIterator __middle,
+		  _BidirectionalIterator __last,
+		  _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
+	    _BidirectionalIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_BidirectionalIterator>::value_type,
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
+      __glibcxx_requires_sorted_pred(__first, __middle, __comp);
+      __glibcxx_requires_sorted_pred(__middle, __last, __comp);
+
+      std::__inplace_merge(__first, __middle, __last,
+			   __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+  /// This is a helper function for the __merge_sort_loop routines.
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Compare>
+    _OutputIterator
+    __move_merge(_InputIterator __first1, _InputIterator __last1,
+		 _InputIterator __first2, _InputIterator __last2,
+		 _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (__comp(__first2, __first1))
+	    {
+	      *__result = _GLIBCXX_MOVE(*__first2);
+	      ++__first2;
+	    }
+	  else
+	    {
+	      *__result = _GLIBCXX_MOVE(*__first1);
+	      ++__first1;
+	    }
+	  ++__result;
+	}
+      return _GLIBCXX_MOVE3(__first2, __last2,
+			    _GLIBCXX_MOVE3(__first1, __last1,
+					   __result));
+    }
+
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+	   typename _Distance, typename _Compare>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+		      _RandomAccessIterator1 __last,
+		      _RandomAccessIterator2 __result, _Distance __step_size,
+		      _Compare __comp)
+    {
+      const _Distance __two_step = 2 * __step_size;
+
+      while (__last - __first >= __two_step)
+	{
+	  __result = std::__move_merge(__first, __first + __step_size,
+				       __first + __step_size,
+				       __first + __two_step,
+				       __result, __comp);
+	  __first += __two_step;
+	}
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+
+      std::__move_merge(__first, __first + __step_size,
+			__first + __step_size, __last, __result, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+	   typename _Compare>
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last,
+			   _Distance __chunk_size, _Compare __comp)
+    {
+      while (__last - __first >= __chunk_size)
+	{
+	  std::__insertion_sort(__first, __first + __chunk_size, __comp);
+	  __first += __chunk_size;
+	}
+      std::__insertion_sort(__first, __last, __comp);
+    }
+
+  enum { _S_chunk_size = 7 };
+
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+			     _RandomAccessIterator __last,
+                             _Pointer __buffer, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_Distance;
+
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
+
+      while (__step_size < __len)
+	{
+	  std::__merge_sort_loop(__first, __last, __buffer,
+				 __step_size, __comp);
+	  __step_size *= 2;
+	  std::__merge_sort_loop(__buffer, __buffer_last, __first,
+				 __step_size, __comp);
+	  __step_size *= 2;
+	}
+    }
+
+  template<typename _RandomAccessIterator, typename _Pointer,
+	   typename _Distance, typename _Compare>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last,
+                           _Pointer __buffer, _Distance __buffer_size,
+                           _Compare __comp)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+	{
+	  std::__stable_sort_adaptive(__first, __middle, __buffer,
+				      __buffer_size, __comp);
+	  std::__stable_sort_adaptive(__middle, __last, __buffer,
+				      __buffer_size, __comp);
+	}
+      else
+	{
+	  std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
+	  std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
+	}
+      std::__merge_adaptive(__first, __middle, __last,
+			    _Distance(__middle - __first),
+			    _Distance(__last - __middle),
+			    __buffer, __buffer_size,
+			    __comp);
+    }
+
+  /// This is a helper function for the stable sorting routines.
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+			  _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first < 15)
+	{
+	  std::__insertion_sort(__first, __last, __comp);
+	  return;
+	}
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle, __comp);
+      std::__inplace_stable_sort(__middle, __last, __comp);
+      std::__merge_without_buffer(__first, __middle, __last,
+				  __middle - __first,
+				  __last - __middle,
+				  __comp);
+    }
+
+  // stable_sort
+
+  // Set algorithms: includes, set_union, set_intersection, set_difference,
+  // set_symmetric_difference.  All of these algorithms have the precondition
+  // that their input ranges are sorted and the postcondition that their output
+  // ranges are sorted.
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _Compare>
+    bool
+    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
+	       _InputIterator2 __first2, _InputIterator2 __last2,
+	       _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	if (__comp(__first2, __first1))
+	  return false;
+	else if (__comp(__first1, __first2))
+	  ++__first1;
+	else
+	  ++__first1, ++__first2;
+
+      return __first2 == __last2;
+    }
+
+  /**
+   *  @brief Determines whether all elements of a sequence exists in a range.
+   *  @param  __first1  Start of search range.
+   *  @param  __last1   End of search range.
+   *  @param  __first2  Start of sequence
+   *  @param  __last2   End of sequence.
+   *  @return  True if each element in [__first2,__last2) is contained in order
+   *  within [__first1,__last1).  False otherwise.
+   *  @ingroup set_algorithms
+   *
+   *  This operation expects both [__first1,__last1) and
+   *  [__first2,__last2) to be sorted.  Searches for the presence of
+   *  each element in [__first2,__last2) within [__first1,__last1).
+   *  The iterators over each range only move forward, so this is a
+   *  linear algorithm.  If an element in [__first2,__last2) is not
+   *  found before the search iterator reaches @p __last2, false is
+   *  returned.
+  */
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
+      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+			     __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Determines whether all elements of a sequence exists in a range
+   *  using comparison.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of search range.
+   *  @param  __last1   End of search range.
+   *  @param  __first2  Start of sequence
+   *  @param  __last2   End of sequence.
+   *  @param  __comp    Comparison function to use.
+   *  @return True if each element in [__first2,__last2) is contained
+   *  in order within [__first1,__last1) according to comp.  False
+   *  otherwise.  @ingroup set_algorithms
+   *
+   *  This operation expects both [__first1,__last1) and
+   *  [__first2,__last2) to be sorted.  Searches for the presence of
+   *  each element in [__first2,__last2) within [__first1,__last1),
+   *  using comp to decide.  The iterators over each range only move
+   *  forward, so this is a linear algorithm.  If an element in
+   *  [__first2,__last2) is not found before the search iterator
+   *  reaches @p __last2, false is returned.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _Compare>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2,
+	     _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
+      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+			     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  // nth_element
+  // merge
+  // set_difference
+  // set_intersection
+  // set_union
+  // stable_sort
+  // set_symmetric_difference
+  // min_element
+  // max_element
+
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    __next_permutation(_BidirectionalIterator __first,
+		       _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+	return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+	return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+	{
+	  _BidirectionalIterator __ii = __i;
+	  --__i;
+	  if (__comp(__i, __ii))
+	    {
+	      _BidirectionalIterator __j = __last;
+	      while (!__comp(__i, --__j))
+		{}
+	      std::iter_swap(__i, __j);
+	      std::__reverse(__ii, __last,
+			     std::__iterator_category(__first));
+	      return true;
+	    }
+	  if (__i == __first)
+	    {
+	      std::__reverse(__first, __last,
+			     std::__iterator_category(__first));
+	      return false;
+	    }
+	}
+    }
+
+  /**
+   *  @brief  Permute range into the next @e dictionary ordering.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @return  False if wrapped to first permutation, true otherwise.
+   *
+   *  Treats all permutations of the range as a set of @e dictionary sorted
+   *  sequences.  Permutes the current sequence into the next one of this set.
+   *  Returns true if there are more sequences to generate.  If the sequence
+   *  is the largest of the set, the smallest is generated and false returned.
+  */
+  template<typename _BidirectionalIterator>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__next_permutation
+	(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Permute range into the next @e dictionary ordering using
+   *          comparison functor.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @param  __comp   A comparison functor.
+   *  @return  False if wrapped to first permutation, true otherwise.
+   *
+   *  Treats all permutations of the range [__first,__last) as a set of
+   *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
+   *  sequence into the next one of this set.  Returns true if there are more
+   *  sequences to generate.  If the sequence is the largest of the set, the
+   *  smallest is generated and false returned.
+  */
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_BidirectionalIterator>::value_type,
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__next_permutation
+	(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    __prev_permutation(_BidirectionalIterator __first,
+		       _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+	return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+	return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+	{
+	  _BidirectionalIterator __ii = __i;
+	  --__i;
+	  if (__comp(__ii, __i))
+	    {
+	      _BidirectionalIterator __j = __last;
+	      while (!__comp(--__j, __i))
+		{}
+	      std::iter_swap(__i, __j);
+	      std::__reverse(__ii, __last,
+			     std::__iterator_category(__first));
+	      return true;
+	    }
+	  if (__i == __first)
+	    {
+	      std::__reverse(__first, __last,
+			     std::__iterator_category(__first));
+	      return false;
+	    }
+	}
+    }
+
+  /**
+   *  @brief  Permute range into the previous @e dictionary ordering.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @return  False if wrapped to last permutation, true otherwise.
+   *
+   *  Treats all permutations of the range as a set of @e dictionary sorted
+   *  sequences.  Permutes the current sequence into the previous one of this
+   *  set.  Returns true if there are more sequences to generate.  If the
+   *  sequence is the smallest of the set, the largest is generated and false
+   *  returned.
+  */
+  template<typename _BidirectionalIterator>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__prev_permutation(__first, __last,
+				     __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Permute range into the previous @e dictionary ordering using
+   *          comparison functor.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @param  __comp   A comparison functor.
+   *  @return  False if wrapped to last permutation, true otherwise.
+   *
+   *  Treats all permutations of the range [__first,__last) as a set of
+   *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
+   *  sequence into the previous one of this set.  Returns true if there are
+   *  more sequences to generate.  If the sequence is the smallest of the set,
+   *  the largest is generated and false returned.
+  */
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_BidirectionalIterator>::value_type,
+	    typename iterator_traits<_BidirectionalIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__prev_permutation(__first, __last,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  // replace
+  // replace_if
+
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Predicate, typename _Tp>
+    _OutputIterator
+    __replace_copy_if(_InputIterator __first, _InputIterator __last,
+		      _OutputIterator __result,
+		      _Predicate __pred, const _Tp& __new_value)
+    {
+      for (; __first != __last; ++__first, ++__result)
+	if (__pred(__first))
+	  *__result = __new_value;
+	else
+	  *__result = *__first;
+      return __result;
+    }
+
+  /**
+   *  @brief Copy a sequence, replacing each element of one value with another
+   *         value.
+   *  @param  __first      An input iterator.
+   *  @param  __last       An input iterator.
+   *  @param  __result     An output iterator.
+   *  @param  __old_value  The value to be replaced.
+   *  @param  __new_value  The replacement value.
+   *  @return   The end of the output sequence, @p result+(last-first).
+   *
+   *  Copies each element in the input range @p [__first,__last) to the
+   *  output range @p [__result,__result+(__last-__first)) replacing elements
+   *  equal to @p __old_value with @p __new_value.
+  */
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+		 _OutputIterator __result,
+		 const _Tp& __old_value, const _Tp& __new_value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_InputIterator>::value_type, _Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__replace_copy_if(__first, __last, __result,
+			__gnu_cxx::__ops::__iter_equals_val(__old_value),
+					      __new_value);
+    }
+
+  /**
+   *  @brief Copy a sequence, replacing each value for which a predicate
+   *         returns true with another value.
+   *  @ingroup mutating_algorithms
+   *  @param  __first      An input iterator.
+   *  @param  __last       An input iterator.
+   *  @param  __result     An output iterator.
+   *  @param  __pred       A predicate.
+   *  @param  __new_value  The replacement value.
+   *  @return   The end of the output sequence, @p __result+(__last-__first).
+   *
+   *  Copies each element in the range @p [__first,__last) to the range
+   *  @p [__result,__result+(__last-__first)) replacing elements for which
+   *  @p __pred returns true with @p __new_value.
+  */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Predicate, typename _Tp>
+    inline _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+		    _OutputIterator __result,
+		    _Predicate __pred, const _Tp& __new_value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__replace_copy_if(__first, __last, __result,
+				__gnu_cxx::__ops::__pred_iter(__pred),
+					      __new_value);
+    }
+
+  template<typename _InputIterator, typename _Predicate>
+    typename iterator_traits<_InputIterator>::difference_type
+    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+	if (__pred(__first))
+	  ++__n;
+      return __n;
+    }
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief  Determines whether the elements of a sequence are sorted.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @return  True if the elements are sorted, false otherwise.
+  */
+  template<typename _ForwardIterator>
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
+    { return std::is_sorted_until(__first, __last) == __last; }
+
+  /**
+   *  @brief  Determines whether the elements of a sequence are sorted
+   *          according to a comparison functor.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __comp    A comparison functor.
+   *  @return  True if the elements are sorted, false otherwise.
+  */
+  template<typename _ForwardIterator, typename _Compare>
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
+	      _Compare __comp)
+    { return std::is_sorted_until(__first, __last, __comp) == __last; }
+
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+		      _Compare __comp)
+    {
+      if (__first == __last)
+	return __last;
+
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, ++__next)
+	if (__comp(__next, __first))
+	  return __next;
+      return __next;
+    }
+
+  /**
+   *  @brief  Determines the end of a sorted sequence.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @return  An iterator pointing to the last iterator i in [__first, __last)
+   *           for which the range [__first, i) is sorted.
+  */
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__is_sorted_until(__first, __last,
+				    __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Determines the end of a sorted sequence using comparison functor.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __comp    A comparison functor.
+   *  @return  An iterator pointing to the last iterator i in [__first, __last)
+   *           for which the range [__first, i) is sorted.
+  */
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+		    _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__is_sorted_until(__first, __last,
+				    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  /**
+   *  @brief  Determines min and max at once as an ordered pair.
+   *  @ingroup sorting_algorithms
+   *  @param  __a  A thing of arbitrary type.
+   *  @param  __b  Another thing of arbitrary type.
+   *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
+   *  __b) otherwise.
+  */
+  template<typename _Tp>
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
+
+      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
+	               : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+
+  /**
+   *  @brief  Determines min and max at once as an ordered pair.
+   *  @ingroup sorting_algorithms
+   *  @param  __a  A thing of arbitrary type.
+   *  @param  __b  Another thing of arbitrary type.
+   *  @param  __comp  A @link comparison_functors comparison functor @endlink.
+   *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
+   *  __b) otherwise.
+  */
+  template<typename _Tp, typename _Compare>
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
+	                      : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    pair<_ForwardIterator, _ForwardIterator>
+    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+		     _Compare __comp)
+    {
+      _ForwardIterator __next = __first;
+      if (__first == __last
+	  || ++__next == __last)
+	return std::make_pair(__first, __first);
+
+      _ForwardIterator __min, __max;
+      if (__comp(__next, __first))
+	{
+	  __min = __next;
+	  __max = __first;
+	}
+      else
+	{
+	  __min = __first;
+	  __max = __next;
+	}
+
+      __first = __next;
+      ++__first;
+
+      while (__first != __last)
+	{
+	  __next = __first;
+	  if (++__next == __last)
+	    {
+	      if (__comp(__first, __min))
+		__min = __first;
+	      else if (!__comp(__first, __max))
+		__max = __first;
+	      break;
+	    }
+
+	  if (__comp(__next, __first))
+	    {
+	      if (__comp(__next, __min))
+		__min = __next;
+	      if (!__comp(__first, __max))
+		__max = __first;
+	    }
+	  else
+	    {
+	      if (__comp(__first, __min))
+		__min = __first;
+	      if (!__comp(__next, __max))
+		__max = __next;
+	    }
+
+	  __first = __next;
+	  ++__first;
+	}
+
+      return std::make_pair(__min, __max);
+    }
+
+  /**
+   *  @brief  Return a pair of iterators pointing to the minimum and maximum
+   *          elements in a range.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @return  make_pair(m, M), where m is the first iterator i in 
+   *           [__first, __last) such that no other element in the range is
+   *           smaller, and where M is the last iterator i in [__first, __last)
+   *           such that no other element in the range is larger.
+  */
+  template<typename _ForwardIterator>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__minmax_element(__first, __last,
+				   __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Return a pair of iterators pointing to the minimum and maximum
+   *          elements in a range.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @param  __comp   Comparison functor.
+   *  @return  make_pair(m, M), where m is the first iterator i in 
+   *           [__first, __last) such that no other element in the range is
+   *           smaller, and where M is the last iterator i in [__first, __last)
+   *           such that no other element in the range is larger.
+  */
+  template<typename _ForwardIterator, typename _Compare>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+		   _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__minmax_element(__first, __last,
+				   __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  // N2722 + DR 915.
+  template<typename _Tp>
+    inline _Tp
+    min(initializer_list<_Tp> __l)
+    { return *std::min_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    inline _Tp
+    min(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::min_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    inline _Tp
+    max(initializer_list<_Tp> __l)
+    { return *std::max_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    inline _Tp
+    max(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::max_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+	std::minmax_element(__l.begin(), __l.end());
+      return std::make_pair(*__p.first, *__p.second);
+    }
+
+  template<typename _Tp, typename _Compare>
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l, _Compare __comp)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+	std::minmax_element(__l.begin(), __l.end(), __comp);
+      return std::make_pair(*__p.first, *__p.second);
+    }
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		     _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+      // Efficiently compare identical prefixes:  O(N) if sequences
+      // have the same elements in the same order.
+      for (; __first1 != __last1; ++__first1, ++__first2)
+	if (!__pred(__first1, __first2))
+	  break;
+
+      if (__first1 == __last1)
+	return true;
+
+      // Establish __last2 assuming equal ranges by iterating over the
+      // rest of the list.
+      _ForwardIterator2 __last2 = __first2;
+      std::advance(__last2, std::distance(__first1, __last1));
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+	{
+	  if (__scan != std::__find_if(__first1, __scan,
+			  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+	    continue; // We've seen this one before.
+	  
+	  auto __matches
+	    = std::__count_if(__first2, __last2,
+			__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+	  if (0 == __matches ||
+	      std::__count_if(__scan, __last1,
+			__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+	      != __matches)
+	    return false;
+	}
+      return true;
+    }
+
+  /**
+   *  @brief  Checks whether a permutation of the second sequence is equal
+   *          to the first sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @return true if there exists a permutation of the elements in the range
+   *          [__first2, __first2 + (__last1 - __first1)), beginning with 
+   *          ForwardIterator2 begin, such that equal(__first1, __last1, begin)
+   *          returns true; otherwise, returns false.
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		   _ForwardIterator2 __first2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcxx_function_requires(_EqualOpConcept<
+		typename iterator_traits<_ForwardIterator1>::value_type,
+		typename iterator_traits<_ForwardIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      return std::__is_permutation(__first1, __last1, __first2,
+				   __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief  Checks whether a permutation of the second sequence is equal
+   *          to the first sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __pred    A binary predicate.
+   *  @return true if there exists a permutation of the elements in
+   *          the range [__first2, __first2 + (__last1 - __first1)),
+   *          beginning with ForwardIterator2 begin, such that
+   *          equal(__first1, __last1, __begin, __pred) returns true;
+   *          otherwise, returns false.
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		   _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      return std::__is_permutation(__first1, __last1, __first2,
+				   __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+
+#if __cplusplus > 201103L
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+		     _BinaryPredicate __pred)
+    {
+      using _Cat1
+	= typename iterator_traits<_ForwardIterator1>::iterator_category;
+      using _Cat2
+	= typename iterator_traits<_ForwardIterator2>::iterator_category;
+      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
+      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
+      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
+      if (__ra_iters)
+	{
+	  auto __d1 = std::distance(__first1, __last1);
+	  auto __d2 = std::distance(__first2, __last2);
+	  if (__d1 != __d2)
+	    return false;
+	}
+
+      // Efficiently compare identical prefixes:  O(N) if sequences
+      // have the same elements in the same order.
+      for (; __first1 != __last1; ++__first1, ++__first2)
+	if (!__pred(__first1, __first2))
+	  break;
+
+      if (__ra_iters)
+	{
+	  if (__first1 == __last1)
+	    return true;
+	}
+      else
+	{
+	  auto __d1 = std::distance(__first1, __last1);
+	  auto __d2 = std::distance(__first2, __last2);
+	  if (__d1 == 0 && __d2 == 0)
+	    return true;
+	  if (__d1 != __d2)
+	    return false;
+	}
+
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+	{
+	  if (__scan != std::__find_if(__first1, __scan,
+			__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+	    continue; // We've seen this one before.
+
+	  auto __matches = std::__count_if(__first2, __last2,
+		__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+	  if (0 == __matches
+	      || std::__count_if(__scan, __last1,
+			__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+	      != __matches)
+	    return false;
+	}
+      return true;
+    }
+
+  /**
+   *  @brief  Checks whether a permutaion of the second sequence is equal
+   *          to the first sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of first range.
+   *  @return true if there exists a permutation of the elements in the range
+   *          [__first2, __last2), beginning with ForwardIterator2 begin,
+   *          such that equal(__first1, __last1, begin) returns true;
+   *          otherwise, returns false.
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		   _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return
+	std::__is_permutation(__first1, __last1, __first2, __last2,
+			      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief  Checks whether a permutation of the second sequence is equal
+   *          to the first sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of first range.
+   *  @param  __pred    A binary predicate.
+   *  @return true if there exists a permutation of the elements in the range
+   *          [__first2, __last2), beginning with ForwardIterator2 begin,
+   *          such that equal(__first1, __last1, __begin, __pred) returns true;
+   *          otherwise, returns false.
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		   _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+		   _BinaryPredicate __pred)
+    {
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return std::__is_permutation(__first1, __last1, __first2, __last2,
+				   __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+#endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+  /**
+   *  @brief Shuffle the elements of a sequence using a uniform random
+   *         number generator.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A forward iterator.
+   *  @param  __last    A forward iterator.
+   *  @param  __g       A UniformRandomNumberGenerator (26.5.1.3).
+   *  @return  Nothing.
+   *
+   *  Reorders the elements in the range @p [__first,__last) using @p __g to
+   *  provide random numbers.
+  */
+  template<typename _RandomAccessIterator,
+	   typename _UniformRandomNumberGenerator>
+    void
+    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	    _UniformRandomNumberGenerator&& __g)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
+
+      typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
+      typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
+      typedef typename __distr_type::param_type __p_type;
+      __distr_type __d;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+	std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
+    }
+#endif
+
+#endif // C++11
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
+
+  /**
+   *  @brief Apply a function to every element of a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __f      A unary function object.
+   *  @return   @p __f (std::move(@p __f) in C++0x).
+   *
+   *  Applies the function object @p __f to each element in the range
+   *  @p [first,last).  @p __f must not modify the order of the sequence.
+   *  If @p __f has a return value it is ignored.
+  */
+  template<typename _InputIterator, typename _Function>
+    _Function
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+      for (; __first != __last; ++__first)
+	__f(*__first);
+      return _GLIBCXX_MOVE(__f);
+    }
+
+  /**
+   *  @brief Find the first occurrence of a value in a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __val    The value to find.
+   *  @return   The first iterator @c i in the range @p [__first,__last)
+   *  such that @c *i == @p __val, or @p __last if no such iterator exists.
+  */
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
+	 const _Tp& __val)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_EqualOpConcept<
+		typename iterator_traits<_InputIterator>::value_type, _Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+      return std::__find_if(__first, __last,
+			    __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+
+  /**
+   *  @brief Find the first element in a sequence for which a
+   *         predicate is true.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __pred   A predicate.
+   *  @return   The first iterator @c i in the range @p [__first,__last)
+   *  such that @p __pred(*i) is true, or @p __last if no such iterator exists.
+  */
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
+	    _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	      typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__find_if(__first, __last,
+			    __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  /**
+   *  @brief  Find element from a set in a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of range to search.
+   *  @param  __last1   End of range to search.
+   *  @param  __first2  Start of match candidates.
+   *  @param  __last2   End of match candidates.
+   *  @return   The first iterator @c i in the range
+   *  @p [__first1,__last1) such that @c *i == @p *(i2) such that i2 is an
+   *  iterator in [__first2,__last2), or @p __last1 if no such iterator exists.
+   *
+   *  Searches the range @p [__first1,__last1) for an element that is
+   *  equal to some element in the range [__first2,__last2).  If
+   *  found, returns an iterator in the range [__first1,__last1),
+   *  otherwise returns @p __last1.
+  */
+  template<typename _InputIterator, typename _ForwardIterator>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+		  _ForwardIterator __first2, _ForwardIterator __last2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_InputIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      for (; __first1 != __last1; ++__first1)
+	for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+	  if (*__first1 == *__iter)
+	    return __first1;
+      return __last1;
+    }
+
+  /**
+   *  @brief  Find element from a set in a sequence using a predicate.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  Start of range to search.
+   *  @param  __last1   End of range to search.
+   *  @param  __first2  Start of match candidates.
+   *  @param  __last2   End of match candidates.
+   *  @param  __comp    Predicate to use.
+   *  @return   The first iterator @c i in the range
+   *  @p [__first1,__last1) such that @c comp(*i, @p *(i2)) is true
+   *  and i2 is an iterator in [__first2,__last2), or @p __last1 if no
+   *  such iterator exists.
+   *
+
+   *  Searches the range @p [__first1,__last1) for an element that is
+   *  equal to some element in the range [__first2,__last2).  If
+   *  found, returns an iterator in the range [__first1,__last1),
+   *  otherwise returns @p __last1.
+  */
+  template<typename _InputIterator, typename _ForwardIterator,
+	   typename _BinaryPredicate>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+		  _ForwardIterator __first2, _ForwardIterator __last2,
+		  _BinaryPredicate __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_InputIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      for (; __first1 != __last1; ++__first1)
+	for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+	  if (__comp(*__first1, *__iter))
+	    return __first1;
+      return __last1;
+    }
+
+  /**
+   *  @brief Find two adjacent values in a sequence that are equal.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  A forward iterator.
+   *  @param  __last   A forward iterator.
+   *  @return   The first iterator @c i such that @c i and @c i+1 are both
+   *  valid iterators in @p [__first,__last) and such that @c *i == @c *(i+1),
+   *  or @p __last if no such iterator exists.
+  */
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_EqualityComparableConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__adjacent_find(__first, __last,
+				  __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief Find two adjacent values in a sequence using a predicate.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first         A forward iterator.
+   *  @param  __last          A forward iterator.
+   *  @param  __binary_pred   A binary predicate.
+   *  @return   The first iterator @c i such that @c i and @c i+1 are both
+   *  valid iterators in @p [__first,__last) and such that
+   *  @p __binary_pred(*i,*(i+1)) is true, or @p __last if no such iterator
+   *  exists.
+  */
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+		  _BinaryPredicate __binary_pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__adjacent_find(__first, __last,
+			__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+  /**
+   *  @brief Count the number of copies of a value in a sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __value  The value to be counted.
+   *  @return   The number of iterators @c i in the range @p [__first,__last)
+   *  for which @c *i == @p __value
+  */
+  template<typename _InputIterator, typename _Tp>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_InputIterator>::value_type, _Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__count_if(__first, __last,
+			     __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+
+  /**
+   *  @brief Count the elements of a sequence for which a predicate is true.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __pred   A predicate.
+   *  @return   The number of iterators @c i in the range @p [__first,__last)
+   *  for which @p __pred(*i) is true.
+  */
+  template<typename _InputIterator, typename _Predicate>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__count_if(__first, __last,
+			     __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  /**
+   *  @brief Search a sequence for a matching sub-sequence.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  A forward iterator.
+   *  @param  __last1   A forward iterator.
+   *  @param  __first2  A forward iterator.
+   *  @param  __last2   A forward iterator.
+   *  @return The first iterator @c i in the range @p
+   *  [__first1,__last1-(__last2-__first2)) such that @c *(i+N) == @p
+   *  *(__first2+N) for each @c N in the range @p
+   *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
+   *
+   *  Searches the range @p [__first1,__last1) for a sub-sequence that
+   *  compares equal value-by-value with the sequence given by @p
+   *  [__first2,__last2) and returns an iterator to the first element
+   *  of the sub-sequence, or @p __last1 if the sub-sequence is not
+   *  found.
+   *
+   *  Because the sub-sequence must lie completely within the range @p
+   *  [__first1,__last1) it must start at a position less than @p
+   *  __last1-(__last2-__first2) where @p __last2-__first2 is the
+   *  length of the sub-sequence.
+   *
+   *  This means that the returned iterator @c i will be in the range
+   *  @p [__first1,__last1-(__last2-__first2))
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	   _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return std::__search(__first1, __last1, __first2, __last2,
+			   __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief Search a sequence for a matching sub-sequence using a predicate.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1     A forward iterator.
+   *  @param  __last1      A forward iterator.
+   *  @param  __first2     A forward iterator.
+   *  @param  __last2      A forward iterator.
+   *  @param  __predicate  A binary predicate.
+   *  @return   The first iterator @c i in the range
+   *  @p [__first1,__last1-(__last2-__first2)) such that
+   *  @p __predicate(*(i+N),*(__first2+N)) is true for each @c N in the range
+   *  @p [0,__last2-__first2), or @p __last1 if no such iterator exists.
+   *
+   *  Searches the range @p [__first1,__last1) for a sub-sequence that
+   *  compares equal value-by-value with the sequence given by @p
+   *  [__first2,__last2), using @p __predicate to determine equality,
+   *  and returns an iterator to the first element of the
+   *  sub-sequence, or @p __last1 if no such iterator exists.
+   *
+   *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+	   _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+	   _BinaryPredicate  __predicate)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_ForwardIterator1>::value_type,
+	    typename iterator_traits<_ForwardIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return std::__search(__first1, __last1, __first2, __last2,
+			   __gnu_cxx::__ops::__iter_comp_iter(__predicate));
+    }
+
+  /**
+   *  @brief Search a sequence for a number of consecutive values.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first  A forward iterator.
+   *  @param  __last   A forward iterator.
+   *  @param  __count  The number of consecutive values.
+   *  @param  __val    The value to find.
+   *  @return The first iterator @c i in the range @p
+   *  [__first,__last-__count) such that @c *(i+N) == @p __val for
+   *  each @c N in the range @p [0,__count), or @p __last if no such
+   *  iterator exists.
+   *
+   *  Searches the range @p [__first,__last) for @p count consecutive elements
+   *  equal to @p __val.
+  */
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+	     _Integer __count, const _Tp& __val)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__search_n(__first, __last, __count,
+			     __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+
+
+  /**
+   *  @brief Search a sequence for a number of consecutive values using a
+   *         predicate.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first        A forward iterator.
+   *  @param  __last         A forward iterator.
+   *  @param  __count        The number of consecutive values.
+   *  @param  __val          The value to find.
+   *  @param  __binary_pred  A binary predicate.
+   *  @return The first iterator @c i in the range @p
+   *  [__first,__last-__count) such that @p
+   *  __binary_pred(*(i+N),__val) is true for each @c N in the range
+   *  @p [0,__count), or @p __last if no such iterator exists.
+   *
+   *  Searches the range @p [__first,__last) for @p __count
+   *  consecutive elements for which the predicate returns true.
+  */
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+	     _Integer __count, const _Tp& __val,
+	     _BinaryPredicate __binary_pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__search_n(__first, __last, __count,
+		__gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
+    }
+
+
+  /**
+   *  @brief Perform an operation on a sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first     An input iterator.
+   *  @param  __last      An input iterator.
+   *  @param  __result    An output iterator.
+   *  @param  __unary_op  A unary operator.
+   *  @return   An output iterator equal to @p __result+(__last-__first).
+   *
+   *  Applies the operator to each element in the input range and assigns
+   *  the results to successive elements of the output sequence.
+   *  Evaluates @p *(__result+N)=unary_op(*(__first+N)) for each @c N in the
+   *  range @p [0,__last-__first).
+   *
+   *  @p unary_op must not alter its argument.
+  */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _UnaryOperation>
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+	      _OutputIterator __result, _UnaryOperation __unary_op)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+            // "the type returned by a _UnaryOperation"
+            __typeof__(__unary_op(*__first))>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first, ++__result)
+	*__result = __unary_op(*__first);
+      return __result;
+    }
+
+  /**
+   *  @brief Perform an operation on corresponding elements of two sequences.
+   *  @ingroup mutating_algorithms
+   *  @param  __first1     An input iterator.
+   *  @param  __last1      An input iterator.
+   *  @param  __first2     An input iterator.
+   *  @param  __result     An output iterator.
+   *  @param  __binary_op  A binary operator.
+   *  @return   An output iterator equal to @p result+(last-first).
+   *
+   *  Applies the operator to the corresponding elements in the two
+   *  input ranges and assigns the results to successive elements of the
+   *  output sequence.
+   *  Evaluates @p
+   *  *(__result+N)=__binary_op(*(__first1+N),*(__first2+N)) for each
+   *  @c N in the range @p [0,__last1-__first1).
+   *
+   *  @p binary_op must not alter either of its arguments.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _BinaryOperation>
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+	      _InputIterator2 __first2, _OutputIterator __result,
+	      _BinaryOperation __binary_op)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+            // "the type returned by a _BinaryOperation"
+            __typeof__(__binary_op(*__first1,*__first2))>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
+	*__result = __binary_op(*__first1, *__first2);
+      return __result;
+    }
+
+  /**
+   *  @brief Replace each occurrence of one value in a sequence with another
+   *         value.
+   *  @ingroup mutating_algorithms
+   *  @param  __first      A forward iterator.
+   *  @param  __last       A forward iterator.
+   *  @param  __old_value  The value to be replaced.
+   *  @param  __new_value  The replacement value.
+   *  @return   replace() returns no value.
+   *
+   *  For each iterator @c i in the range @p [__first,__last) if @c *i ==
+   *  @p __old_value then the assignment @c *i = @p __new_value is performed.
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    void
+    replace(_ForwardIterator __first, _ForwardIterator __last,
+	    const _Tp& __old_value, const _Tp& __new_value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
+      __glibcxx_function_requires(_ConvertibleConcept<_Tp,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first)
+	if (*__first == __old_value)
+	  *__first = __new_value;
+    }
+
+  /**
+   *  @brief Replace each value in a sequence for which a predicate returns
+   *         true with another value.
+   *  @ingroup mutating_algorithms
+   *  @param  __first      A forward iterator.
+   *  @param  __last       A forward iterator.
+   *  @param  __pred       A predicate.
+   *  @param  __new_value  The replacement value.
+   *  @return   replace_if() returns no value.
+   *
+   *  For each iterator @c i in the range @p [__first,__last) if @p __pred(*i)
+   *  is true then the assignment @c *i = @p __new_value is performed.
+  */
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+    void
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
+	       _Predicate __pred, const _Tp& __new_value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_ConvertibleConcept<_Tp,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first)
+	if (__pred(*__first))
+	  *__first = __new_value;
+    }
+
+  /**
+   *  @brief Assign the result of a function object to each value in a
+   *         sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A forward iterator.
+   *  @param  __last   A forward iterator.
+   *  @param  __gen    A function object taking no arguments and returning
+   *                 std::iterator_traits<_ForwardIterator>::value_type
+   *  @return   generate() returns no value.
+   *
+   *  Performs the assignment @c *i = @p __gen() for each @c i in the range
+   *  @p [__first,__last).
+  */
+  template<typename _ForwardIterator, typename _Generator>
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+	     _Generator __gen)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_GeneratorConcept<_Generator,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first)
+	*__first = __gen();
+    }
+
+  /**
+   *  @brief Assign the result of a function object to each value in a
+   *         sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A forward iterator.
+   *  @param  __n      The length of the sequence.
+   *  @param  __gen    A function object taking no arguments and returning
+   *                 std::iterator_traits<_ForwardIterator>::value_type
+   *  @return   The end of the sequence, @p __first+__n
+   *
+   *  Performs the assignment @c *i = @p __gen() for each @c i in the range
+   *  @p [__first,__first+__n).
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  DR 865. More algorithms that throw away information
+  */
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+            // "the type returned by a _Generator"
+            __typeof__(__gen())>)
+
+      for (__decltype(__n + 0) __niter = __n;
+	   __niter > 0; --__niter, ++__first)
+	*__first = __gen();
+      return __first;
+    }
+
+  /**
+   *  @brief Copy a sequence, removing consecutive duplicate values.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   An input iterator.
+   *  @param  __last    An input iterator.
+   *  @param  __result  An output iterator.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [__first,__last) to the range
+   *  beginning at @p __result, except that only the first element is copied
+   *  from groups of consecutive elements that compare equal.
+   *  unique_copy() is stable, so the relative order of elements that are
+   *  copied is unchanged.
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
+   *  
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  DR 538. 241 again: Does unique_copy() require CopyConstructible and 
+   *  Assignable?
+  */
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_function_requires(_EqualityComparableConcept<
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return __result;
+      return std::__unique_copy(__first, __last, __result,
+				__gnu_cxx::__ops::__iter_equal_to_iter(),
+				std::__iterator_category(__first),
+				std::__iterator_category(__result));
+    }
+
+  /**
+   *  @brief Copy a sequence, removing consecutive values using a predicate.
+   *  @ingroup mutating_algorithms
+   *  @param  __first        An input iterator.
+   *  @param  __last         An input iterator.
+   *  @param  __result       An output iterator.
+   *  @param  __binary_pred  A binary predicate.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [__first,__last) to the range
+   *  beginning at @p __result, except that only the first element is copied
+   *  from groups of consecutive elements for which @p __binary_pred returns
+   *  true.
+   *  unique_copy() is stable, so the relative order of elements that are
+   *  copied is unchanged.
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
+  */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _BinaryPredicate>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result,
+		_BinaryPredicate __binary_pred)
+    {
+      // concept requirements -- predicates checked later
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return __result;
+      return std::__unique_copy(__first, __last, __result,
+			__gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
+				std::__iterator_category(__first),
+				std::__iterator_category(__result));
+    }
+
+  /**
+   *  @brief Randomly shuffle the elements of a sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A forward iterator.
+   *  @param  __last    A forward iterator.
+   *  @return  Nothing.
+   *
+   *  Reorder the elements in the range @p [__first,__last) using a random
+   *  distribution, so that every possible ordering of the sequence is
+   *  equally likely.
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first != __last)
+	for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+	  std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
+    }
+
+  /**
+   *  @brief Shuffle the elements of a sequence using a random number
+   *         generator.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A forward iterator.
+   *  @param  __last    A forward iterator.
+   *  @param  __rand    The RNG functor or function.
+   *  @return  Nothing.
+   *
+   *  Reorders the elements in the range @p [__first,__last) using @p __rand to
+   *  provide a random distribution. Calling @p __rand(N) for a positive
+   *  integer @p N should return a randomly chosen integer from the
+   *  range [0,N).
+  */
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+#if __cplusplus >= 201103L
+		   _RandomNumberGenerator&& __rand)
+#else
+		   _RandomNumberGenerator& __rand)
+#endif
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+	std::iter_swap(__i, __first + __rand((__i - __first) + 1));
+    }
+
+
+  /**
+   *  @brief Move elements for which a predicate is true to the beginning
+   *         of a sequence.
+   *  @ingroup mutating_algorithms
+   *  @param  __first   A forward iterator.
+   *  @param  __last    A forward iterator.
+   *  @param  __pred    A predicate functor.
+   *  @return  An iterator @p middle such that @p __pred(i) is true for each
+   *  iterator @p i in the range @p [__first,middle) and false for each @p i
+   *  in the range @p [middle,__last).
+   *
+   *  @p __pred must not modify its operand. @p partition() does not preserve
+   *  the relative ordering of elements in each group, use
+   *  @p stable_partition() if this is needed.
+  */
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
+	      _Predicate   __pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__partition(__first, __last, __pred,
+			      std::__iterator_category(__first));
+    }
+
+
+  /**
+   *  @brief Sort the smallest elements of a sequence.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __middle  Another iterator.
+   *  @param  __last    Another iterator.
+   *  @return  Nothing.
+   *
+   *  Sorts the smallest @p (__middle-__first) elements in the range
+   *  @p [first,last) and moves them to the range @p [__first,__middle). The
+   *  order of the remaining elements in the range @p [__middle,__last) is
+   *  undefined.
+   *  After the sort if @e i and @e j are iterators in the range
+   *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
+   *  the range @p [__middle,__last) then *j<*i and *k<*i are both false.
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+		 _RandomAccessIterator __middle,
+		 _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __middle);
+      __glibcxx_requires_valid_range(__middle, __last);
+
+      std::__partial_sort(__first, __middle, __last,
+			  __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Sort the smallest elements of a sequence using a predicate
+   *         for comparison.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __middle  Another iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __comp    A comparison functor.
+   *  @return  Nothing.
+   *
+   *  Sorts the smallest @p (__middle-__first) elements in the range
+   *  @p [__first,__last) and moves them to the range @p [__first,__middle). The
+   *  order of the remaining elements in the range @p [__middle,__last) is
+   *  undefined.
+   *  After the sort if @e i and @e j are iterators in the range
+   *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
+   *  the range @p [__middle,__last) then @p *__comp(j,*i) and @p __comp(*k,*i)
+   *  are both false.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+		 _RandomAccessIterator __middle,
+		 _RandomAccessIterator __last,
+		 _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_RandomAccessIterator>::value_type,
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __middle);
+      __glibcxx_requires_valid_range(__middle, __last);
+
+      std::__partial_sort(__first, __middle, __last,
+			  __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  /**
+   *  @brief Sort a sequence just enough to find a particular position.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __nth     Another iterator.
+   *  @param  __last    Another iterator.
+   *  @return  Nothing.
+   *
+   *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
+   *  is the same element that would have been in that position had the
+   *  whole sequence been sorted. The elements either side of @p *__nth are
+   *  not completely sorted, but for any iterator @e i in the range
+   *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
+   *  holds that *j < *i is false.
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+		_RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __nth);
+      __glibcxx_requires_valid_range(__nth, __last);
+
+      if (__first == __last || __nth == __last)
+	return;
+
+      std::__introselect(__first, __nth, __last,
+			 std::__lg(__last - __first) * 2,
+			 __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Sort a sequence just enough to find a particular position
+   *         using a predicate for comparison.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __nth     Another iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __comp    A comparison functor.
+   *  @return  Nothing.
+   *
+   *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
+   *  is the same element that would have been in that position had the
+   *  whole sequence been sorted. The elements either side of @p *__nth are
+   *  not completely sorted, but for any iterator @e i in the range
+   *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
+   *  holds that @p __comp(*j,*i) is false.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+		_RandomAccessIterator __last, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_RandomAccessIterator>::value_type,
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __nth);
+      __glibcxx_requires_valid_range(__nth, __last);
+
+      if (__first == __last || __nth == __last)
+	return;
+
+      std::__introselect(__first, __nth, __last,
+			 std::__lg(__last - __first) * 2,
+			 __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  /**
+   *  @brief Sort the elements of a sequence.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @return  Nothing.
+   *
+   *  Sorts the elements in the range @p [__first,__last) in ascending order,
+   *  such that for each iterator @e i in the range @p [__first,__last-1),  
+   *  *(i+1)<*i is false.
+   *
+   *  The relative ordering of equivalent elements is not preserved, use
+   *  @p stable_sort() if this is needed.
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Sort the elements of a sequence using a predicate for comparison.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __comp    A comparison functor.
+   *  @return  Nothing.
+   *
+   *  Sorts the elements in the range @p [__first,__last) in ascending order,
+   *  such that @p __comp(*(i+1),*i) is false for every iterator @e i in the
+   *  range @p [__first,__last-1).
+   *
+   *  The relative ordering of equivalent elements is not preserved, use
+   *  @p stable_sort() if this is needed.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	 _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_RandomAccessIterator>::value_type,
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
+	    _InputIterator2 __first2, _InputIterator2 __last2,
+	    _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (__comp(__first2, __first1))
+	    {
+	      *__result = *__first2;
+	      ++__first2;
+	    }
+	  else
+	    {
+	      *__result = *__first1;
+	      ++__first1;
+	    }
+	  ++__result;
+	}
+      return std::copy(__first2, __last2,
+		       std::copy(__first1, __last1, __result));
+    }
+
+  /**
+   *  @brief Merges two sorted ranges.
+   *  @ingroup sorting_algorithms
+   *  @param  __first1  An iterator.
+   *  @param  __first2  Another iterator.
+   *  @param  __last1   Another iterator.
+   *  @param  __last2   Another iterator.
+   *  @param  __result  An iterator pointing to the end of the merged range.
+   *  @return         An iterator pointing to the first element <em>not less
+   *                  than</em> @e val.
+   *
+   *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
+   *  the sorted range @p [__result, __result + (__last1-__first1) +
+   *  (__last2-__first2)).  Both input ranges must be sorted, and the
+   *  output range must not overlap with either of the input ranges.
+   *  The sort is @e stable, that is, for equivalent elements in the
+   *  two ranges, elements from the first range will always come
+   *  before elements from the second.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+	  _InputIterator2 __first2, _InputIterator2 __last2,
+	  _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)	
+      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
+      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
+
+      return _GLIBCXX_STD_A::__merge(__first1, __last1,
+				     __first2, __last2, __result,
+				     __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Merges two sorted ranges.
+   *  @ingroup sorting_algorithms
+   *  @param  __first1  An iterator.
+   *  @param  __first2  Another iterator.
+   *  @param  __last1   Another iterator.
+   *  @param  __last2   Another iterator.
+   *  @param  __result  An iterator pointing to the end of the merged range.
+   *  @param  __comp    A functor to use for comparisons.
+   *  @return         An iterator pointing to the first element "not less
+   *                  than" @e val.
+   *
+   *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
+   *  the sorted range @p [__result, __result + (__last1-__first1) +
+   *  (__last2-__first2)).  Both input ranges must be sorted, and the
+   *  output range must not overlap with either of the input ranges.
+   *  The sort is @e stable, that is, for equivalent elements in the
+   *  two ranges, elements from the first range will always come
+   *  before elements from the second.
+   *
+   *  The comparison function should have the same effects on ordering as
+   *  the function used for the initial sort.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+	  _InputIterator2 __first2, _InputIterator2 __last2,
+	  _OutputIterator __result, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
+      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
+
+      return _GLIBCXX_STD_A::__merge(__first1, __last1,
+				__first2, __last2, __result,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+		  _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
+
+      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+
+      if (__buf.begin() == 0)
+	std::__inplace_stable_sort(__first, __last, __comp);
+      else
+	std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+				    _DistanceType(__buf.size()), __comp);
+    }
+
+  /**
+   *  @brief Sort the elements of a sequence, preserving the relative order
+   *         of equivalent elements.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @return  Nothing.
+   *
+   *  Sorts the elements in the range @p [__first,__last) in ascending order,
+   *  such that for each iterator @p i in the range @p [__first,__last-1),
+   *  @p *(i+1)<*i is false.
+   *
+   *  The relative ordering of equivalent elements is preserved, so any two
+   *  elements @p x and @p y in the range @p [__first,__last) such that
+   *  @p x<y is false and @p y<x is false will have the same relative
+   *  ordering after calling @p stable_sort().
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      _GLIBCXX_STD_A::__stable_sort(__first, __last,
+				    __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Sort the elements of a sequence using a predicate for comparison,
+   *         preserving the relative order of equivalent elements.
+   *  @ingroup sorting_algorithms
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __comp    A comparison functor.
+   *  @return  Nothing.
+   *
+   *  Sorts the elements in the range @p [__first,__last) in ascending order,
+   *  such that for each iterator @p i in the range @p [__first,__last-1),
+   *  @p __comp(*(i+1),*i) is false.
+   *
+   *  The relative ordering of equivalent elements is preserved, so any two
+   *  elements @p x and @p y in the range @p [__first,__last) such that
+   *  @p __comp(x,y) is false and @p __comp(y,x) is false will have the same
+   *  relative ordering after calling @p stable_sort().
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+		_Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_RandomAccessIterator>::value_type,
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      _GLIBCXX_STD_A::__stable_sort(__first, __last,
+				    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator,
+	   typename _Compare>
+    _OutputIterator
+    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+		_InputIterator2 __first2, _InputIterator2 __last2,
+		_OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (__comp(__first1, __first2))
+	    {
+	      *__result = *__first1;
+	      ++__first1;
+	    }
+	  else if (__comp(__first2, __first1))
+	    {
+	      *__result = *__first2;
+	      ++__first2;
+	    }
+	  else
+	    {
+	      *__result = *__first1;
+	      ++__first1;
+	      ++__first2;
+	    }
+	  ++__result;
+	}
+      return std::copy(__first2, __last2,
+		       std::copy(__first1, __last1, __result));
+    }
+
+  /**
+   *  @brief Return the union of two sorted ranges.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  each range in order to the output range.  Iterators increment for each
+   *  range.  When the current element of one range is less than the other,
+   *  that element is copied and the iterator advanced.  If an element is
+   *  contained in both ranges, the element from the first range is copied and
+   *  both ranges advance.  The output range may not overlap either input
+   *  range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+	      _InputIterator2 __first2, _InputIterator2 __last2,
+	      _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
+      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
+
+      return _GLIBCXX_STD_A::__set_union(__first1, __last1,
+				__first2, __last2, __result,
+				__gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Return the union of two sorted ranges using a comparison functor.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @param  __comp    The comparison functor.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  each range in order to the output range.  Iterators increment for each
+   *  range.  When the current element of one range is less than the other
+   *  according to @p __comp, that element is copied and the iterator advanced.
+   *  If an equivalent element according to @p __comp is contained in both
+   *  ranges, the element from the first range is copied and both ranges
+   *  advance.  The output range may not overlap either input range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+	      _InputIterator2 __first2, _InputIterator2 __last2,
+	      _OutputIterator __result, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
+      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
+
+      return _GLIBCXX_STD_A::__set_union(__first1, __last1,
+				__first2, __last2, __result,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator,
+	   typename _Compare>
+    _OutputIterator
+    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+		       _InputIterator2 __first2, _InputIterator2 __last2,
+		       _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	if (__comp(__first1, __first2))
+	  ++__first1;
+	else if (__comp(__first2, __first1))
+	  ++__first2;
+	else
+	  {
+	    *__result = *__first1;
+	    ++__first1;
+	    ++__first2;
+	    ++__result;
+	  }
+      return __result;
+    }
+
+  /**
+   *  @brief Return the intersection of two sorted ranges.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  both ranges in order to the output range.  Iterators increment for each
+   *  range.  When the current element of one range is less than the other,
+   *  that iterator advances.  If an element is contained in both ranges, the
+   *  element from the first range is copied and both ranges advance.  The
+   *  output range may not overlap either input range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+		     _InputIterator2 __first2, _InputIterator2 __last2,
+		     _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
+      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
+
+      return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,
+				     __first2, __last2, __result,
+				     __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief Return the intersection of two sorted ranges using comparison
+   *  functor.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @param  __comp    The comparison functor.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  both ranges in order to the output range.  Iterators increment for each
+   *  range.  When the current element of one range is less than the other
+   *  according to @p __comp, that iterator advances.  If an element is
+   *  contained in both ranges according to @p __comp, the element from the
+   *  first range is copied and both ranges advance.  The output range may not
+   *  overlap either input range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+		     _InputIterator2 __first2, _InputIterator2 __last2,
+		     _OutputIterator __result, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
+      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
+
+      return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,
+				__first2, __last2, __result,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator,
+	   typename _Compare>
+    _OutputIterator
+    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+		     _InputIterator2 __first2, _InputIterator2 __last2,
+		     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	if (__comp(__first1, __first2))
+	  {
+	    *__result = *__first1;
+	    ++__first1;
+	    ++__result;
+	  }
+	else if (__comp(__first2, __first1))
+	  ++__first2;
+	else
+	  {
+	    ++__first1;
+	    ++__first2;
+	  }
+      return std::copy(__first1, __last1, __result);
+    }
+
+  /**
+   *  @brief Return the difference of two sorted ranges.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  the first range but not the second in order to the output range.
+   *  Iterators increment for each range.  When the current element of the
+   *  first range is less than the second, that element is copied and the
+   *  iterator advances.  If the current element of the second range is less,
+   *  the iterator advances, but no element is copied.  If an element is
+   *  contained in both ranges, no elements are copied and both ranges
+   *  advance.  The output range may not overlap either input range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+		   _InputIterator2 __first2, _InputIterator2 __last2,
+		   _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)	
+      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
+      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
+
+      return _GLIBCXX_STD_A::__set_difference(__first1, __last1,
+				   __first2, __last2, __result,
+				   __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Return the difference of two sorted ranges using comparison
+   *  functor.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @param  __comp    The comparison functor.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  the first range but not the second in order to the output range.
+   *  Iterators increment for each range.  When the current element of the
+   *  first range is less than the second according to @p __comp, that element
+   *  is copied and the iterator advances.  If the current element of the
+   *  second range is less, no element is copied and the iterator advances.
+   *  If an element is contained in both ranges according to @p __comp, no
+   *  elements are copied and both ranges advance.  The output range may not
+   *  overlap either input range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+		   _InputIterator2 __first2, _InputIterator2 __last2,
+		   _OutputIterator __result, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
+      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
+
+      return _GLIBCXX_STD_A::__set_difference(__first1, __last1,
+				   __first2, __last2, __result,
+				   __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator,
+	   typename _Compare>
+    _OutputIterator
+    __set_symmetric_difference(_InputIterator1 __first1,
+			       _InputIterator1 __last1,
+			       _InputIterator2 __first2,
+			       _InputIterator2 __last2,
+			       _OutputIterator __result,
+			       _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	if (__comp(__first1, __first2))
+	  {
+	    *__result = *__first1;
+	    ++__first1;
+	    ++__result;
+	  }
+	else if (__comp(__first2, __first1))
+	  {
+	    *__result = *__first2;
+	    ++__first2;
+	    ++__result;
+	  }
+	else
+	  {
+	    ++__first1;
+	    ++__first2;
+	  }
+      return std::copy(__first2, __last2, 
+		       std::copy(__first1, __last1, __result));
+    }
+
+  /**
+   *  @brief  Return the symmetric difference of two sorted ranges.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  one range but not the other in order to the output range.  Iterators
+   *  increment for each range.  When the current element of one range is less
+   *  than the other, that element is copied and the iterator advances.  If an
+   *  element is contained in both ranges, no elements are copied and both
+   *  ranges advance.  The output range may not overlap either input range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+			     _InputIterator2 __first2, _InputIterator2 __last2,
+			     _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)	
+      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
+      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
+
+      return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,
+					__first2, __last2, __result,
+					__gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Return the symmetric difference of two sorted ranges using
+   *  comparison functor.
+   *  @ingroup set_algorithms
+   *  @param  __first1  Start of first range.
+   *  @param  __last1   End of first range.
+   *  @param  __first2  Start of second range.
+   *  @param  __last2   End of second range.
+   *  @param  __comp    The comparison functor.
+   *  @return  End of the output range.
+   *  @ingroup set_algorithms
+   *
+   *  This operation iterates over both ranges, copying elements present in
+   *  one range but not the other in order to the output range.  Iterators
+   *  increment for each range.  When the current element of one range is less
+   *  than the other according to @p comp, that element is copied and the
+   *  iterator advances.  If an element is contained in both ranges according
+   *  to @p __comp, no elements are copied and both ranges advance.  The output
+   *  range may not overlap either input range.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+			     _InputIterator2 __first2, _InputIterator2 __last2,
+			     _OutputIterator __result,
+			     _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_InputIterator2>::value_type,
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
+      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
+
+      return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,
+				__first2, __last2, __result,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    __min_element(_ForwardIterator __first, _ForwardIterator __last,
+		  _Compare __comp)
+    {
+      if (__first == __last)
+	return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+	if (__comp(__first, __result))
+	  __result = __first;
+      return __result;
+    }
+
+  /**
+   *  @brief  Return the minimum element in a range.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @return  Iterator referencing the first instance of the smallest value.
+  */
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return _GLIBCXX_STD_A::__min_element(__first, __last,
+				__gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Return the minimum element in a range using comparison functor.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @param  __comp   Comparison functor.
+   *  @return  Iterator referencing the first instance of the smallest value
+   *  according to __comp.
+  */
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
+		_Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return _GLIBCXX_STD_A::__min_element(__first, __last,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    __max_element(_ForwardIterator __first, _ForwardIterator __last,
+		  _Compare __comp)
+    {
+      if (__first == __last) return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+	if (__comp(__result, __first))
+	  __result = __first;
+      return __result;
+    }
+
+  /**
+   *  @brief  Return the maximum element in a range.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @return  Iterator referencing the first instance of the largest value.
+  */
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return _GLIBCXX_STD_A::__max_element(__first, __last,
+				__gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Return the maximum element in a range using comparison functor.
+   *  @ingroup sorting_algorithms
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @param  __comp   Comparison functor.
+   *  @return  Iterator referencing the first instance of the largest value
+   *  according to __comp.
+  */
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
+		_Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return _GLIBCXX_STD_A::__max_element(__first, __last,
+				__gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
+
+#endif /* _STL_ALGO_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_algobase.h b/gcc-4.9/libstdc++-v3/include/bits/stl_algobase.h
new file mode 100644
index 0000000..5ff21be
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_algobase.h
@@ -0,0 +1,1424 @@
+// Core algorithmic facilities -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_algobase.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{algorithm}
+ */
+
+#ifndef _STL_ALGOBASE_H
+#define _STL_ALGOBASE_H 1
+
+#include <bits/c++config.h>
+#include <bits/functexcept.h>
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+#include <ext/numeric_traits.h>
+#include <bits/stl_pair.h>
+#include <bits/stl_iterator_base_types.h>
+#include <bits/stl_iterator_base_funcs.h>
+#include <bits/stl_iterator.h>
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+#include <bits/move.h> // For std::swap and _GLIBCXX_MOVE
+#include <bits/predefined_ops.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if __cplusplus < 201103L
+  // See http://gcc.gnu.org/ml/libstdc++/2004-08/msg00167.html: in a
+  // nutshell, we are partially implementing the resolution of DR 187,
+  // when it's safe, i.e., the value_types are equal.
+  template<bool _BoolType>
+    struct __iter_swap
+    {
+      template<typename _ForwardIterator1, typename _ForwardIterator2>
+        static void
+        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+        {
+          typedef typename iterator_traits<_ForwardIterator1>::value_type
+            _ValueType1;
+          _ValueType1 __tmp = _GLIBCXX_MOVE(*__a);
+          *__a = _GLIBCXX_MOVE(*__b);
+          *__b = _GLIBCXX_MOVE(__tmp);
+	}
+    };
+
+  template<>
+    struct __iter_swap<true>
+    {
+      template<typename _ForwardIterator1, typename _ForwardIterator2>
+        static void 
+        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+        {
+          swap(*__a, *__b);
+        }
+    };
+#endif
+
+  /**
+   *  @brief Swaps the contents of two iterators.
+   *  @ingroup mutating_algorithms
+   *  @param  __a  An iterator.
+   *  @param  __b  Another iterator.
+   *  @return   Nothing.
+   *
+   *  This function swaps the values pointed to by two iterators, not the
+   *  iterators themselves.
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator1>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator2>)
+
+#if __cplusplus < 201103L
+      typedef typename iterator_traits<_ForwardIterator1>::value_type
+	_ValueType1;
+      typedef typename iterator_traits<_ForwardIterator2>::value_type
+	_ValueType2;
+
+      __glibcxx_function_requires(_ConvertibleConcept<_ValueType1,
+				  _ValueType2>)
+      __glibcxx_function_requires(_ConvertibleConcept<_ValueType2,
+				  _ValueType1>)
+
+      typedef typename iterator_traits<_ForwardIterator1>::reference
+	_ReferenceType1;
+      typedef typename iterator_traits<_ForwardIterator2>::reference
+	_ReferenceType2;
+      std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
+	&& __are_same<_ValueType1&, _ReferenceType1>::__value
+	&& __are_same<_ValueType2&, _ReferenceType2>::__value>::
+	iter_swap(__a, __b);
+#else
+      swap(*__a, *__b);
+#endif
+    }
+
+  /**
+   *  @brief Swap the elements of two sequences.
+   *  @ingroup mutating_algorithms
+   *  @param  __first1  A forward iterator.
+   *  @param  __last1   A forward iterator.
+   *  @param  __first2  A forward iterator.
+   *  @return   An iterator equal to @p first2+(last1-first1).
+   *
+   *  Swaps each element in the range @p [first1,last1) with the
+   *  corresponding element in the range @p [first2,(last1-first1)).
+   *  The ranges must not overlap.
+  */
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+		_ForwardIterator2 __first2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator1>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+	std::iter_swap(__first1, __first2);
+      return __first2;
+    }
+
+  /**
+   *  @brief This does what you think it does.
+   *  @ingroup sorting_algorithms
+   *  @param  __a  A thing of arbitrary type.
+   *  @param  __b  Another thing of arbitrary type.
+   *  @return   The lesser of the parameters.
+   *
+   *  This is the simple classic generic implementation.  It will work on
+   *  temporary expressions, since they are only evaluated once, unlike a
+   *  preprocessor macro.
+  */
+  template<typename _Tp>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
+      //return __b < __a ? __b : __a;
+      if (__b < __a)
+	return __b;
+      return __a;
+    }
+
+  /**
+   *  @brief This does what you think it does.
+   *  @ingroup sorting_algorithms
+   *  @param  __a  A thing of arbitrary type.
+   *  @param  __b  Another thing of arbitrary type.
+   *  @return   The greater of the parameters.
+   *
+   *  This is the simple classic generic implementation.  It will work on
+   *  temporary expressions, since they are only evaluated once, unlike a
+   *  preprocessor macro.
+  */
+  template<typename _Tp>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
+      //return  __a < __b ? __b : __a;
+      if (__a < __b)
+	return __b;
+      return __a;
+    }
+
+  /**
+   *  @brief This does what you think it does.
+   *  @ingroup sorting_algorithms
+   *  @param  __a  A thing of arbitrary type.
+   *  @param  __b  Another thing of arbitrary type.
+   *  @param  __comp  A @link comparison_functors comparison functor@endlink.
+   *  @return   The lesser of the parameters.
+   *
+   *  This will work on temporary expressions, since they are only evaluated
+   *  once, unlike a preprocessor macro.
+  */
+  template<typename _Tp, typename _Compare>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      //return __comp(__b, __a) ? __b : __a;
+      if (__comp(__b, __a))
+	return __b;
+      return __a;
+    }
+
+  /**
+   *  @brief This does what you think it does.
+   *  @ingroup sorting_algorithms
+   *  @param  __a  A thing of arbitrary type.
+   *  @param  __b  Another thing of arbitrary type.
+   *  @param  __comp  A @link comparison_functors comparison functor@endlink.
+   *  @return   The greater of the parameters.
+   *
+   *  This will work on temporary expressions, since they are only evaluated
+   *  once, unlike a preprocessor macro.
+  */
+  template<typename _Tp, typename _Compare>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      //return __comp(__a, __b) ? __b : __a;
+      if (__comp(__a, __b))
+	return __b;
+      return __a;
+    }
+
+  // If _Iterator is a __normal_iterator return its base (a plain pointer,
+  // normally) otherwise return it untouched.  See copy, fill, ... 
+  template<typename _Iterator>
+    struct _Niter_base
+    : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
+    { };
+
+  template<typename _Iterator>
+    inline typename _Niter_base<_Iterator>::iterator_type
+    __niter_base(_Iterator __it)
+    { return std::_Niter_base<_Iterator>::_S_base(__it); }
+
+  // Likewise, for move_iterator.
+  template<typename _Iterator>
+    struct _Miter_base
+    : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
+    { };
+
+  template<typename _Iterator>
+    inline typename _Miter_base<_Iterator>::iterator_type
+    __miter_base(_Iterator __it)
+    { return std::_Miter_base<_Iterator>::_S_base(__it); }
+
+  // All of these auxiliary structs serve two purposes.  (1) Replace
+  // calls to copy with memmove whenever possible.  (Memmove, not memcpy,
+  // because the input and output ranges are permitted to overlap.)
+  // (2) If we're using random access iterators, then write the loop as
+  // a for loop with an explicit count.
+
+  template<bool, bool, typename>
+    struct __copy_move
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+	  for (; __first != __last; ++__result, ++__first)
+	    *__result = *__first;
+	  return __result;
+	}
+    };
+
+#if __cplusplus >= 201103L
+  template<typename _Category>
+    struct __copy_move<true, false, _Category>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+	  for (; __first != __last; ++__result, ++__first)
+	    *__result = std::move(*__first);
+	  return __result;
+	}
+    };
+#endif
+
+  template<>
+    struct __copy_move<false, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        { 
+	  typedef typename iterator_traits<_II>::difference_type _Distance;
+	  for(_Distance __n = __last - __first; __n > 0; --__n)
+	    {
+	      *__result = *__first;
+	      ++__first;
+	      ++__result;
+	    }
+	  return __result;
+	}
+    };
+
+#if __cplusplus >= 201103L
+  template<>
+    struct __copy_move<true, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        { 
+	  typedef typename iterator_traits<_II>::difference_type _Distance;
+	  for(_Distance __n = __last - __first; __n > 0; --__n)
+	    {
+	      *__result = std::move(*__first);
+	      ++__first;
+	      ++__result;
+	    }
+	  return __result;
+	}
+    };
+#endif
+
+  template<bool _IsMove>
+    struct __copy_move<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+#if __cplusplus >= 201103L
+	  // trivial types can have deleted assignment
+	  static_assert( is_copy_assignable<_Tp>::value,
+	                 "type is not assignable" );
+#endif
+	  const ptrdiff_t _Num = __last - __first;
+	  if (_Num)
+	    __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
+	  return __result + _Num;
+	}
+    };
+
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a(_II __first, _II __last, _OI __result)
+    {
+      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
+      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
+      typedef typename iterator_traits<_II>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueTypeI)
+	                     && __is_pointer<_II>::__value
+	                     && __is_pointer<_OI>::__value
+			     && __are_same<_ValueTypeI, _ValueTypeO>::__value);
+
+      return std::__copy_move<_IsMove, __simple,
+	                      _Category>::__copy_m(__first, __last, __result);
+    }
+
+  // Helpers for streambuf iterators (either istream or ostream).
+  // NB: avoid including <iosfwd>, relatively large.
+  template<typename _CharT>
+    struct char_traits;
+
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator;
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, 
+	     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(_CharT*, _CharT*,
+		   ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, 
+	     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(const _CharT*, const _CharT*,
+		   ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+				    _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
+		   istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
+
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a2(_II __first, _II __last, _OI __result)
+    {
+      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
+					     std::__niter_base(__last),
+					     std::__niter_base(__result)));
+    }
+
+  /**
+   *  @brief Copies the range [first,last) into result.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __result An output iterator.
+   *  @return   result + (first - last)
+   *
+   *  This inline function will boil down to a call to @c memmove whenever
+   *  possible.  Failing that, if random access iterators are passed, then the
+   *  loop count will be known (and therefore a candidate for compiler
+   *  optimizations such as unrolling).  Result may not be contained within
+   *  [first,last); the copy_backward function should be used instead.
+   *
+   *  Note that the end of the output range is permitted to be contained
+   *  within [first,last).
+  */
+  template<typename _II, typename _OI>
+    inline _OI
+    copy(_II __first, _II __last, _OI __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_II>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OI,
+	    typename iterator_traits<_II>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
+	      (std::__miter_base(__first), std::__miter_base(__last),
+	       __result));
+    }
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief Moves the range [first,last) into result.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __result An output iterator.
+   *  @return   result + (first - last)
+   *
+   *  This inline function will boil down to a call to @c memmove whenever
+   *  possible.  Failing that, if random access iterators are passed, then the
+   *  loop count will be known (and therefore a candidate for compiler
+   *  optimizations such as unrolling).  Result may not be contained within
+   *  [first,last); the move_backward function should be used instead.
+   *
+   *  Note that the end of the output range is permitted to be contained
+   *  within [first,last).
+  */
+  template<typename _II, typename _OI>
+    inline _OI
+    move(_II __first, _II __last, _OI __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_II>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OI,
+	    typename iterator_traits<_II>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__copy_move_a2<true>(std::__miter_base(__first),
+				       std::__miter_base(__last), __result);
+    }
+
+#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::move(_Tp, _Up, _Vp)
+#else
+#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::copy(_Tp, _Up, _Vp)
+#endif
+
+  template<bool, bool, typename>
+    struct __copy_move_backward
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+	  while (__first != __last)
+	    *--__result = *--__last;
+	  return __result;
+	}
+    };
+
+#if __cplusplus >= 201103L
+  template<typename _Category>
+    struct __copy_move_backward<true, false, _Category>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+	  while (__first != __last)
+	    *--__result = std::move(*--__last);
+	  return __result;
+	}
+    };
+#endif
+
+  template<>
+    struct __copy_move_backward<false, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+	  typename iterator_traits<_BI1>::difference_type __n;
+	  for (__n = __last - __first; __n > 0; --__n)
+	    *--__result = *--__last;
+	  return __result;
+	}
+    };
+
+#if __cplusplus >= 201103L
+  template<>
+    struct __copy_move_backward<true, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+	  typename iterator_traits<_BI1>::difference_type __n;
+	  for (__n = __last - __first; __n > 0; --__n)
+	    *--__result = std::move(*--__last);
+	  return __result;
+	}
+    };
+#endif
+
+  template<bool _IsMove>
+    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+#if __cplusplus >= 201103L
+	  // trivial types can have deleted assignment
+	  static_assert( is_copy_assignable<_Tp>::value,
+	                 "type is not assignable" );
+#endif
+	  const ptrdiff_t _Num = __last - __first;
+	  if (_Num)
+	    __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
+	  return __result - _Num;
+	}
+    };
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
+      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
+      typedef typename iterator_traits<_BI1>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueType1)
+	                     && __is_pointer<_BI1>::__value
+	                     && __is_pointer<_BI2>::__value
+			     && __are_same<_ValueType1, _ValueType2>::__value);
+
+      return std::__copy_move_backward<_IsMove, __simple,
+	                               _Category>::__copy_move_b(__first,
+								 __last,
+								 __result);
+    }
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      return _BI2(std::__copy_move_backward_a<_IsMove>
+		  (std::__niter_base(__first), std::__niter_base(__last),
+		   std::__niter_base(__result)));
+    }
+
+  /**
+   *  @brief Copies the range [first,last) into result.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A bidirectional iterator.
+   *  @param  __last   A bidirectional iterator.
+   *  @param  __result A bidirectional iterator.
+   *  @return   result - (first - last)
+   *
+   *  The function has the same effect as copy, but starts at the end of the
+   *  range and works its way to the start, returning the start of the result.
+   *  This inline function will boil down to a call to @c memmove whenever
+   *  possible.  Failing that, if random access iterators are passed, then the
+   *  loop count will be known (and therefore a candidate for compiler
+   *  optimizations such as unrolling).
+   *
+   *  Result may not be in the range (first,last].  Use copy instead.  Note
+   *  that the start of the output range may overlap [first,last).
+  */
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)
+      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)
+      __glibcxx_function_requires(_ConvertibleConcept<
+	    typename iterator_traits<_BI1>::value_type,
+	    typename iterator_traits<_BI2>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
+	      (std::__miter_base(__first), std::__miter_base(__last),
+	       __result));
+    }
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief Moves the range [first,last) into result.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A bidirectional iterator.
+   *  @param  __last   A bidirectional iterator.
+   *  @param  __result A bidirectional iterator.
+   *  @return   result - (first - last)
+   *
+   *  The function has the same effect as move, but starts at the end of the
+   *  range and works its way to the start, returning the start of the result.
+   *  This inline function will boil down to a call to @c memmove whenever
+   *  possible.  Failing that, if random access iterators are passed, then the
+   *  loop count will be known (and therefore a candidate for compiler
+   *  optimizations such as unrolling).
+   *
+   *  Result may not be in the range (first,last].  Use move instead.  Note
+   *  that the start of the output range may overlap [first,last).
+  */
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)
+      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)
+      __glibcxx_function_requires(_ConvertibleConcept<
+	    typename iterator_traits<_BI1>::value_type,
+	    typename iterator_traits<_BI2>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
+						std::__miter_base(__last),
+						__result);
+    }
+
+#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::move_backward(_Tp, _Up, _Vp)
+#else
+#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::copy_backward(_Tp, _Up, _Vp)
+#endif
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+ 	     const _Tp& __value)
+    {
+      for (; __first != __last; ++__first)
+	*__first = __value;
+    }
+    
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+	     const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __first != __last; ++__first)
+	*__first = __tmp;
+    }
+
+  // Specialization: for char types we can use memset.
+  template<typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
+    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
+    {
+      const _Tp __tmp = __c;
+      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
+		       __last - __first);
+    }
+
+  /**
+   *  @brief Fills the range [first,last) with copies of value.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  A forward iterator.
+   *  @param  __last   A forward iterator.
+   *  @param  __value  A reference-to-const of arbitrary type.
+   *  @return   Nothing.
+   *
+   *  This function fills a range with copies of the same value.  For char
+   *  types filling contiguous areas of memory, this becomes an inline call
+   *  to @c memset or @c wmemset.
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
+		    __value);
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      for (__decltype(__n + 0) __niter = __n;
+	   __niter > 0; --__niter, ++__first)
+	*__first = __value;
+      return __first;
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (__decltype(__n + 0) __niter = __n;
+	   __niter > 0; --__niter, ++__first)
+	*__first = __tmp;
+      return __first;
+    }
+
+  template<typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
+    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
+    {
+      std::__fill_a(__first, __first + __n, __c);
+      return __first + __n;
+    }
+
+  /**
+   *  @brief Fills the range [first,first+n) with copies of value.
+   *  @ingroup mutating_algorithms
+   *  @param  __first  An output iterator.
+   *  @param  __n      The count of copies to perform.
+   *  @param  __value  A reference-to-const of arbitrary type.
+   *  @return   The iterator at first+n.
+   *
+   *  This function fills a range with copies of the same value.  For char
+   *  types filling contiguous areas of memory, this becomes an inline call
+   *  to @c memset or @ wmemset.
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  DR 865. More algorithms that throw away information
+  */
+  template<typename _OI, typename _Size, typename _Tp>
+    inline _OI
+    fill_n(_OI __first, _Size __n, const _Tp& __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_OutputIteratorConcept<_OI, _Tp>)
+
+      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
+    }
+
+  template<bool _BoolType>
+    struct __equal
+    {
+      template<typename _II1, typename _II2>
+        static bool
+        equal(_II1 __first1, _II1 __last1, _II2 __first2)
+        {
+	  for (; __first1 != __last1; ++__first1, ++__first2)
+	    if (!(*__first1 == *__first2))
+	      return false;
+	  return true;
+	}
+    };
+
+  template<>
+    struct __equal<true>
+    {
+      template<typename _Tp>
+        static bool
+        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
+        {
+	  return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
+				   * (__last1 - __first1));
+	}
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple = ((__is_integer<_ValueType1>::__value
+			      || __is_pointer<_ValueType1>::__value)
+	                     && __is_pointer<_II1>::__value
+	                     && __is_pointer<_II2>::__value
+			     && __are_same<_ValueType1, _ValueType2>::__value);
+
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+
+  template<typename, typename>
+    struct __lc_rai
+    {
+      template<typename _II1, typename _II2>
+        static _II1
+        __newlast1(_II1, _II1 __last1, _II2, _II2)
+        { return __last1; }
+
+      template<typename _II>
+        static bool
+        __cnd2(_II __first, _II __last)
+        { return __first != __last; }
+    };
+
+  template<>
+    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
+    {
+      template<typename _RAI1, typename _RAI2>
+        static _RAI1
+        __newlast1(_RAI1 __first1, _RAI1 __last1,
+		   _RAI2 __first2, _RAI2 __last2)
+        {
+	  const typename iterator_traits<_RAI1>::difference_type
+	    __diff1 = __last1 - __first1;
+	  const typename iterator_traits<_RAI2>::difference_type
+	    __diff2 = __last2 - __first2;
+	  return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
+	}
+
+      template<typename _RAI>
+        static bool
+        __cnd2(_RAI, _RAI)
+        { return true; }
+    };
+
+  template<typename _II1, typename _II2, typename _Compare>
+    bool
+    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
+				   _II2 __first2, _II2 __last2,
+				   _Compare __comp)
+    {
+      typedef typename iterator_traits<_II1>::iterator_category _Category1;
+      typedef typename iterator_traits<_II2>::iterator_category _Category2;
+      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+
+      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
+      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+	   ++__first1, ++__first2)
+	{
+	  if (__comp(__first1, __first2))
+	    return true;
+	  if (__comp(__first2, __first1))
+	    return false;
+	}
+      return __first1 == __last1 && __first2 != __last2;
+    }
+
+  template<bool _BoolType>
+    struct __lexicographical_compare
+    {
+      template<typename _II1, typename _II2>
+        static bool __lc(_II1, _II1, _II2, _II2);
+    };
+
+  template<bool _BoolType>
+    template<typename _II1, typename _II2>
+      bool
+      __lexicographical_compare<_BoolType>::
+      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+      {
+	return std::__lexicographical_compare_impl(__first1, __last1,
+						   __first2, __last2,
+					__gnu_cxx::__ops::__iter_less_iter());
+      }
+
+  template<>
+    struct __lexicographical_compare<true>
+    {
+      template<typename _Tp, typename _Up>
+        static bool
+        __lc(const _Tp* __first1, const _Tp* __last1,
+	     const _Up* __first2, const _Up* __last2)
+	{
+	  const size_t __len1 = __last1 - __first1;
+	  const size_t __len2 = __last2 - __first2;
+	  const int __result = __builtin_memcmp(__first1, __first2,
+						std::min(__len1, __len2));
+	  return __result != 0 ? __result < 0 : __len1 < __len2;
+	}
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
+				  _II2 __first2, _II2 __last2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple =
+	(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
+	 && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
+	 && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
+	 && __is_pointer<_II1>::__value
+	 && __is_pointer<_II2>::__value);
+
+      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
+							    __first2, __last2);
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+		  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+	{
+	  _DistanceType __half = __len >> 1;
+	  _ForwardIterator __middle = __first;
+	  std::advance(__middle, __half);
+	  if (__comp(__middle, __val))
+	    {
+	      __first = __middle;
+	      ++__first;
+	      __len = __len - __half - 1;
+	    }
+	  else
+	    __len = __half;
+	}
+      return __first;
+    }
+
+  /**
+   *  @brief Finds the first position in which @a val could be inserted
+   *         without changing the ordering.
+   *  @param  __first   An iterator.
+   *  @param  __last    Another iterator.
+   *  @param  __val     The search term.
+   *  @return         An iterator pointing to the first element <em>not less
+   *                  than</em> @a val, or end() if every element is less than 
+   *                  @a val.
+   *  @ingroup binary_search_algorithms
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanOpConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
+      __glibcxx_requires_partitioned_lower(__first, __last, __val);
+
+      return std::__lower_bound(__first, __last, __val,
+				__gnu_cxx::__ops::__iter_less_val());
+    }
+
+  /// This is a helper function for the sort routines and for random.tcc.
+  //  Precondition: __n > 0.
+  inline _GLIBCXX_CONSTEXPR int
+  __lg(int __n)
+  { return sizeof(int) * __CHAR_BIT__  - 1 - __builtin_clz(__n); }
+
+  inline _GLIBCXX_CONSTEXPR unsigned
+  __lg(unsigned __n)
+  { return sizeof(int) * __CHAR_BIT__  - 1 - __builtin_clz(__n); }
+
+  inline _GLIBCXX_CONSTEXPR long
+  __lg(long __n)
+  { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); }
+
+  inline _GLIBCXX_CONSTEXPR unsigned long
+  __lg(unsigned long __n)
+  { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); }
+
+  inline _GLIBCXX_CONSTEXPR long long
+  __lg(long long __n)
+  { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }
+
+  inline _GLIBCXX_CONSTEXPR unsigned long long
+  __lg(unsigned long long __n)
+  { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
+
+  /**
+   *  @brief Tests a range for element-wise equality.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @return   A boolean true or false.
+   *
+   *  This compares the elements of two ranges using @c == and returns true or
+   *  false depending on whether all of the corresponding elements of the
+   *  ranges are equal.
+  */
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_II1>::value_type,
+	    typename iterator_traits<_II2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      return std::__equal_aux(std::__niter_base(__first1),
+			      std::__niter_base(__last1),
+			      std::__niter_base(__first2));
+    }
+
+  /**
+   *  @brief Tests a range for element-wise equality.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param __binary_pred A binary predicate @link functors
+   *                  functor@endlink.
+   *  @return         A boolean true or false.
+   *
+   *  This compares the elements of two ranges using the binary_pred
+   *  parameter, and returns true or
+   *  false depending on whether all of the corresponding elements of the
+   *  ranges are equal.
+  */
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+	  _IIter2 __first2, _BinaryPredicate __binary_pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_IIter1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_IIter2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+	if (!bool(__binary_pred(*__first1, *__first2)))
+	  return false;
+      return true;
+    }
+
+#if __cplusplus > 201103L
+  /**
+   *  @brief Tests a range for element-wise equality.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param  __last2   An input iterator.
+   *  @return   A boolean true or false.
+   *
+   *  This compares the elements of two ranges using @c == and returns true or
+   *  false depending on whether all of the corresponding elements of the
+   *  ranges are equal.
+  */
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_II1>::value_type,
+	    typename iterator_traits<_II2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+	{
+	  auto __d1 = std::distance(__first1, __last1);
+	  auto __d2 = std::distance(__first2, __last2);
+	  if (__d1 != __d2)
+	    return false;
+	  return _GLIBCXX_STD_A::equal(__first1, __last1, __first2);
+	}
+
+      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+	if (!(*__first1 == *__first2))
+	  return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+
+  /**
+   *  @brief Tests a range for element-wise equality.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param  __last2   An input iterator.
+   *  @param __binary_pred A binary predicate @link functors
+   *                  functor@endlink.
+   *  @return         A boolean true or false.
+   *
+   *  This compares the elements of two ranges using the binary_pred
+   *  parameter, and returns true or
+   *  false depending on whether all of the corresponding elements of the
+   *  ranges are equal.
+  */
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+	  _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_IIter1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_IIter2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_IIter1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_IIter2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+	{
+	  auto __d1 = std::distance(__first1, __last1);
+	  auto __d2 = std::distance(__first2, __last2);
+	  if (__d1 != __d2)
+	    return false;
+	  return _GLIBCXX_STD_A::equal(__first1, __last1, __first2,
+				       __binary_pred);
+	}
+
+      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+	if (!bool(__binary_pred(*__first1, *__first2)))
+	  return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+#endif
+
+  /**
+   *  @brief Performs @b dictionary comparison on ranges.
+   *  @ingroup sorting_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param  __last2   An input iterator.
+   *  @return   A boolean true or false.
+   *
+   *  <em>Returns true if the sequence of elements defined by the range
+   *  [first1,last1) is lexicographically less than the sequence of elements
+   *  defined by the range [first2,last2).  Returns false otherwise.</em>
+   *  (Quoted from [25.3.8]/1.)  If the iterators are all character pointers,
+   *  then this is an inline call to @c memcmp.
+  */
+  template<typename _II1, typename _II2>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+			    _II2 __first2, _II2 __last2)
+    {
+#ifdef _GLIBCXX_CONCEPT_CHECKS
+      // concept requirements
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+#endif
+      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
+      __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
+      __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
+						std::__niter_base(__last1),
+						std::__niter_base(__first2),
+						std::__niter_base(__last2));
+    }
+
+  /**
+   *  @brief Performs @b dictionary comparison on ranges.
+   *  @ingroup sorting_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param  __last2   An input iterator.
+   *  @param  __comp  A @link comparison_functors comparison functor@endlink.
+   *  @return   A boolean true or false.
+   *
+   *  The same as the four-parameter @c lexicographical_compare, but uses the
+   *  comp parameter instead of @c <.
+  */
+  template<typename _II1, typename _II2, typename _Compare>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+			    _II2 __first2, _II2 __last2, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return std::__lexicographical_compare_impl
+	(__first1, __last1, __first2, __last2,
+	 __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	       _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __binary_pred(__first1, __first2))
+        {
+	  ++__first1;
+	  ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+
+  /**
+   *  @brief Finds the places in ranges which don't match.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @return   A pair of iterators pointing to the first mismatch.
+   *
+   *  This compares the elements of two ranges using @c == and returns a pair
+   *  of iterators.  The first iterator points into the first range, the
+   *  second iterator points into the second range, and the elements pointed
+   *  to by the iterators are not equal.
+  */
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
+			     __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief Finds the places in ranges which don't match.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param __binary_pred A binary predicate @link functors
+   *         functor@endlink.
+   *  @return   A pair of iterators pointing to the first mismatch.
+   *
+   *  This compares the elements of two ranges using the binary_pred
+   *  parameter, and returns a pair
+   *  of iterators.  The first iterator points into the first range, the
+   *  second iterator points into the second range, and the elements pointed
+   *  to by the iterators are not equal.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
+	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+#if __cplusplus > 201103L
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	       _InputIterator2 __first2, _InputIterator2 __last2,
+	       _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __first2 != __last2
+	     && __binary_pred(__first1, __first2))
+        {
+	  ++__first1;
+	  ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+
+  /**
+   *  @brief Finds the places in ranges which don't match.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param  __last2   An input iterator.
+   *  @return   A pair of iterators pointing to the first mismatch.
+   *
+   *  This compares the elements of two ranges using @c == and returns a pair
+   *  of iterators.  The first iterator points into the first range, the
+   *  second iterator points into the second range, and the elements pointed
+   *  to by the iterators are not equal.
+  */
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_EqualOpConcept<
+	    typename iterator_traits<_InputIterator1>::value_type,
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,
+			     __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+  /**
+   *  @brief Finds the places in ranges which don't match.
+   *  @ingroup non_mutating_algorithms
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param  __last2   An input iterator.
+   *  @param __binary_pred A binary predicate @link functors
+   *         functor@endlink.
+   *  @return   A pair of iterators pointing to the first mismatch.
+   *
+   *  This compares the elements of two ranges using the binary_pred
+   *  parameter, and returns a pair
+   *  of iterators.  The first iterator points into the first range, the
+   *  second iterator points into the second range, and the elements pointed
+   *  to by the iterators are not equal.
+  */
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2,
+	     _BinaryPredicate __binary_pred)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,
+			     __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+#endif
+
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
+
+// NB: This file is included within many other C++ includes, as a way
+// of getting the base algorithms. So, make sure that parallel bits
+// come in too if requested. 
+#ifdef _GLIBCXX_PARALLEL
+# include <parallel/algobase.h>
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_bvector.h b/gcc-4.9/libstdc++-v3/include/bits/stl_bvector.h
new file mode 100644
index 0000000..996eb1a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_bvector.h
@@ -0,0 +1,1202 @@
+// vector<bool> specialization -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_bvector.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{vector}
+ */
+
+#ifndef _STL_BVECTOR_H
+#define _STL_BVECTOR_H 1
+
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  typedef unsigned long _Bit_type;
+  enum { _S_word_bit = int(__CHAR_BIT__ * sizeof(_Bit_type)) };
+
+  struct _Bit_reference
+  {
+    _Bit_type * _M_p;
+    _Bit_type _M_mask;
+
+    _Bit_reference(_Bit_type * __x, _Bit_type __y)
+    : _M_p(__x), _M_mask(__y) { }
+
+    _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
+
+    operator bool() const _GLIBCXX_NOEXCEPT
+    { return !!(*_M_p & _M_mask); }
+
+    _Bit_reference&
+    operator=(bool __x) _GLIBCXX_NOEXCEPT
+    {
+      if (__x)
+	*_M_p |= _M_mask;
+      else
+	*_M_p &= ~_M_mask;
+      return *this;
+    }
+
+    _Bit_reference&
+    operator=(const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
+    { return *this = bool(__x); }
+
+    bool
+    operator==(const _Bit_reference& __x) const
+    { return bool(*this) == bool(__x); }
+
+    bool
+    operator<(const _Bit_reference& __x) const
+    { return !bool(*this) && bool(__x); }
+
+    void
+    flip() _GLIBCXX_NOEXCEPT
+    { *_M_p ^= _M_mask; }
+  };
+
+#if __cplusplus >= 201103L
+  inline void
+  swap(_Bit_reference __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(_Bit_reference __x, bool& __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(bool& __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+#endif
+
+  struct _Bit_iterator_base
+  : public std::iterator<std::random_access_iterator_tag, bool>
+  {
+    _Bit_type * _M_p;
+    unsigned int _M_offset;
+
+    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
+    : _M_p(__x), _M_offset(__y) { }
+
+    void
+    _M_bump_up()
+    {
+      if (_M_offset++ == int(_S_word_bit) - 1)
+	{
+	  _M_offset = 0;
+	  ++_M_p;
+	}
+    }
+
+    void
+    _M_bump_down()
+    {
+      if (_M_offset-- == 0)
+	{
+	  _M_offset = int(_S_word_bit) - 1;
+	  --_M_p;
+	}
+    }
+
+    void
+    _M_incr(ptrdiff_t __i)
+    {
+      difference_type __n = __i + _M_offset;
+      _M_p += __n / int(_S_word_bit);
+      __n = __n % int(_S_word_bit);
+      if (__n < 0)
+	{
+	  __n += int(_S_word_bit);
+	  --_M_p;
+	}
+      _M_offset = static_cast<unsigned int>(__n);
+    }
+
+    bool
+    operator==(const _Bit_iterator_base& __i) const
+    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
+
+    bool
+    operator<(const _Bit_iterator_base& __i) const
+    {
+      return _M_p < __i._M_p
+	     || (_M_p == __i._M_p && _M_offset < __i._M_offset);
+    }
+
+    bool
+    operator!=(const _Bit_iterator_base& __i) const
+    { return !(*this == __i); }
+
+    bool
+    operator>(const _Bit_iterator_base& __i) const
+    { return __i < *this; }
+
+    bool
+    operator<=(const _Bit_iterator_base& __i) const
+    { return !(__i < *this); }
+
+    bool
+    operator>=(const _Bit_iterator_base& __i) const
+    { return !(*this < __i); }
+  };
+
+  inline ptrdiff_t
+  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+  {
+    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+	    + __x._M_offset - __y._M_offset);
+  }
+
+  struct _Bit_iterator : public _Bit_iterator_base
+  {
+    typedef _Bit_reference  reference;
+    typedef _Bit_reference* pointer;
+    typedef _Bit_iterator   iterator;
+
+    _Bit_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    iterator
+    _M_const_cast() const
+    { return *this; }
+
+    reference
+    operator*() const
+    { return reference(_M_p, 1UL << _M_offset); }
+
+    iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    iterator
+    operator++(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    iterator
+    operator--(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    iterator
+    operator+(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp += __i;
+    }
+
+    iterator
+    operator-(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+
+    reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+
+  inline _Bit_iterator
+  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
+  { return __x + __n; }
+
+  struct _Bit_const_iterator : public _Bit_iterator_base
+  {
+    typedef bool                 reference;
+    typedef bool                 const_reference;
+    typedef const bool*          pointer;
+    typedef _Bit_const_iterator  const_iterator;
+
+    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    _Bit_const_iterator(const _Bit_iterator& __x)
+    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
+
+    _Bit_iterator
+    _M_const_cast() const
+    { return _Bit_iterator(_M_p, _M_offset); }
+
+    const_reference
+    operator*() const
+    { return _Bit_reference(_M_p, 1UL << _M_offset); }
+
+    const_iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    const_iterator
+    operator++(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    const_iterator
+    operator--(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    const_iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    const_iterator 
+    operator+(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp += __i;
+    }
+
+    const_iterator
+    operator-(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+
+    const_reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+
+  inline _Bit_const_iterator
+  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
+  { return __x + __n; }
+
+  inline void
+  __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
+  {
+    for (; __first != __last; ++__first)
+      *__first = __x;
+  }
+
+  inline void
+  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
+  {
+    if (__first._M_p != __last._M_p)
+      {
+	std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
+	__fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
+	__fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
+      }
+    else
+      __fill_bvector(__first, __last, __x);
+  }
+
+  template<typename _Alloc>
+    struct _Bvector_base
+    {
+      typedef typename _Alloc::template rebind<_Bit_type>::other
+        _Bit_alloc_type;
+      
+      struct _Bvector_impl
+      : public _Bit_alloc_type
+      {
+	_Bit_iterator 	_M_start;
+	_Bit_iterator 	_M_finish;
+	_Bit_type* 	_M_end_of_storage;
+
+	_Bvector_impl()
+	: _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
+	{ }
+ 
+	_Bvector_impl(const _Bit_alloc_type& __a)
+	: _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
+	{ }
+
+#if __cplusplus >= 201103L
+	_Bvector_impl(_Bit_alloc_type&& __a)
+	: _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
+	  _M_end_of_storage(0)
+	{ }
+#endif
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Bit_alloc_type&
+      _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
+      { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
+
+      const _Bit_alloc_type&
+      _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
+      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_get_Bit_allocator()); }
+
+      _Bvector_base()
+      : _M_impl() { }
+      
+      _Bvector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+
+#if __cplusplus >= 201103L
+      _Bvector_base(_Bvector_base&& __x) noexcept
+      : _M_impl(std::move(__x._M_get_Bit_allocator()))
+      {
+	this->_M_impl._M_start = __x._M_impl._M_start;
+	this->_M_impl._M_finish = __x._M_impl._M_finish;
+	this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
+	__x._M_impl._M_start = _Bit_iterator();
+	__x._M_impl._M_finish = _Bit_iterator();
+	__x._M_impl._M_end_of_storage = 0;
+      }
+#endif
+
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
+
+    protected:
+      _Bvector_impl _M_impl;
+
+      _Bit_type*
+      _M_allocate(size_t __n)
+      { return _M_impl.allocate(_S_nword(__n)); }
+
+      void
+      _M_deallocate()
+      {
+	if (_M_impl._M_start._M_p)
+	  _M_impl.deallocate(_M_impl._M_start._M_p,
+			     _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
+      }
+
+      static size_t
+      _S_nword(size_t __n)
+      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
+    };
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+// Declare a partial specialization of vector<T, Alloc>.
+#include <bits/stl_vector.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  @brief  A specialization of vector for booleans which offers fixed time
+   *  access to individual elements in any order.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Alloc  Allocator type.
+   *
+   *  Note that vector<bool> does not actually meet the requirements for being
+   *  a container.  This is because the reference and pointer types are not
+   *  really references and pointers to bool.  See DR96 for details.  @see
+   *  vector for function documentation.
+   *
+   *  In some terminology a %vector can be described as a dynamic
+   *  C-style array, it offers fast and efficient access to individual
+   *  elements in any order and saves the user from worrying about
+   *  memory and size allocation.  Subscripting ( @c [] ) access is
+   *  also provided as with C-style arrays.
+  */
+template<typename _Alloc>
+  class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
+  {
+    typedef _Bvector_base<_Alloc>			 _Base;
+
+#if __cplusplus >= 201103L
+    template<typename> friend struct hash;
+#endif
+
+  public:
+    typedef bool                                         value_type;
+    typedef size_t                                       size_type;
+    typedef ptrdiff_t                                    difference_type;
+    typedef _Bit_reference                               reference;
+    typedef bool                                         const_reference;
+    typedef _Bit_reference*                              pointer;
+    typedef const bool*                                  const_pointer;
+    typedef _Bit_iterator                                iterator;
+    typedef _Bit_const_iterator                          const_iterator;
+    typedef std::reverse_iterator<const_iterator>        const_reverse_iterator;
+    typedef std::reverse_iterator<iterator>              reverse_iterator;
+    typedef _Alloc                        		 allocator_type;
+
+    allocator_type get_allocator() const
+    { return _Base::get_allocator(); }
+
+  protected:
+    using _Base::_M_allocate;
+    using _Base::_M_deallocate;
+    using _Base::_S_nword;
+    using _Base::_M_get_Bit_allocator;
+
+  public:
+    vector()
+    : _Base() { }
+
+    explicit
+    vector(const allocator_type& __a)
+    : _Base(__a) { }
+
+#if __cplusplus >= 201103L
+    explicit
+    vector(size_type __n, const allocator_type& __a = allocator_type())
+    : vector(__n, false, __a)
+    { }
+
+    vector(size_type __n, const bool& __value, 
+	   const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    {
+      _M_initialize(__n);
+      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, 
+		__value ? ~0 : 0);
+    }
+#else
+    explicit
+    vector(size_type __n, const bool& __value = bool(), 
+	   const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    {
+      _M_initialize(__n);
+      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, 
+		__value ? ~0 : 0);
+    }
+#endif
+
+    vector(const vector& __x)
+    : _Base(__x._M_get_Bit_allocator())
+    {
+      _M_initialize(__x.size());
+      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+    }
+
+#if __cplusplus >= 201103L
+    vector(vector&& __x) noexcept
+    : _Base(std::move(__x)) { }
+
+    vector(initializer_list<bool> __l,
+	   const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    {
+      _M_initialize_range(__l.begin(), __l.end(),
+			  random_access_iterator_tag());
+    }
+#endif
+
+#if __cplusplus >= 201103L
+    template<typename _InputIterator,
+	     typename = std::_RequireInputIter<_InputIterator>>
+      vector(_InputIterator __first, _InputIterator __last,
+	     const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      { _M_initialize_dispatch(__first, __last, __false_type()); }
+#else
+    template<typename _InputIterator>
+      vector(_InputIterator __first, _InputIterator __last,
+	     const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	_M_initialize_dispatch(__first, __last, _Integral());
+      }
+#endif
+
+    ~vector() _GLIBCXX_NOEXCEPT { }
+
+    vector&
+    operator=(const vector& __x)
+    {
+      if (&__x == this)
+	return *this;
+      if (__x.size() > capacity())
+	{
+	  this->_M_deallocate();
+	  _M_initialize(__x.size());
+	}
+      this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+						begin());
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+    vector&
+    operator=(vector&& __x)
+    {
+      // NB: DR 1204.
+      // NB: DR 675.
+      this->clear();
+      this->swap(__x); 
+      return *this;
+    }
+
+    vector&
+    operator=(initializer_list<bool> __l)
+    {
+      this->assign (__l.begin(), __l.end());
+      return *this;
+    }
+#endif
+
+    // assign(), a generalized assignment member function.  Two
+    // versions: one that takes a count, and one that takes a range.
+    // The range version is a member template, so we dispatch on whether
+    // or not the type is an integer.
+    void
+    assign(size_type __n, const bool& __x)
+    { _M_fill_assign(__n, __x); }
+
+#if __cplusplus >= 201103L
+    template<typename _InputIterator,
+	     typename = std::_RequireInputIter<_InputIterator>>
+      void
+      assign(_InputIterator __first, _InputIterator __last)
+      { _M_assign_dispatch(__first, __last, __false_type()); }
+#else
+    template<typename _InputIterator>
+      void
+      assign(_InputIterator __first, _InputIterator __last)
+      {
+	typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	_M_assign_dispatch(__first, __last, _Integral());
+      }
+#endif
+
+#if __cplusplus >= 201103L
+    void
+    assign(initializer_list<bool> __l)
+    { this->assign(__l.begin(), __l.end()); }
+#endif
+
+    iterator
+    begin() _GLIBCXX_NOEXCEPT
+    { return this->_M_impl._M_start; }
+
+    const_iterator
+    begin() const _GLIBCXX_NOEXCEPT
+    { return this->_M_impl._M_start; }
+
+    iterator
+    end() _GLIBCXX_NOEXCEPT
+    { return this->_M_impl._M_finish; }
+
+    const_iterator
+    end() const _GLIBCXX_NOEXCEPT
+    { return this->_M_impl._M_finish; }
+
+    reverse_iterator
+    rbegin() _GLIBCXX_NOEXCEPT
+    { return reverse_iterator(end()); }
+
+    const_reverse_iterator
+    rbegin() const _GLIBCXX_NOEXCEPT
+    { return const_reverse_iterator(end()); }
+
+    reverse_iterator
+    rend() _GLIBCXX_NOEXCEPT
+    { return reverse_iterator(begin()); }
+
+    const_reverse_iterator
+    rend() const _GLIBCXX_NOEXCEPT
+    { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+    const_iterator
+    cbegin() const noexcept
+    { return this->_M_impl._M_start; }
+
+    const_iterator
+    cend() const noexcept
+    { return this->_M_impl._M_finish; }
+
+    const_reverse_iterator
+    crbegin() const noexcept
+    { return const_reverse_iterator(end()); }
+
+    const_reverse_iterator
+    crend() const noexcept
+    { return const_reverse_iterator(begin()); }
+#endif
+
+    size_type
+    size() const _GLIBCXX_NOEXCEPT
+    { return size_type(end() - begin()); }
+
+    size_type
+    max_size() const _GLIBCXX_NOEXCEPT
+    {
+      const size_type __isize =
+	__gnu_cxx::__numeric_traits<difference_type>::__max
+	- int(_S_word_bit) + 1;
+      const size_type __asize = _M_get_Bit_allocator().max_size();
+      return (__asize <= __isize / int(_S_word_bit)
+	      ? __asize * int(_S_word_bit) : __isize);
+    }
+
+    size_type
+    capacity() const _GLIBCXX_NOEXCEPT
+    { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
+		       - begin()); }
+
+    bool
+    empty() const _GLIBCXX_NOEXCEPT
+    { return begin() == end(); }
+
+    reference
+    operator[](size_type __n)
+    {
+      return *iterator(this->_M_impl._M_start._M_p
+		       + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+
+    const_reference
+    operator[](size_type __n) const
+    {
+      return *const_iterator(this->_M_impl._M_start._M_p
+			     + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+
+  protected:
+    void
+    _M_range_check(size_type __n) const
+    {
+      if (__n >= this->size())
+	__throw_out_of_range_fmt(__N("vector<bool>::_M_range_check: __n "
+				     "(which is %zu) >= this->size() "
+				     "(which is %zu)"),
+				 __n, this->size());
+    }
+
+  public:
+    reference
+    at(size_type __n)
+    { _M_range_check(__n); return (*this)[__n]; }
+
+    const_reference
+    at(size_type __n) const
+    { _M_range_check(__n); return (*this)[__n]; }
+
+    void
+    reserve(size_type __n)
+    {
+      if (__n > max_size())
+	__throw_length_error(__N("vector::reserve"));
+      if (capacity() < __n)
+	_M_reallocate(__n);
+    }
+
+    reference
+    front()
+    { return *begin(); }
+
+    const_reference
+    front() const
+    { return *begin(); }
+
+    reference
+    back()
+    { return *(end() - 1); }
+
+    const_reference
+    back() const
+    { return *(end() - 1); }
+
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // DR 464. Suggestion for new member functions in standard containers.
+    // N.B. DR 464 says nothing about vector<bool> but we need something
+    // here due to the way we are implementing DR 464 in the debug-mode
+    // vector class.
+    void
+    data() _GLIBCXX_NOEXCEPT { }
+
+    void
+    push_back(bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(end(), __x);
+    }
+
+    void
+    swap(vector& __x)
+    {
+      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+      std::swap(this->_M_impl._M_end_of_storage, 
+		__x._M_impl._M_end_of_storage);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 431. Swapping containers with unequal allocators.
+      std::__alloc_swap<typename _Base::_Bit_alloc_type>::
+	_S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
+    }
+
+    // [23.2.5]/1, third-to-last entry in synopsis listing
+    static void
+    swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT
+    {
+      bool __tmp = __x;
+      __x = __y;
+      __y = __tmp;
+    }
+
+    iterator
+#if __cplusplus >= 201103L
+    insert(const_iterator __position, const bool& __x = bool())
+#else
+    insert(iterator __position, const bool& __x = bool())
+#endif
+    {
+      const difference_type __n = __position - begin();
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
+	  && __position == end())
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(__position._M_const_cast(), __x);
+      return begin() + __n;
+    }
+
+#if __cplusplus >= 201103L
+    template<typename _InputIterator,
+	     typename = std::_RequireInputIter<_InputIterator>>
+      iterator
+      insert(const_iterator __position,
+	     _InputIterator __first, _InputIterator __last)
+      {
+	difference_type __offset = __position - cbegin();
+	_M_insert_dispatch(__position._M_const_cast(),
+			   __first, __last, __false_type());
+	return begin() + __offset;
+      }
+#else
+    template<typename _InputIterator>
+      void
+      insert(iterator __position,
+	     _InputIterator __first, _InputIterator __last)
+      {
+	typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	_M_insert_dispatch(__position, __first, __last, _Integral());
+      }
+#endif
+
+#if __cplusplus >= 201103L
+    iterator
+    insert(const_iterator __position, size_type __n, const bool& __x)
+    {
+      difference_type __offset = __position - cbegin();
+      _M_fill_insert(__position._M_const_cast(), __n, __x);
+      return begin() + __offset;
+    }
+#else
+    void
+    insert(iterator __position, size_type __n, const bool& __x)
+    { _M_fill_insert(__position, __n, __x); }
+#endif
+
+#if __cplusplus >= 201103L
+    iterator
+    insert(const_iterator __p, initializer_list<bool> __l)
+    { return this->insert(__p, __l.begin(), __l.end()); }
+#endif
+
+    void
+    pop_back()
+    { --this->_M_impl._M_finish; }
+
+    iterator
+#if __cplusplus >= 201103L
+    erase(const_iterator __position)
+#else
+    erase(iterator __position)
+#endif
+    { return _M_erase(__position._M_const_cast()); }
+
+    iterator
+#if __cplusplus >= 201103L
+    erase(const_iterator __first, const_iterator __last)
+#else
+    erase(iterator __first, iterator __last)
+#endif
+    { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+
+    void
+    resize(size_type __new_size, bool __x = bool())
+    {
+      if (__new_size < size())
+        _M_erase_at_end(begin() + difference_type(__new_size));
+      else
+        insert(end(), __new_size - size(), __x);
+    }
+
+#if __cplusplus >= 201103L
+    void
+    shrink_to_fit()
+    { _M_shrink_to_fit(); }
+#endif
+
+    void
+    flip() _GLIBCXX_NOEXCEPT
+    {
+      for (_Bit_type * __p = this->_M_impl._M_start._M_p;
+	   __p != this->_M_impl._M_end_of_storage; ++__p)
+        *__p = ~*__p;
+    }
+
+    void
+    clear() _GLIBCXX_NOEXCEPT
+    { _M_erase_at_end(begin()); }
+
+#if __cplusplus >= 201103L
+    template<typename... _Args>
+      void
+      emplace_back(_Args&&... __args)
+      { push_back(bool(__args...)); }
+
+    template<typename... _Args>
+      iterator
+      emplace(const_iterator __pos, _Args&&... __args)
+      { return insert(__pos, bool(__args...)); }
+#endif
+
+  protected:
+    // Precondition: __first._M_offset == 0 && __result._M_offset == 0.
+    iterator
+    _M_copy_aligned(const_iterator __first, const_iterator __last,
+		    iterator __result)
+    {
+      _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
+      return std::copy(const_iterator(__last._M_p, 0), __last,
+		       iterator(__q, 0));
+    }
+
+    void
+    _M_initialize(size_type __n)
+    {
+      _Bit_type* __q = this->_M_allocate(__n);
+      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+      this->_M_impl._M_start = iterator(__q, 0);
+      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
+    }
+
+    void
+    _M_reallocate(size_type __n);
+
+#if __cplusplus >= 201103L
+    bool
+    _M_shrink_to_fit();
+#endif
+
+    // Check whether it's an integral type.  If so, it's not an iterator.
+
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 438. Ambiguity in the "do the right thing" clause
+    template<typename _Integer>
+      void
+      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+      {
+	_M_initialize(static_cast<size_type>(__n));
+	std::fill(this->_M_impl._M_start._M_p, 
+		  this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+      }
+
+    template<typename _InputIterator>
+      void 
+      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+			     __false_type)
+      { _M_initialize_range(__first, __last, 
+			    std::__iterator_category(__first)); }
+
+    template<typename _InputIterator>
+      void
+      _M_initialize_range(_InputIterator __first, _InputIterator __last,
+			  std::input_iterator_tag)
+      {
+	for (; __first != __last; ++__first)
+	  push_back(*__first);
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+			  std::forward_iterator_tag)
+      {
+	const size_type __n = std::distance(__first, __last);
+	_M_initialize(__n);
+	std::copy(__first, __last, this->_M_impl._M_start);
+      }
+
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 438. Ambiguity in the "do the right thing" clause
+    template<typename _Integer>
+      void
+      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+      { _M_fill_assign(__n, __val); }
+
+    template<class _InputIterator>
+      void
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+			 __false_type)
+      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+
+    void
+    _M_fill_assign(size_t __n, bool __x)
+    {
+      if (__n > size())
+	{
+	  std::fill(this->_M_impl._M_start._M_p, 
+		    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+	  insert(end(), __n - size(), __x);
+	}
+      else
+	{
+	  _M_erase_at_end(begin() + __n);
+	  std::fill(this->_M_impl._M_start._M_p, 
+		    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+	}
+    }
+
+    template<typename _InputIterator>
+      void
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+		    std::input_iterator_tag)
+      {
+	iterator __cur = begin();
+	for (; __first != __last && __cur != end(); ++__cur, ++__first)
+	  *__cur = *__first;
+	if (__first == __last)
+	  _M_erase_at_end(__cur);
+	else
+	  insert(end(), __first, __last);
+      }
+    
+    template<typename _ForwardIterator>
+      void
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+		    std::forward_iterator_tag)
+      {
+	const size_type __len = std::distance(__first, __last);
+	if (__len < size())
+	  _M_erase_at_end(std::copy(__first, __last, begin()));
+	else
+	  {
+	    _ForwardIterator __mid = __first;
+	    std::advance(__mid, size());
+	    std::copy(__first, __mid, begin());
+	    insert(end(), __mid, __last);
+	  }
+      }
+
+    // Check whether it's an integral type.  If so, it's not an iterator.
+
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 438. Ambiguity in the "do the right thing" clause
+    template<typename _Integer>
+      void
+      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+			 __true_type)
+      { _M_fill_insert(__pos, __n, __x); }
+
+    template<typename _InputIterator>
+      void
+      _M_insert_dispatch(iterator __pos,
+			 _InputIterator __first, _InputIterator __last,
+			 __false_type)
+      { _M_insert_range(__pos, __first, __last,
+			std::__iterator_category(__first)); }
+
+    void
+    _M_fill_insert(iterator __position, size_type __n, bool __x);
+
+    template<typename _InputIterator>
+      void
+      _M_insert_range(iterator __pos, _InputIterator __first, 
+		      _InputIterator __last, std::input_iterator_tag)
+      {
+	for (; __first != __last; ++__first)
+	  {
+	    __pos = insert(__pos, *__first);
+	    ++__pos;
+	  }
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_insert_range(iterator __position, _ForwardIterator __first, 
+		      _ForwardIterator __last, std::forward_iterator_tag);
+
+    void
+    _M_insert_aux(iterator __position, bool __x);
+
+    size_type
+    _M_check_len(size_type __n, const char* __s) const
+    {
+      if (max_size() - size() < __n)
+	__throw_length_error(__N(__s));
+
+      const size_type __len = size() + std::max(size(), __n);
+      return (__len < size() || __len > max_size()) ? max_size() : __len;
+    }
+
+    void
+    _M_erase_at_end(iterator __pos)
+    { this->_M_impl._M_finish = __pos; }
+
+    iterator
+    _M_erase(iterator __pos);
+
+    iterator
+    _M_erase(iterator __first, iterator __last);
+  };
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#if __cplusplus >= 201103L
+
+#include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // DR 1182.
+  /// std::hash specialization for vector<bool>.
+  template<typename _Alloc>
+    struct hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>
+    : public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
+    {
+      size_t
+      operator()(const _GLIBCXX_STD_C::vector<bool, _Alloc>&) const noexcept;
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}// namespace std
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_construct.h b/gcc-4.9/libstdc++-v3/include/bits/stl_construct.h
new file mode 100644
index 0000000..df245c7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_construct.h
@@ -0,0 +1,158 @@
+// nonstandard construct and destroy functions -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_construct.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _STL_CONSTRUCT_H
+#define _STL_CONSTRUCT_H 1
+
+#include <new>
+#include <bits/move.h>
+#include <ext/alloc_traits.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * Constructs an object in existing memory by invoking an allocated
+   * object's constructor with an initializer.
+   */
+#if __cplusplus >= 201103L
+  template<typename _T1, typename... _Args>
+    inline void
+    _Construct(_T1* __p, _Args&&... __args)
+    { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
+#else
+  template<typename _T1, typename _T2>
+    inline void
+    _Construct(_T1* __p, const _T2& __value)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 402. wrong new expression in [some_]allocator::construct
+      ::new(static_cast<void*>(__p)) _T1(__value);
+    }
+#endif
+
+  /**
+   * Destroy the object pointed to by a pointer type.
+   */
+  template<typename _Tp>
+    inline void
+    _Destroy(_Tp* __pointer)
+    { __pointer->~_Tp(); }
+
+  template<bool>
+    struct _Destroy_aux
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator __first, _ForwardIterator __last)
+	{
+	  for (; __first != __last; ++__first)
+	    std::_Destroy(std::__addressof(*__first));
+	}
+    };
+
+  template<>
+    struct _Destroy_aux<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator, _ForwardIterator) { }
+    };
+
+  /**
+   * Destroy a range of objects.  If the value_type of the object has
+   * a trivial destructor, the compiler should optimize all of this
+   * away, otherwise the objects' destructors must be invoked.
+   */
+  template<typename _ForwardIterator>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
+	__destroy(__first, __last);
+    }
+
+  /**
+   * Destroy a range of objects using the supplied allocator.  For
+   * nondefault allocators we do not optimize away invocation of 
+   * destroy() even if _Tp has a trivial destructor.
+   */
+
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+	     _Allocator& __alloc)
+    {
+      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+      for (; __first != __last; ++__first)
+	__traits::destroy(__alloc, std::__addressof(*__first));
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+	     allocator<_Tp>&)
+    {
+      _Destroy(__first, __last);
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif /* _STL_CONSTRUCT_H */
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_deque.h b/gcc-4.9/libstdc++-v3/include/bits/stl_deque.h
new file mode 100644
index 0000000..add8742
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_deque.h
@@ -0,0 +1,2091 @@
+// Deque implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_deque.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{deque}
+ */
+
+#ifndef _STL_DEQUE_H
+#define _STL_DEQUE_H 1
+
+#include <bits/concept_check.h>
+#include <bits/stl_iterator_base_types.h>
+#include <bits/stl_iterator_base_funcs.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  @brief This function controls the size of memory nodes.
+   *  @param  __size  The size of an element.
+   *  @return   The number (not byte size) of elements per node.
+   *
+   *  This function started off as a compiler kludge from SGI, but
+   *  seems to be a useful wrapper around a repeated constant
+   *  expression.  The @b 512 is tunable (and no other code needs to
+   *  change), but no investigation has been done since inheriting the
+   *  SGI code.  Touch _GLIBCXX_DEQUE_BUF_SIZE only if you know what
+   *  you are doing, however: changing it breaks the binary
+   *  compatibility!!
+  */
+
+#ifndef _GLIBCXX_DEQUE_BUF_SIZE
+#define _GLIBCXX_DEQUE_BUF_SIZE 512
+#endif
+
+  inline size_t
+  __deque_buf_size(size_t __size)
+  { return (__size < _GLIBCXX_DEQUE_BUF_SIZE
+	    ? size_t(_GLIBCXX_DEQUE_BUF_SIZE / __size) : size_t(1)); }
+
+
+  /**
+   *  @brief A deque::iterator.
+   *
+   *  Quite a bit of intelligence here.  Much of the functionality of
+   *  deque is actually passed off to this class.  A deque holds two
+   *  of these internally, marking its valid range.  Access to
+   *  elements is done as offsets of either of those two, relying on
+   *  operator overloading in this class.
+   *
+   *  All the functions are op overloads except for _M_set_node.
+  */
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    struct _Deque_iterator
+    {
+      typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
+      typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+
+      static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
+      { return __deque_buf_size(sizeof(_Tp)); }
+
+      typedef std::random_access_iterator_tag iterator_category;
+      typedef _Tp                             value_type;
+      typedef _Ptr                            pointer;
+      typedef _Ref                            reference;
+      typedef size_t                          size_type;
+      typedef ptrdiff_t                       difference_type;
+      typedef _Tp**                           _Map_pointer;
+      typedef _Deque_iterator                 _Self;
+
+      _Tp* _M_cur;
+      _Tp* _M_first;
+      _Tp* _M_last;
+      _Map_pointer _M_node;
+
+      _Deque_iterator(_Tp* __x, _Map_pointer __y) _GLIBCXX_NOEXCEPT
+      : _M_cur(__x), _M_first(*__y),
+        _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
+
+      _Deque_iterator() _GLIBCXX_NOEXCEPT
+      : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
+
+      _Deque_iterator(const iterator& __x) _GLIBCXX_NOEXCEPT
+      : _M_cur(__x._M_cur), _M_first(__x._M_first),
+        _M_last(__x._M_last), _M_node(__x._M_node) { }
+
+      iterator
+      _M_const_cast() const _GLIBCXX_NOEXCEPT
+      { return iterator(_M_cur, _M_node); }
+
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      { return *_M_cur; }
+
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT
+      { return _M_cur; }
+
+      _Self&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	++_M_cur;
+	if (_M_cur == _M_last)
+	  {
+	    _M_set_node(_M_node + 1);
+	    _M_cur = _M_first;
+	  }
+	return *this;
+      }
+
+      _Self
+      operator++(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	++*this;
+	return __tmp;
+      }
+
+      _Self&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	if (_M_cur == _M_first)
+	  {
+	    _M_set_node(_M_node - 1);
+	    _M_cur = _M_last;
+	  }
+	--_M_cur;
+	return *this;
+      }
+
+      _Self
+      operator--(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	--*this;
+	return __tmp;
+      }
+
+      _Self&
+      operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
+      {
+	const difference_type __offset = __n + (_M_cur - _M_first);
+	if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
+	  _M_cur += __n;
+	else
+	  {
+	    const difference_type __node_offset =
+	      __offset > 0 ? __offset / difference_type(_S_buffer_size())
+	                   : -difference_type((-__offset - 1)
+					      / _S_buffer_size()) - 1;
+	    _M_set_node(_M_node + __node_offset);
+	    _M_cur = _M_first + (__offset - __node_offset
+				 * difference_type(_S_buffer_size()));
+	  }
+	return *this;
+      }
+
+      _Self
+      operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	return __tmp += __n;
+      }
+
+      _Self&
+      operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
+      { return *this += -__n; }
+
+      _Self
+      operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	return __tmp -= __n;
+      }
+
+      reference
+      operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
+      { return *(*this + __n); }
+
+      /** 
+       *  Prepares to traverse new_node.  Sets everything except
+       *  _M_cur, which should therefore be set by the caller
+       *  immediately afterwards, based on _M_first and _M_last.
+       */
+      void
+      _M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT
+      {
+	_M_node = __new_node;
+	_M_first = *__new_node;
+	_M_last = _M_first + difference_type(_S_buffer_size());
+      }
+    };
+
+  // Note: we also provide overloads whose operands are of the same type in
+  // order to avoid ambiguous overload resolution when std::rel_ops operators
+  // are in scope (for additional details, see libstdc++/3628)
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+	       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+	   typename _RefR, typename _PtrR>
+    inline bool
+    operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+	       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+	       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
+    { return !(__x == __y); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+	   typename _RefR, typename _PtrR>
+    inline bool
+    operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+	       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
+    { return !(__x == __y); }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+	      const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
+    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
+                                          : (__x._M_node < __y._M_node); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+	   typename _RefR, typename _PtrR>
+    inline bool
+    operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+	      const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
+    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
+	                                  : (__x._M_node < __y._M_node); }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+	      const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
+    { return __y < __x; }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+	   typename _RefR, typename _PtrR>
+    inline bool
+    operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+	      const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
+    { return __y < __x; }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+	       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
+    { return !(__y < __x); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+	   typename _RefR, typename _PtrR>
+    inline bool
+    operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+	       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
+    { return !(__y < __x); }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+	       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
+    { return !(__x < __y); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+	   typename _RefR, typename _PtrR>
+    inline bool
+    operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+	       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
+    { return !(__x < __y); }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // According to the resolution of DR179 not only the various comparison
+  // operators but also operator- must accept mixed iterator/const_iterator
+  // parameters.
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
+    operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+	      const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
+    {
+      return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
+	(_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
+	* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+	+ (__y._M_last - __y._M_cur);
+    }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+	   typename _RefR, typename _PtrR>
+    inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
+    operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+	      const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
+    {
+      return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
+	(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
+	* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+	+ (__y._M_last - __y._M_cur);
+    }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline _Deque_iterator<_Tp, _Ref, _Ptr>
+    operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
+    _GLIBCXX_NOEXCEPT
+    { return __x + __n; }
+
+  template<typename _Tp>
+    void
+    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
+	 const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+	 _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
+		       _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
+		       __result); }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+		  _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::copy_backward(_Deque_iterator<_Tp,
+				const _Tp&, const _Tp*>(__first),
+				_Deque_iterator<_Tp,
+				const _Tp&, const _Tp*>(__last),
+				__result); }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+	 _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+	 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
+		       _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
+		       __result); }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+		  _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+		  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::move_backward(_Deque_iterator<_Tp,
+				const _Tp&, const _Tp*>(__first),
+				_Deque_iterator<_Tp,
+				const _Tp&, const _Tp*>(__last),
+				__result); }
+#endif
+
+  /**
+   *  Deque base class.  This class provides the unified face for %deque's
+   *  allocation.  This class's constructor and destructor allocate and
+   *  deallocate (but do not initialize) storage.  This makes %exception
+   *  safety easier.
+   *
+   *  Nothing in this class ever constructs or destroys an actual Tp element.
+   *  (Deque handles that itself.)  Only/All memory management is performed
+   *  here.
+  */
+  template<typename _Tp, typename _Alloc>
+    class _Deque_base
+    {
+    public:
+      typedef _Alloc                  allocator_type;
+
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+      typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
+      typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+
+      _Deque_base()
+      : _M_impl()
+      { _M_initialize_map(0); }
+
+      _Deque_base(size_t __num_elements)
+      : _M_impl()
+      { _M_initialize_map(__num_elements); }
+
+      _Deque_base(const allocator_type& __a, size_t __num_elements)
+      : _M_impl(__a)
+      { _M_initialize_map(__num_elements); }
+
+      _Deque_base(const allocator_type& __a)
+      : _M_impl(__a)
+      { }
+
+#if __cplusplus >= 201103L
+      _Deque_base(_Deque_base&& __x)
+      : _M_impl(std::move(__x._M_get_Tp_allocator()))
+      {
+	_M_initialize_map(0);
+	if (__x._M_impl._M_map)
+	  {
+	    std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+	    std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+	    std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
+	    std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
+	  }
+      }
+#endif
+
+      ~_Deque_base() _GLIBCXX_NOEXCEPT;
+
+    protected:
+      typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
+
+      typedef typename _Alloc::template rebind<_Tp>::other  _Tp_alloc_type;
+
+      //This struct encapsulates the implementation of the std::deque
+      //standard container and at the same time makes use of the EBO
+      //for empty allocators.
+      struct _Deque_impl
+      : public _Tp_alloc_type
+      {
+	_Tp** _M_map;
+	size_t _M_map_size;
+	iterator _M_start;
+	iterator _M_finish;
+
+	_Deque_impl()
+	: _Tp_alloc_type(), _M_map(0), _M_map_size(0),
+	  _M_start(), _M_finish()
+	{ }
+
+	_Deque_impl(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
+	: _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
+	  _M_start(), _M_finish()
+	{ }
+
+#if __cplusplus >= 201103L
+	_Deque_impl(_Tp_alloc_type&& __a) _GLIBCXX_NOEXCEPT
+	: _Tp_alloc_type(std::move(__a)), _M_map(0), _M_map_size(0),
+	  _M_start(), _M_finish()
+	{ }
+#endif
+      };
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() _GLIBCXX_NOEXCEPT
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+
+      _Map_alloc_type
+      _M_get_map_allocator() const _GLIBCXX_NOEXCEPT
+      { return _Map_alloc_type(_M_get_Tp_allocator()); }
+
+      _Tp*
+      _M_allocate_node()
+      { 
+	return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
+      }
+
+      void
+      _M_deallocate_node(_Tp* __p) _GLIBCXX_NOEXCEPT
+      {
+	_M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
+      }
+
+      _Tp**
+      _M_allocate_map(size_t __n)
+      { return _M_get_map_allocator().allocate(__n); }
+
+      void
+      _M_deallocate_map(_Tp** __p, size_t __n) _GLIBCXX_NOEXCEPT
+      { _M_get_map_allocator().deallocate(__p, __n); }
+
+    protected:
+      void _M_initialize_map(size_t);
+      void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
+      void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) _GLIBCXX_NOEXCEPT;
+      enum { _S_initial_map_size = 8 };
+
+      _Deque_impl _M_impl;
+    };
+
+  template<typename _Tp, typename _Alloc>
+    _Deque_base<_Tp, _Alloc>::
+    ~_Deque_base() _GLIBCXX_NOEXCEPT
+    {
+      if (this->_M_impl._M_map)
+	{
+	  _M_destroy_nodes(this->_M_impl._M_start._M_node,
+			   this->_M_impl._M_finish._M_node + 1);
+	  _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+	}
+    }
+
+  /**
+   *  @brief Layout storage.
+   *  @param  __num_elements  The count of T's for which to allocate space
+   *                        at first.
+   *  @return   Nothing.
+   *
+   *  The initial underlying memory layout is a bit complicated...
+  */
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_initialize_map(size_t __num_elements)
+    {
+      const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
+				  + 1);
+
+      this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
+					   size_t(__num_nodes + 2));
+      this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
+
+      // For "small" maps (needing less than _M_map_size nodes), allocation
+      // starts in the middle elements and grows outwards.  So nstart may be
+      // the beginning of _M_map, but for small maps it may be as far in as
+      // _M_map+3.
+
+      _Tp** __nstart = (this->_M_impl._M_map
+			+ (this->_M_impl._M_map_size - __num_nodes) / 2);
+      _Tp** __nfinish = __nstart + __num_nodes;
+
+      __try
+	{ _M_create_nodes(__nstart, __nfinish); }
+      __catch(...)
+	{
+	  _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+	  this->_M_impl._M_map = 0;
+	  this->_M_impl._M_map_size = 0;
+	  __throw_exception_again;
+	}
+
+      this->_M_impl._M_start._M_set_node(__nstart);
+      this->_M_impl._M_finish._M_set_node(__nfinish - 1);
+      this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
+      this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
+					+ __num_elements
+					% __deque_buf_size(sizeof(_Tp)));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
+    {
+      _Tp** __cur;
+      __try
+	{
+	  for (__cur = __nstart; __cur < __nfinish; ++__cur)
+	    *__cur = this->_M_allocate_node();
+	}
+      __catch(...)
+	{
+	  _M_destroy_nodes(__nstart, __cur);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) _GLIBCXX_NOEXCEPT
+    {
+      for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
+	_M_deallocate_node(*__n);
+    }
+
+  /**
+   *  @brief  A standard container using fixed-size memory allocation and
+   *  constant-time manipulation of elements at either end.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Tp  Type of element.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_Tp>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and a
+   *  <a href="tables.html#67">sequence</a>, including the
+   *  <a href="tables.html#68">optional sequence requirements</a>.
+   *
+   *  In previous HP/SGI versions of deque, there was an extra template
+   *  parameter so users could control the node size.  This extension turned
+   *  out to violate the C++ standard (it can be detected using template
+   *  template parameters), and it was removed.
+   *
+   *  Here's how a deque<Tp> manages memory.  Each deque has 4 members:
+   *
+   *  - Tp**        _M_map
+   *  - size_t      _M_map_size
+   *  - iterator    _M_start, _M_finish
+   *
+   *  map_size is at least 8.  %map is an array of map_size
+   *  pointers-to-@a nodes.  (The name %map has nothing to do with the
+   *  std::map class, and @b nodes should not be confused with
+   *  std::list's usage of @a node.)
+   *
+   *  A @a node has no specific type name as such, but it is referred
+   *  to as @a node in this file.  It is a simple array-of-Tp.  If Tp
+   *  is very large, there will be one Tp element per node (i.e., an
+   *  @a array of one).  For non-huge Tp's, node size is inversely
+   *  related to Tp size: the larger the Tp, the fewer Tp's will fit
+   *  in a node.  The goal here is to keep the total size of a node
+   *  relatively small and constant over different Tp's, to improve
+   *  allocator efficiency.
+   *
+   *  Not every pointer in the %map array will point to a node.  If
+   *  the initial number of elements in the deque is small, the
+   *  /middle/ %map pointers will be valid, and the ones at the edges
+   *  will be unused.  This same situation will arise as the %map
+   *  grows: available %map pointers, if any, will be on the ends.  As
+   *  new nodes are created, only a subset of the %map's pointers need
+   *  to be copied @a outward.
+   *
+   *  Class invariants:
+   * - For any nonsingular iterator i:
+   *    - i.node points to a member of the %map array.  (Yes, you read that
+   *      correctly:  i.node does not actually point to a node.)  The member of
+   *      the %map array is what actually points to the node.
+   *    - i.first == *(i.node)    (This points to the node (first Tp element).)
+   *    - i.last  == i.first + node_size
+   *    - i.cur is a pointer in the range [i.first, i.last).  NOTE:
+   *      the implication of this is that i.cur is always a dereferenceable
+   *      pointer, even if i is a past-the-end iterator.
+   * - Start and Finish are always nonsingular iterators.  NOTE: this
+   * means that an empty deque must have one node, a deque with <N
+   * elements (where N is the node buffer size) must have one node, a
+   * deque with N through (2N-1) elements must have two nodes, etc.
+   * - For every node other than start.node and finish.node, every
+   * element in the node is an initialized object.  If start.node ==
+   * finish.node, then [start.cur, finish.cur) are initialized
+   * objects, and the elements outside that range are uninitialized
+   * storage.  Otherwise, [start.cur, start.last) and [finish.first,
+   * finish.cur) are initialized objects, and [start.first, start.cur)
+   * and [finish.cur, finish.last) are uninitialized storage.
+   * - [%map, %map + map_size) is a valid, non-empty range.
+   * - [start.node, finish.node] is a valid range contained within
+   *   [%map, %map + map_size).
+   * - A pointer in the range [%map, %map + map_size) points to an allocated
+   *   node if and only if the pointer is in the range
+   *   [start.node, finish.node].
+   *
+   *  Here's the magic:  nothing in deque is @b aware of the discontiguous
+   *  storage!
+   *
+   *  The memory setup and layout occurs in the parent, _Base, and the iterator
+   *  class is entirely responsible for @a leaping from one node to the next.
+   *  All the implementation routines for deque itself work only through the
+   *  start and finish iterators.  This keeps the routines simple and sane,
+   *  and we can use other standard algorithms as well.
+  */
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class deque : protected _Deque_base<_Tp, _Alloc>
+    {
+      // concept requirements
+      typedef typename _Alloc::value_type        _Alloc_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
+
+      typedef _Deque_base<_Tp, _Alloc>           _Base;
+      typedef typename _Base::_Tp_alloc_type	 _Tp_alloc_type;
+
+    public:
+      typedef _Tp                                        value_type;
+      typedef typename _Tp_alloc_type::pointer           pointer;
+      typedef typename _Tp_alloc_type::const_pointer     const_pointer;
+      typedef typename _Tp_alloc_type::reference         reference;
+      typedef typename _Tp_alloc_type::const_reference   const_reference;
+      typedef typename _Base::iterator                   iterator;
+      typedef typename _Base::const_iterator             const_iterator;
+      typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
+      typedef std::reverse_iterator<iterator>            reverse_iterator;
+      typedef size_t                             size_type;
+      typedef ptrdiff_t                          difference_type;
+      typedef _Alloc                             allocator_type;
+
+    protected:
+      typedef pointer*                           _Map_pointer;
+
+      static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
+      { return __deque_buf_size(sizeof(_Tp)); }
+
+      // Functions controlling memory layout, and nothing else.
+      using _Base::_M_initialize_map;
+      using _Base::_M_create_nodes;
+      using _Base::_M_destroy_nodes;
+      using _Base::_M_allocate_node;
+      using _Base::_M_deallocate_node;
+      using _Base::_M_allocate_map;
+      using _Base::_M_deallocate_map;
+      using _Base::_M_get_Tp_allocator;
+
+      /** 
+       *  A total of four data members accumulated down the hierarchy.
+       *  May be accessed via _M_impl.*
+       */
+      using _Base::_M_impl;
+
+    public:
+      // [23.2.1.1] construct/copy/destroy
+      // (assign() and get_allocator() are also listed in this section)
+
+      /**
+       *  @brief  Creates a %deque with no elements.
+       */
+      deque() : _Base() { }
+
+      /**
+       *  @brief  Creates a %deque with no elements.
+       *  @param  __a  An allocator object.
+       */
+      explicit
+      deque(const allocator_type& __a)
+      : _Base(__a, 0) { }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Creates a %deque with default constructed elements.
+       *  @param  __n  The number of elements to initially create.
+       *
+       *  This constructor fills the %deque with @a n default
+       *  constructed elements.
+       */
+      explicit
+      deque(size_type __n)
+      : _Base(__n)
+      { _M_default_initialize(); }
+
+      /**
+       *  @brief  Creates a %deque with copies of an exemplar element.
+       *  @param  __n  The number of elements to initially create.
+       *  @param  __value  An element to copy.
+       *  @param  __a  An allocator.
+       *
+       *  This constructor fills the %deque with @a __n copies of @a __value.
+       */
+      deque(size_type __n, const value_type& __value,
+	    const allocator_type& __a = allocator_type())
+      : _Base(__a, __n)
+      { _M_fill_initialize(__value); }
+#else
+      /**
+       *  @brief  Creates a %deque with copies of an exemplar element.
+       *  @param  __n  The number of elements to initially create.
+       *  @param  __value  An element to copy.
+       *  @param  __a  An allocator.
+       *
+       *  This constructor fills the %deque with @a __n copies of @a __value.
+       */
+      explicit
+      deque(size_type __n, const value_type& __value = value_type(),
+	    const allocator_type& __a = allocator_type())
+      : _Base(__a, __n)
+      { _M_fill_initialize(__value); }
+#endif
+
+      /**
+       *  @brief  %Deque copy constructor.
+       *  @param  __x  A %deque of identical element and allocator types.
+       *
+       *  The newly-created %deque uses a copy of the allocation object used
+       *  by @a __x.
+       */
+      deque(const deque& __x)
+      : _Base(__x._M_get_Tp_allocator(), __x.size())
+      { std::__uninitialized_copy_a(__x.begin(), __x.end(), 
+				    this->_M_impl._M_start,
+				    _M_get_Tp_allocator()); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Deque move constructor.
+       *  @param  __x  A %deque of identical element and allocator types.
+       *
+       *  The newly-created %deque contains the exact contents of @a __x.
+       *  The contents of @a __x are a valid, but unspecified %deque.
+       */
+      deque(deque&& __x)
+      : _Base(std::move(__x)) { }
+
+      /**
+       *  @brief  Builds a %deque from an initializer list.
+       *  @param  __l  An initializer_list.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %deque consisting of copies of the elements in the
+       *  initializer_list @a __l.
+       *
+       *  This will call the element type's copy constructor N times
+       *  (where N is __l.size()) and do no memory reallocation.
+       */
+      deque(initializer_list<value_type> __l,
+	    const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	_M_range_initialize(__l.begin(), __l.end(),
+			    random_access_iterator_tag());
+      }
+#endif
+
+      /**
+       *  @brief  Builds a %deque from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %deque consisting of copies of the elements from [__first,
+       *  __last).
+       *
+       *  If the iterators are forward, bidirectional, or random-access, then
+       *  this will call the elements' copy constructor N times (where N is
+       *  distance(__first,__last)) and do no memory reallocation.  But if only
+       *  input iterators are used, then this will do at most 2N calls to the
+       *  copy constructor, and logN memory reallocations.
+       */
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        deque(_InputIterator __first, _InputIterator __last,
+	      const allocator_type& __a = allocator_type())
+	: _Base(__a)
+        { _M_initialize_dispatch(__first, __last, __false_type()); }
+#else
+      template<typename _InputIterator>
+        deque(_InputIterator __first, _InputIterator __last,
+	      const allocator_type& __a = allocator_type())
+	: _Base(__a)
+        {
+	  // Check whether it's an integral type.  If so, it's not an iterator.
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_initialize_dispatch(__first, __last, _Integral());
+	}
+#endif
+
+      /**
+       *  The dtor only erases the elements, and note that if the elements
+       *  themselves are pointers, the pointed-to memory is not touched in any
+       *  way.  Managing the pointer is the user's responsibility.
+       */
+      ~deque() _GLIBCXX_NOEXCEPT
+      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
+
+      /**
+       *  @brief  %Deque assignment operator.
+       *  @param  __x  A %deque of identical element and allocator types.
+       *
+       *  All the elements of @a x are copied, but unlike the copy constructor,
+       *  the allocator object is not copied.
+       */
+      deque&
+      operator=(const deque& __x);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Deque move assignment operator.
+       *  @param  __x  A %deque of identical element and allocator types.
+       *
+       *  The contents of @a __x are moved into this deque (without copying).
+       *  @a __x is a valid, but unspecified %deque.
+       */
+      deque&
+      operator=(deque&& __x) noexcept
+      {
+	// NB: DR 1204.
+	// NB: DR 675.
+	this->clear();
+	this->swap(__x);
+	return *this;
+      }
+
+      /**
+       *  @brief  Assigns an initializer list to a %deque.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %deque with copies of the elements in the
+       *  initializer_list @a __l.
+       *
+       *  Note that the assignment completely changes the %deque and that the
+       *  resulting %deque's size is the same as the number of elements
+       *  assigned.  Old data may be lost.
+       */
+      deque&
+      operator=(initializer_list<value_type> __l)
+      {
+	this->assign(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      /**
+       *  @brief  Assigns a given value to a %deque.
+       *  @param  __n  Number of elements to be assigned.
+       *  @param  __val  Value to be assigned.
+       *
+       *  This function fills a %deque with @a n copies of the given
+       *  value.  Note that the assignment completely changes the
+       *  %deque and that the resulting %deque's size is the same as
+       *  the number of elements assigned.  Old data may be lost.
+       */
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+
+      /**
+       *  @brief  Assigns a range to a %deque.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *
+       *  This function fills a %deque with copies of the elements in the
+       *  range [__first,__last).
+       *
+       *  Note that the assignment completely changes the %deque and that the
+       *  resulting %deque's size is the same as the number of elements
+       *  assigned.  Old data may be lost.
+       */
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _M_assign_dispatch(__first, __last, __false_type()); }
+#else
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_assign_dispatch(__first, __last, _Integral());
+	}
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Assigns an initializer list to a %deque.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %deque with copies of the elements in the
+       *  initializer_list @a __l.
+       *
+       *  Note that the assignment completely changes the %deque and that the
+       *  resulting %deque's size is the same as the number of elements
+       *  assigned.  Old data may be lost.
+       */
+      void
+      assign(initializer_list<value_type> __l)
+      { this->assign(__l.begin(), __l.end()); }
+#endif
+
+      /// Get a copy of the memory allocation object.
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return _Base::get_allocator(); }
+
+      // iterators
+      /**
+       *  Returns a read/write iterator that points to the first element in the
+       *  %deque.  Iteration is done in ordinary element order.
+       */
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_start; }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %deque.  Iteration is done in ordinary element order.
+       */
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_start; }
+
+      /**
+       *  Returns a read/write iterator that points one past the last
+       *  element in the %deque.  Iteration is done in ordinary
+       *  element order.
+       */
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_finish; }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past
+       *  the last element in the %deque.  Iteration is done in
+       *  ordinary element order.
+       */
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_finish; }
+
+      /**
+       *  Returns a read/write reverse iterator that points to the
+       *  last element in the %deque.  Iteration is done in reverse
+       *  element order.
+       */
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(this->_M_impl._M_finish); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last element in the %deque.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(this->_M_impl._M_finish); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to one
+       *  before the first element in the %deque.  Iteration is done
+       *  in reverse element order.
+       */
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(this->_M_impl._M_start); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first element in the %deque.  Iteration is
+       *  done in reverse element order.
+       */
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(this->_M_impl._M_start); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %deque.  Iteration is done in ordinary element order.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return this->_M_impl._M_start; }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past
+       *  the last element in the %deque.  Iteration is done in
+       *  ordinary element order.
+       */
+      const_iterator
+      cend() const noexcept
+      { return this->_M_impl._M_finish; }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last element in the %deque.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_finish); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first element in the %deque.  Iteration is
+       *  done in reverse element order.
+       */
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_start); }
+#endif
+
+      // [23.2.1.2] capacity
+      /**  Returns the number of elements in the %deque.  */
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_finish - this->_M_impl._M_start; }
+
+      /**  Returns the size() of the largest possible %deque.  */
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _M_get_Tp_allocator().max_size(); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Resizes the %deque to the specified number of elements.
+       *  @param  __new_size  Number of elements the %deque should contain.
+       *
+       *  This function will %resize the %deque to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %deque's current size the %deque is truncated, otherwise
+       *  default constructed elements are appended.
+       */
+      void
+      resize(size_type __new_size)
+      {
+	const size_type __len = size();
+	if (__new_size > __len)
+	  _M_default_append(__new_size - __len);
+	else if (__new_size < __len)
+	  _M_erase_at_end(this->_M_impl._M_start
+			  + difference_type(__new_size));
+      }
+
+      /**
+       *  @brief  Resizes the %deque to the specified number of elements.
+       *  @param  __new_size  Number of elements the %deque should contain.
+       *  @param  __x  Data with which new elements should be populated.
+       *
+       *  This function will %resize the %deque to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %deque's current size the %deque is truncated, otherwise the
+       *  %deque is extended and new elements are populated with given
+       *  data.
+       */
+      void
+      resize(size_type __new_size, const value_type& __x)
+      {
+	const size_type __len = size();
+	if (__new_size > __len)
+	  insert(this->_M_impl._M_finish, __new_size - __len, __x);
+	else if (__new_size < __len)
+	  _M_erase_at_end(this->_M_impl._M_start
+			  + difference_type(__new_size));
+      }
+#else
+      /**
+       *  @brief  Resizes the %deque to the specified number of elements.
+       *  @param  __new_size  Number of elements the %deque should contain.
+       *  @param  __x  Data with which new elements should be populated.
+       *
+       *  This function will %resize the %deque to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %deque's current size the %deque is truncated, otherwise the
+       *  %deque is extended and new elements are populated with given
+       *  data.
+       */
+      void
+      resize(size_type __new_size, value_type __x = value_type())
+      {
+	const size_type __len = size();
+	if (__new_size > __len)
+	  insert(this->_M_impl._M_finish, __new_size - __len, __x);
+	else if (__new_size < __len)
+	  _M_erase_at_end(this->_M_impl._M_start
+			  + difference_type(__new_size));
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      /**  A non-binding request to reduce memory use.  */
+      void
+      shrink_to_fit() noexcept
+      { _M_shrink_to_fit(); }
+#endif
+
+      /**
+       *  Returns true if the %deque is empty.  (Thus begin() would
+       *  equal end().)
+       */
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_finish == this->_M_impl._M_start; }
+
+      // element access
+      /**
+       *  @brief Subscript access to the data contained in the %deque.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read/write reference to data.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)
+       */
+      reference
+      operator[](size_type __n) _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_start[difference_type(__n)]; }
+
+      /**
+       *  @brief Subscript access to the data contained in the %deque.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read-only (constant) reference to data.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)
+       */
+      const_reference
+      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_start[difference_type(__n)]; }
+
+    protected:
+      /// Safety check used only from at().
+      void
+      _M_range_check(size_type __n) const
+      {
+	if (__n >= this->size())
+	  __throw_out_of_range_fmt(__N("deque::_M_range_check: __n "
+				       "(which is %zu)>= this->size() "
+				       "(which is %zu)"),
+				   __n, this->size());
+      }
+
+    public:
+      /**
+       *  @brief  Provides access to the data contained in the %deque.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read/write reference to data.
+       *  @throw  std::out_of_range  If @a __n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter
+       *  is first checked that it is in the range of the deque.  The
+       *  function throws out_of_range if the check fails.
+       */
+      reference
+      at(size_type __n)
+      {
+	_M_range_check(__n);
+	return (*this)[__n];
+      }
+
+      /**
+       *  @brief  Provides access to the data contained in the %deque.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read-only (constant) reference to data.
+       *  @throw  std::out_of_range  If @a __n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter is first
+       *  checked that it is in the range of the deque.  The function throws
+       *  out_of_range if the check fails.
+       */
+      const_reference
+      at(size_type __n) const
+      {
+	_M_range_check(__n);
+	return (*this)[__n];
+      }
+
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %deque.
+       */
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      { return *begin(); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %deque.
+       */
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      { return *begin(); }
+
+      /**
+       *  Returns a read/write reference to the data at the last element of the
+       *  %deque.
+       */
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      {
+	iterator __tmp = end();
+	--__tmp;
+	return *__tmp;
+      }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the last
+       *  element of the %deque.
+       */
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      {
+	const_iterator __tmp = end();
+	--__tmp;
+	return *__tmp;
+      }
+
+      // [23.2.1.2] modifiers
+      /**
+       *  @brief  Add data to the front of the %deque.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical stack operation.  The function creates an
+       *  element at the front of the %deque and assigns the given
+       *  data to it.  Due to the nature of a %deque this operation
+       *  can be done in constant time.
+       */
+      void
+      push_front(const value_type& __x)
+      {
+	if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
+	  {
+	    this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
+	    --this->_M_impl._M_start._M_cur;
+	  }
+	else
+	  _M_push_front_aux(__x);
+      }
+
+#if __cplusplus >= 201103L
+      void
+      push_front(value_type&& __x)
+      { emplace_front(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_front(_Args&&... __args);
+#endif
+
+      /**
+       *  @brief  Add data to the end of the %deque.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical stack operation.  The function creates an
+       *  element at the end of the %deque and assigns the given data
+       *  to it.  Due to the nature of a %deque this operation can be
+       *  done in constant time.
+       */
+      void
+      push_back(const value_type& __x)
+      {
+	if (this->_M_impl._M_finish._M_cur
+	    != this->_M_impl._M_finish._M_last - 1)
+	  {
+	    this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
+	    ++this->_M_impl._M_finish._M_cur;
+	  }
+	else
+	  _M_push_back_aux(__x);
+      }
+
+#if __cplusplus >= 201103L
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args);
+#endif
+
+      /**
+       *  @brief  Removes first element.
+       *
+       *  This is a typical stack operation.  It shrinks the %deque by one.
+       *
+       *  Note that no data is returned, and if the first element's data is
+       *  needed, it should be retrieved before pop_front() is called.
+       */
+      void
+      pop_front() _GLIBCXX_NOEXCEPT
+      {
+	if (this->_M_impl._M_start._M_cur
+	    != this->_M_impl._M_start._M_last - 1)
+	  {
+	    this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
+	    ++this->_M_impl._M_start._M_cur;
+	  }
+	else
+	  _M_pop_front_aux();
+      }
+
+      /**
+       *  @brief  Removes last element.
+       *
+       *  This is a typical stack operation.  It shrinks the %deque by one.
+       *
+       *  Note that no data is returned, and if the last element's data is
+       *  needed, it should be retrieved before pop_back() is called.
+       */
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      {
+	if (this->_M_impl._M_finish._M_cur
+	    != this->_M_impl._M_finish._M_first)
+	  {
+	    --this->_M_impl._M_finish._M_cur;
+	    this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
+	  }
+	else
+	  _M_pop_back_aux();
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts an object in %deque before specified iterator.
+       *  @param  __position  A const_iterator into the %deque.
+       *  @param  __args  Arguments.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert an object of type T constructed
+       *  with T(std::forward<Args>(args)...) before the specified location.
+       */
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args);
+
+      /**
+       *  @brief  Inserts given value into %deque before specified iterator.
+       *  @param  __position  A const_iterator into the %deque.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given value before the
+       *  specified location.
+       */
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+#else
+      /**
+       *  @brief  Inserts given value into %deque before specified iterator.
+       *  @param  __position  An iterator into the %deque.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given value before the
+       *  specified location.
+       */
+      iterator
+      insert(iterator __position, const value_type& __x);
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts given rvalue into %deque before specified iterator.
+       *  @param  __position  A const_iterator into the %deque.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given rvalue before the
+       *  specified location.
+       */
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+
+      /**
+       *  @brief  Inserts an initializer list into the %deque.
+       *  @param  __p  An iterator into the %deque.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function will insert copies of the data in the
+       *  initializer_list @a __l into the %deque before the location
+       *  specified by @a __p.  This is known as <em>list insert</em>.
+       */
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts a number of copies of given data into the %deque.
+       *  @param  __position  A const_iterator into the %deque.
+       *  @param  __n  Number of elements to be inserted.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a specified number of copies of the given
+       *  data before the location specified by @a __position.
+       */
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+	difference_type __offset = __position - cbegin();
+	_M_fill_insert(__position._M_const_cast(), __n, __x);
+	return begin() + __offset;
+      }
+#else
+      /**
+       *  @brief  Inserts a number of copies of given data into the %deque.
+       *  @param  __position  An iterator into the %deque.
+       *  @param  __n  Number of elements to be inserted.
+       *  @param  __x  Data to be inserted.
+       *
+       *  This function will insert a specified number of copies of the given
+       *  data before the location specified by @a __position.
+       */
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      { _M_fill_insert(__position, __n, __x); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts a range into the %deque.
+       *  @param  __position  A const_iterator into the %deque.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert copies of the data in the range
+       *  [__first,__last) into the %deque before the location specified
+       *  by @a __position.  This is known as <em>range insert</em>.
+       */
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert(const_iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+        {
+	  difference_type __offset = __position - cbegin();
+	  _M_insert_dispatch(__position._M_const_cast(),
+			     __first, __last, __false_type());
+	  return begin() + __offset;
+	}
+#else
+      /**
+       *  @brief  Inserts a range into the %deque.
+       *  @param  __position  An iterator into the %deque.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *
+       *  This function will insert copies of the data in the range
+       *  [__first,__last) into the %deque before the location specified
+       *  by @a __position.  This is known as <em>range insert</em>.
+       */
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+        {
+	  // Check whether it's an integral type.  If so, it's not an iterator.
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_insert_dispatch(__position, __first, __last, _Integral());
+	}
+#endif
+
+      /**
+       *  @brief  Remove element at given position.
+       *  @param  __position  Iterator pointing to element to be erased.
+       *  @return  An iterator pointing to the next element (or end()).
+       *
+       *  This function will erase the element at the given position and thus
+       *  shorten the %deque by one.
+       *
+       *  The user is cautioned that
+       *  this function only erases the element, and that if the element is
+       *  itself a pointer, the pointed-to memory is not touched in any way.
+       *  Managing the pointer is the user's responsibility.
+       */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position)
+#else
+      erase(iterator __position)
+#endif
+      { return _M_erase(__position._M_const_cast()); }
+
+      /**
+       *  @brief  Remove a range of elements.
+       *  @param  __first  Iterator pointing to the first element to be erased.
+       *  @param  __last  Iterator pointing to one past the last element to be
+       *                erased.
+       *  @return  An iterator pointing to the element pointed to by @a last
+       *           prior to erasing (or end()).
+       *
+       *  This function will erase the elements in the range
+       *  [__first,__last) and shorten the %deque accordingly.
+       *
+       *  The user is cautioned that
+       *  this function only erases the elements, and that if the elements
+       *  themselves are pointers, the pointed-to memory is not touched in any
+       *  way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last)
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+
+      /**
+       *  @brief  Swaps data with another %deque.
+       *  @param  __x  A %deque of the same element and allocator types.
+       *
+       *  This exchanges the elements between two deques in constant time.
+       *  (Four pointers, so it should be quite fast.)
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(d1,d2) will feed to this function.
+       */
+      void
+      swap(deque& __x) _GLIBCXX_NOEXCEPT
+      {
+	std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+	std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+	std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
+	std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
+
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 431. Swapping containers with unequal allocators.
+	std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
+						    __x._M_get_Tp_allocator());
+      }
+
+      /**
+       *  Erases all the elements.  Note that this function only erases the
+       *  elements, and that if the elements themselves are pointers, the
+       *  pointed-to memory is not touched in any way.  Managing the pointer is
+       *  the user's responsibility.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { _M_erase_at_end(begin()); }
+
+    protected:
+      // Internal constructor functions follow.
+
+      // called by the range constructor to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+        {
+	  _M_initialize_map(static_cast<size_type>(__n));
+	  _M_fill_initialize(__x);
+	}
+
+      // called by the range constructor to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+			       __false_type)
+        {
+	  typedef typename std::iterator_traits<_InputIterator>::
+	    iterator_category _IterCategory;
+	  _M_range_initialize(__first, __last, _IterCategory());
+	}
+
+      // called by the second initialize_dispatch above
+      //@{
+      /**
+       *  @brief Fills the deque with whatever is in [first,last).
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @return   Nothing.
+       *
+       *  If the iterators are actually forward iterators (or better), then the
+       *  memory layout can be done all at once.  Else we move forward using
+       *  push_back on each value from the iterator.
+       */
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first, _InputIterator __last,
+			    std::input_iterator_tag);
+
+      // called by the second initialize_dispatch above
+      template<typename _ForwardIterator>
+        void
+        _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+			    std::forward_iterator_tag);
+      //@}
+
+      /**
+       *  @brief Fills the %deque with copies of value.
+       *  @param  __value  Initial value.
+       *  @return   Nothing.
+       *  @pre _M_start and _M_finish have already been initialized,
+       *  but none of the %deque's elements have yet been constructed.
+       *
+       *  This function is called only when the user provides an explicit size
+       *  (with or without an explicit exemplar value).
+       */
+      void
+      _M_fill_initialize(const value_type& __value);
+
+#if __cplusplus >= 201103L
+      // called by deque(n).
+      void
+      _M_default_initialize();
+#endif
+
+      // Internal assign functions follow.  The *_aux functions do the actual
+      // assignment work for the range versions.
+
+      // called by the range assign to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+
+      // called by the range assign to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+			   __false_type)
+        {
+	  typedef typename std::iterator_traits<_InputIterator>::
+	    iterator_category _IterCategory;
+	  _M_assign_aux(__first, __last, _IterCategory());
+	}
+
+      // called by the second assign_dispatch above
+      template<typename _InputIterator>
+        void
+        _M_assign_aux(_InputIterator __first, _InputIterator __last,
+		      std::input_iterator_tag);
+
+      // called by the second assign_dispatch above
+      template<typename _ForwardIterator>
+        void
+        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+		      std::forward_iterator_tag)
+        {
+	  const size_type __len = std::distance(__first, __last);
+	  if (__len > size())
+	    {
+	      _ForwardIterator __mid = __first;
+	      std::advance(__mid, size());
+	      std::copy(__first, __mid, begin());
+	      insert(end(), __mid, __last);
+	    }
+	  else
+	    _M_erase_at_end(std::copy(__first, __last, begin()));
+	}
+
+      // Called by assign(n,t), and the range assign when it turns out
+      // to be the same thing.
+      void
+      _M_fill_assign(size_type __n, const value_type& __val)
+      {
+	if (__n > size())
+	  {
+	    std::fill(begin(), end(), __val);
+	    insert(end(), __n - size(), __val);
+	  }
+	else
+	  {
+	    _M_erase_at_end(begin() + difference_type(__n));
+	    std::fill(begin(), end(), __val);
+	  }
+      }
+
+      //@{
+      /// Helper functions for push_* and pop_*.
+#if __cplusplus < 201103L
+      void _M_push_back_aux(const value_type&);
+
+      void _M_push_front_aux(const value_type&);
+#else
+      template<typename... _Args>
+        void _M_push_back_aux(_Args&&... __args);
+
+      template<typename... _Args>
+        void _M_push_front_aux(_Args&&... __args);
+#endif
+
+      void _M_pop_back_aux();
+
+      void _M_pop_front_aux();
+      //@}
+
+      // Internal insert functions follow.  The *_aux functions do the actual
+      // insertion work when all shortcuts fail.
+
+      // called by the range insert to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_insert_dispatch(iterator __pos,
+			   _Integer __n, _Integer __x, __true_type)
+        { _M_fill_insert(__pos, __n, __x); }
+
+      // called by the range insert to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_insert_dispatch(iterator __pos,
+			   _InputIterator __first, _InputIterator __last,
+			   __false_type)
+        {
+	  typedef typename std::iterator_traits<_InputIterator>::
+	    iterator_category _IterCategory;
+          _M_range_insert_aux(__pos, __first, __last, _IterCategory());
+	}
+
+      // called by the second insert_dispatch above
+      template<typename _InputIterator>
+        void
+        _M_range_insert_aux(iterator __pos, _InputIterator __first,
+			    _InputIterator __last, std::input_iterator_tag);
+
+      // called by the second insert_dispatch above
+      template<typename _ForwardIterator>
+        void
+        _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
+			    _ForwardIterator __last, std::forward_iterator_tag);
+
+      // Called by insert(p,n,x), and the range insert when it turns out to be
+      // the same thing.  Can use fill functions in optimal situations,
+      // otherwise passes off to insert_aux(p,n,x).
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+      // called by insert(p,x)
+#if __cplusplus < 201103L
+      iterator
+      _M_insert_aux(iterator __pos, const value_type& __x);
+#else
+      template<typename... _Args>
+        iterator
+        _M_insert_aux(iterator __pos, _Args&&... __args);
+#endif
+
+      // called by insert(p,n,x) via fill_insert
+      void
+      _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
+
+      // called by range_insert_aux for forward iterators
+      template<typename _ForwardIterator>
+        void
+        _M_insert_aux(iterator __pos,
+		      _ForwardIterator __first, _ForwardIterator __last,
+		      size_type __n);
+
+
+      // Internal erase functions follow.
+
+      void
+      _M_destroy_data_aux(iterator __first, iterator __last);
+
+      // Called by ~deque().
+      // NB: Doesn't deallocate the nodes.
+      template<typename _Alloc1>
+        void
+        _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
+        { _M_destroy_data_aux(__first, __last); }
+
+      void
+      _M_destroy_data(iterator __first, iterator __last,
+		      const std::allocator<_Tp>&)
+      {
+	if (!__has_trivial_destructor(value_type))
+	  _M_destroy_data_aux(__first, __last);
+      }
+
+      // Called by erase(q1, q2).
+      void
+      _M_erase_at_begin(iterator __pos)
+      {
+	_M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
+	_M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
+	this->_M_impl._M_start = __pos;
+      }
+
+      // Called by erase(q1, q2), resize(), clear(), _M_assign_aux,
+      // _M_fill_assign, operator=.
+      void
+      _M_erase_at_end(iterator __pos)
+      {
+	_M_destroy_data(__pos, end(), _M_get_Tp_allocator());
+	_M_destroy_nodes(__pos._M_node + 1,
+			 this->_M_impl._M_finish._M_node + 1);
+	this->_M_impl._M_finish = __pos;
+      }
+
+      iterator
+      _M_erase(iterator __pos);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+
+#if __cplusplus >= 201103L
+      // Called by resize(sz).
+      void
+      _M_default_append(size_type __n);
+
+      bool
+      _M_shrink_to_fit();
+#endif
+
+      //@{
+      /// Memory-handling helpers for the previous internal insert functions.
+      iterator
+      _M_reserve_elements_at_front(size_type __n)
+      {
+	const size_type __vacancies = this->_M_impl._M_start._M_cur
+	                              - this->_M_impl._M_start._M_first;
+	if (__n > __vacancies)
+	  _M_new_elements_at_front(__n - __vacancies);
+	return this->_M_impl._M_start - difference_type(__n);
+      }
+
+      iterator
+      _M_reserve_elements_at_back(size_type __n)
+      {
+	const size_type __vacancies = (this->_M_impl._M_finish._M_last
+				       - this->_M_impl._M_finish._M_cur) - 1;
+	if (__n > __vacancies)
+	  _M_new_elements_at_back(__n - __vacancies);
+	return this->_M_impl._M_finish + difference_type(__n);
+      }
+
+      void
+      _M_new_elements_at_front(size_type __new_elements);
+
+      void
+      _M_new_elements_at_back(size_type __new_elements);
+      //@}
+
+
+      //@{
+      /**
+       *  @brief Memory-handling helpers for the major %map.
+       *
+       *  Makes sure the _M_map has space for new nodes.  Does not
+       *  actually add the nodes.  Can invalidate _M_map pointers.
+       *  (And consequently, %deque iterators.)
+       */
+      void
+      _M_reserve_map_at_back(size_type __nodes_to_add = 1)
+      {
+	if (__nodes_to_add + 1 > this->_M_impl._M_map_size
+	    - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
+	  _M_reallocate_map(__nodes_to_add, false);
+      }
+
+      void
+      _M_reserve_map_at_front(size_type __nodes_to_add = 1)
+      {
+	if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
+				       - this->_M_impl._M_map))
+	  _M_reallocate_map(__nodes_to_add, true);
+      }
+
+      void
+      _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
+      //@}
+    };
+
+
+  /**
+   *  @brief  Deque equality comparison.
+   *  @param  __x  A %deque.
+   *  @param  __y  A %deque of the same type as @a __x.
+   *  @return  True iff the size and elements of the deques are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the size of the
+   *  deques.  Deques are considered equivalent if their sizes are equal,
+   *  and if corresponding elements compare equal.
+  */
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const deque<_Tp, _Alloc>& __x,
+                         const deque<_Tp, _Alloc>& __y)
+    { return __x.size() == __y.size()
+             && std::equal(__x.begin(), __x.end(), __y.begin()); }
+
+  /**
+   *  @brief  Deque ordering relation.
+   *  @param  __x  A %deque.
+   *  @param  __y  A %deque of the same type as @a __x.
+   *  @return  True iff @a x is lexicographically less than @a __y.
+   *
+   *  This is a total ordering relation.  It is linear in the size of the
+   *  deques.  The elements must be comparable with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+  */
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const deque<_Tp, _Alloc>& __x,
+	      const deque<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+					  __y.begin(), __y.end()); }
+
+  /// Based on operator==
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const deque<_Tp, _Alloc>& __x,
+	       const deque<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const deque<_Tp, _Alloc>& __x,
+	      const deque<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const deque<_Tp, _Alloc>& __x,
+	       const deque<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const deque<_Tp, _Alloc>& __x,
+	       const deque<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  /// See std::deque::swap().
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
+    { __x.swap(__y); }
+
+#undef _GLIBCXX_DEQUE_BUF_SIZE
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _STL_DEQUE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_function.h b/gcc-4.9/libstdc++-v3/include/bits/stl_function.h
new file mode 100644
index 0000000..8703ce9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_function.h
@@ -0,0 +1,1083 @@
+// Functor implementations -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_function.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _STL_FUNCTION_H
+#define _STL_FUNCTION_H 1
+
+#if __cplusplus > 201103L
+#include <bits/move.h>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 20.3.1 base classes
+  /** @defgroup functors Function Objects
+   * @ingroup utilities
+   *
+   *  Function objects, or @e functors, are objects with an @c operator()
+   *  defined and accessible.  They can be passed as arguments to algorithm
+   *  templates and used in place of a function pointer.  Not only is the
+   *  resulting expressiveness of the library increased, but the generated
+   *  code can be more efficient than what you might write by hand.  When we
+   *  refer to @a functors, then, generally we include function pointers in
+   *  the description as well.
+   *
+   *  Often, functors are only created as temporaries passed to algorithm
+   *  calls, rather than being created as named variables.
+   *
+   *  Two examples taken from the standard itself follow.  To perform a
+   *  by-element addition of two vectors @c a and @c b containing @c double,
+   *  and put the result in @c a, use
+   *  \code
+   *  transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
+   *  \endcode
+   *  To negate every element in @c a, use
+   *  \code
+   *  transform(a.begin(), a.end(), a.begin(), negate<double>());
+   *  \endcode
+   *  The addition and negation functions will be inlined directly.
+   *
+   *  The standard functors are derived from structs named @c unary_function
+   *  and @c binary_function.  These two classes contain nothing but typedefs,
+   *  to aid in generic (template) programming.  If you write your own
+   *  functors, you might consider doing the same.
+   *
+   *  @{
+   */
+  /**
+   *  This is one of the @link functors functor base classes@endlink.
+   */
+  template<typename _Arg, typename _Result>
+    struct unary_function
+    {
+      /// @c argument_type is the type of the argument
+      typedef _Arg 	argument_type;   
+
+      /// @c result_type is the return type
+      typedef _Result 	result_type;  
+    };
+
+  /**
+   *  This is one of the @link functors functor base classes@endlink.
+   */
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    struct binary_function
+    {
+      /// @c first_argument_type is the type of the first argument
+      typedef _Arg1 	first_argument_type; 
+
+      /// @c second_argument_type is the type of the second argument
+      typedef _Arg2 	second_argument_type;
+
+      /// @c result_type is the return type
+      typedef _Result 	result_type;
+    };
+  /** @}  */
+
+  // 20.3.2 arithmetic
+  /** @defgroup arithmetic_functors Arithmetic Classes
+   * @ingroup functors
+   *
+   *  Because basic math often needs to be done during an algorithm,
+   *  the library provides functors for those operations.  See the
+   *  documentation for @link functors the base classes@endlink
+   *  for examples of their use.
+   *
+   *  @{
+   */
+
+#if __cplusplus > 201103L
+  struct __is_transparent;  // undefined
+
+  template<typename _Tp = void>
+    struct plus;
+
+  template<typename _Tp = void>
+    struct minus;
+
+  template<typename _Tp = void>
+    struct multiplies;
+
+  template<typename _Tp = void>
+    struct divides;
+
+  template<typename _Tp = void>
+    struct modulus;
+
+  template<typename _Tp = void>
+    struct negate;
+#endif
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<typename _Tp>
+    struct plus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x + __y; }
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<typename _Tp>
+    struct minus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x - __y; }
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<typename _Tp>
+    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x * __y; }
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<typename _Tp>
+    struct divides : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x / __y; }
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<typename _Tp>
+    struct modulus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x % __y; }
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<typename _Tp>
+    struct negate : public unary_function<_Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x) const
+      { return -__x; }
+    };
+
+#if __cplusplus > 201103L
+  template<>
+    struct plus<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<>
+    struct minus<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<>
+    struct multiplies<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<>
+    struct divides<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<>
+    struct modulus<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link arithmetic_functors math functors@endlink.
+  template<>
+    struct negate<void>
+    {
+      template <typename _Tp>
+	auto
+	operator()(_Tp&& __t) const
+	noexcept(noexcept(-std::forward<_Tp>(__t)))
+	-> decltype(-std::forward<_Tp>(__t))
+	{ return -std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+#endif
+  /** @}  */
+
+  // 20.3.3 comparisons
+  /** @defgroup comparison_functors Comparison Classes
+   * @ingroup functors
+   *
+   *  The library provides six wrapper functors for all the basic comparisons
+   *  in C++, like @c <.
+   *
+   *  @{
+   */
+#if __cplusplus > 201103L
+  template<typename _Tp = void>
+    struct equal_to;
+
+  template<typename _Tp = void>
+    struct not_equal_to;
+
+  template<typename _Tp = void>
+    struct greater;
+
+  template<typename _Tp = void>
+    struct less;
+
+  template<typename _Tp = void>
+    struct greater_equal;
+
+  template<typename _Tp = void>
+    struct less_equal;
+#endif
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<typename _Tp>
+    struct equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x == __y; }
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<typename _Tp>
+    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x != __y; }
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<typename _Tp>
+    struct greater : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x > __y; }
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<typename _Tp>
+    struct less : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x < __y; }
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<typename _Tp>
+    struct greater_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >= __y; }
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<typename _Tp>
+    struct less_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x <= __y; }
+    };
+
+#if __cplusplus > 201103L
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<>
+    struct equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<>
+    struct not_equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<>
+    struct greater<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<>
+    struct less<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<>
+    struct greater_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link comparison_functors comparison functors@endlink.
+  template<>
+    struct less_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+#endif
+  /** @}  */
+
+  // 20.3.4 logical operations
+  /** @defgroup logical_functors Boolean Operations Classes
+   * @ingroup functors
+   *
+   *  Here are wrapper functors for Boolean operations: @c &&, @c ||,
+   *  and @c !.
+   *
+   *  @{
+   */
+#if __cplusplus > 201103L
+  template<typename _Tp = void>
+    struct logical_and;
+
+  template<typename _Tp = void>
+    struct logical_or;
+
+  template<typename _Tp = void>
+    struct logical_not;
+#endif
+
+  /// One of the @link logical_functors Boolean operations functors@endlink.
+  template<typename _Tp>
+    struct logical_and : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x && __y; }
+    };
+
+  /// One of the @link logical_functors Boolean operations functors@endlink.
+  template<typename _Tp>
+    struct logical_or : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x || __y; }
+    };
+
+  /// One of the @link logical_functors Boolean operations functors@endlink.
+  template<typename _Tp>
+    struct logical_not : public unary_function<_Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x) const
+      { return !__x; }
+    };
+
+#if __cplusplus > 201103L
+  /// One of the @link logical_functors Boolean operations functors@endlink.
+  template<>
+    struct logical_and<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link logical_functors Boolean operations functors@endlink.
+  template<>
+    struct logical_or<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  /// One of the @link logical_functors Boolean operations functors@endlink.
+  template<>
+    struct logical_not<void>
+    {
+      template <typename _Tp>
+	auto
+	operator()(_Tp&& __t) const
+	noexcept(noexcept(!std::forward<_Tp>(__t)))
+	-> decltype(!std::forward<_Tp>(__t))
+	{ return !std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+#endif
+  /** @}  */
+
+#if __cplusplus > 201103L
+  template<typename _Tp = void>
+    struct bit_and;
+
+  template<typename _Tp = void>
+    struct bit_or;
+
+  template<typename _Tp = void>
+    struct bit_xor;
+
+  template<typename _Tp = void>
+    struct bit_not;
+#endif
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 660. Missing Bitwise Operations.
+  template<typename _Tp>
+    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x & __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x | __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x ^ __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_not : public unary_function<_Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x) const
+      { return ~__x; }
+    };
+
+#if __cplusplus > 201103L
+  template <>
+    struct bit_and<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_or<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_xor<void>
+    {
+      template <typename _Tp, typename _Up>
+	auto
+	operator()(_Tp&& __t, _Up&& __u) const
+	noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
+	-> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
+	{ return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_not<void>
+    {
+      template <typename _Tp>
+	auto
+	operator()(_Tp&& __t) const
+	noexcept(noexcept(~std::forward<_Tp>(__t)))
+	-> decltype(~std::forward<_Tp>(__t))
+	{ return ~std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+#endif
+
+  // 20.3.5 negators
+  /** @defgroup negators Negators
+   * @ingroup functors
+   *
+   *  The functions @c not1 and @c not2 each take a predicate functor
+   *  and return an instance of @c unary_negate or
+   *  @c binary_negate, respectively.  These classes are functors whose
+   *  @c operator() performs the stored predicate function and then returns
+   *  the negation of the result.
+   *
+   *  For example, given a vector of integers and a trivial predicate,
+   *  \code
+   *  struct IntGreaterThanThree
+   *    : public std::unary_function<int, bool>
+   *  {
+   *      bool operator() (int x) { return x > 3; }
+   *  };
+   *
+   *  std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
+   *  \endcode
+   *  The call to @c find_if will locate the first index (i) of @c v for which
+   *  <code>!(v[i] > 3)</code> is true.
+   *
+   *  The not1/unary_negate combination works on predicates taking a single
+   *  argument.  The not2/binary_negate combination works on predicates which
+   *  take two arguments.
+   *
+   *  @{
+   */
+  /// One of the @link negators negation functors@endlink.
+  template<typename _Predicate>
+    class unary_negate
+    : public unary_function<typename _Predicate::argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+
+    public:
+      explicit
+      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      bool
+      operator()(const typename _Predicate::argument_type& __x) const
+      { return !_M_pred(__x); }
+    };
+
+  /// One of the @link negators negation functors@endlink.
+  template<typename _Predicate>
+    inline unary_negate<_Predicate>
+    not1(const _Predicate& __pred)
+    { return unary_negate<_Predicate>(__pred); }
+
+  /// One of the @link negators negation functors@endlink.
+  template<typename _Predicate>
+    class binary_negate
+    : public binary_function<typename _Predicate::first_argument_type,
+			     typename _Predicate::second_argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+
+    public:
+      explicit
+      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      bool
+      operator()(const typename _Predicate::first_argument_type& __x,
+		 const typename _Predicate::second_argument_type& __y) const
+      { return !_M_pred(__x, __y); }
+    };
+
+  /// One of the @link negators negation functors@endlink.
+  template<typename _Predicate>
+    inline binary_negate<_Predicate>
+    not2(const _Predicate& __pred)
+    { return binary_negate<_Predicate>(__pred); }
+  /** @}  */
+
+  // 20.3.7 adaptors pointers functions
+  /** @defgroup pointer_adaptors Adaptors for pointers to functions
+   * @ingroup functors
+   *
+   *  The advantage of function objects over pointers to functions is that
+   *  the objects in the standard library declare nested typedefs describing
+   *  their argument and result types with uniform names (e.g., @c result_type
+   *  from the base classes @c unary_function and @c binary_function).
+   *  Sometimes those typedefs are required, not just optional.
+   *
+   *  Adaptors are provided to turn pointers to unary (single-argument) and
+   *  binary (double-argument) functions into function objects.  The
+   *  long-winded functor @c pointer_to_unary_function is constructed with a
+   *  function pointer @c f, and its @c operator() called with argument @c x
+   *  returns @c f(x).  The functor @c pointer_to_binary_function does the same
+   *  thing, but with a double-argument @c f and @c operator().
+   *
+   *  The function @c ptr_fun takes a pointer-to-function @c f and constructs
+   *  an instance of the appropriate functor.
+   *
+   *  @{
+   */
+  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
+  template<typename _Arg, typename _Result>
+    class pointer_to_unary_function : public unary_function<_Arg, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg);
+
+    public:
+      pointer_to_unary_function() { }
+
+      explicit
+      pointer_to_unary_function(_Result (*__x)(_Arg))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg __x) const
+      { return _M_ptr(__x); }
+    };
+
+  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
+  template<typename _Arg, typename _Result>
+    inline pointer_to_unary_function<_Arg, _Result>
+    ptr_fun(_Result (*__x)(_Arg))
+    { return pointer_to_unary_function<_Arg, _Result>(__x); }
+
+  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    class pointer_to_binary_function
+    : public binary_function<_Arg1, _Arg2, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg1, _Arg2);
+
+    public:
+      pointer_to_binary_function() { }
+
+      explicit
+      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg1 __x, _Arg2 __y) const
+      { return _M_ptr(__x, __y); }
+    };
+
+  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
+    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
+    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
+  /** @}  */
+
+  template<typename _Tp>
+    struct _Identity
+    : public unary_function<_Tp,_Tp>
+    {
+      _Tp&
+      operator()(_Tp& __x) const
+      { return __x; }
+
+      const _Tp&
+      operator()(const _Tp& __x) const
+      { return __x; }
+    };
+
+  template<typename _Pair>
+    struct _Select1st
+    : public unary_function<_Pair, typename _Pair::first_type>
+    {
+      typename _Pair::first_type&
+      operator()(_Pair& __x) const
+      { return __x.first; }
+
+      const typename _Pair::first_type&
+      operator()(const _Pair& __x) const
+      { return __x.first; }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair2>
+        typename _Pair2::first_type&
+        operator()(_Pair2& __x) const
+        { return __x.first; }
+
+      template<typename _Pair2>
+        const typename _Pair2::first_type&
+        operator()(const _Pair2& __x) const
+        { return __x.first; }
+#endif
+    };
+
+  template<typename _Pair>
+    struct _Select2nd
+    : public unary_function<_Pair, typename _Pair::second_type>
+    {
+      typename _Pair::second_type&
+      operator()(_Pair& __x) const
+      { return __x.second; }
+
+      const typename _Pair::second_type&
+      operator()(const _Pair& __x) const
+      { return __x.second; }
+    };
+
+  // 20.3.8 adaptors pointers members
+  /** @defgroup memory_adaptors Adaptors for pointers to members
+   * @ingroup functors
+   *
+   *  There are a total of 8 = 2^3 function objects in this family.
+   *   (1) Member functions taking no arguments vs member functions taking
+   *        one argument.
+   *   (2) Call through pointer vs call through reference.
+   *   (3) Const vs non-const member function.
+   *
+   *  All of this complexity is in the function objects themselves.  You can
+   *   ignore it by using the helper function mem_fun and mem_fun_ref,
+   *   which create whichever type of adaptor is appropriate.
+   *
+   *  @{
+   */
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp>
+    class mem_fun_t : public unary_function<_Tp*, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+    };
+
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp>
+    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_ref_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+  };
+
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+  /// One of the @link memory_adaptors adaptors for member
+  /// pointers@endlink.
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+  // Mem_fun adaptor helper functions.  There are only two:
+  // mem_fun and mem_fun_ref.
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)())
+    { return mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)())
+    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+  /** @}  */
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
+# include <backward/binders.h>
+#endif
+
+#endif /* _STL_FUNCTION_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_heap.h b/gcc-4.9/libstdc++-v3/include/bits/stl_heap.h
new file mode 100644
index 0000000..2e1768b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_heap.h
@@ -0,0 +1,532 @@
+// Heap implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_heap.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{queue}
+ */
+
+#ifndef _STL_HEAP_H
+#define _STL_HEAP_H 1
+
+#include <debug/debug.h>
+#include <bits/move.h>
+#include <bits/predefined_ops.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup heap_algorithms Heap
+   * @ingroup sorting_algorithms
+   */
+
+  template<typename _RandomAccessIterator, typename _Distance,
+	   typename _Compare>
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
+		    _Compare __comp)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+	{
+	  if (__comp(__first + __parent, __first + __child))
+	    return __child;
+	  if ((__child & 1) == 0)
+	    ++__parent;
+	}
+      return __n;
+    }
+
+  // __is_heap, a predicate testing whether or not a range is a heap.
+  // This function is an extension, not part of the C++ standard.
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Distance __n)
+    {
+      return std::__is_heap_until(__first, __n,
+			__gnu_cxx::__ops::__iter_less_iter()) == __n;
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare,
+	   typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
+    {
+      return std::__is_heap_until(__first, __n,
+	__gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n;
+    }
+
+  template<typename _RandomAccessIterator>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::__is_heap(__first, std::distance(__first, __last)); }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	      _Compare __comp)
+    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
+
+  // Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap,
+  // + is_heap and is_heap_until in C++0x.
+
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
+	   typename _Compare>
+    void
+    __push_heap(_RandomAccessIterator __first,
+		_Distance __holeIndex, _Distance __topIndex, _Tp __value,
+		_Compare __comp)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
+	{
+	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
+	  __holeIndex = __parent;
+	  __parent = (__holeIndex - 1) / 2;
+	}
+      *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
+    }
+
+  /**
+   *  @brief  Push an element onto a heap.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap + element.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation pushes the element at last-1 onto the valid heap
+   *  over the range [__first,__last-1).  After completion,
+   *  [__first,__last) is a valid heap.
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	  _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	  _DistanceType;
+
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_heap(__first, __last - 1);
+
+      _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+		       _DistanceType(0), _GLIBCXX_MOVE(__value),
+		       __gnu_cxx::__ops::__iter_less_val());
+    }
+
+  /**
+   *  @brief  Push an element onto a heap using comparison functor.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap + element.
+   *  @param  __comp   Comparison functor.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation pushes the element at __last-1 onto the valid
+   *  heap over the range [__first,__last-1).  After completion,
+   *  [__first,__last) is a valid heap.  Compare operations are
+   *  performed using comp.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	      _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	  _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	  _DistanceType;
+
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_heap_pred(__first, __last - 1, __comp);
+
+      _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+		       _DistanceType(0), _GLIBCXX_MOVE(__value),
+		       __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+	   typename _Tp, typename _Compare>
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+		  _Distance __len, _Tp __value, _Compare __comp)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+	{
+	  __secondChild = 2 * (__secondChild + 1);
+	  if (__comp(__first + __secondChild,
+		     __first + (__secondChild - 1)))
+	    __secondChild--;
+	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
+	  __holeIndex = __secondChild;
+	}
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+	{
+	  __secondChild = 2 * (__secondChild + 1);
+	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
+						     + (__secondChild - 1)));
+	  __holeIndex = __secondChild - 1;
+	}
+      std::__push_heap(__first, __holeIndex, __topIndex, 
+		       _GLIBCXX_MOVE(__value),
+		       __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	       _RandomAccessIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
+
+      _ValueType __value = _GLIBCXX_MOVE(*__result);
+      *__result = _GLIBCXX_MOVE(*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+			 _DistanceType(__last - __first),
+			 _GLIBCXX_MOVE(__value), __comp);
+    }
+
+  /**
+   *  @brief  Pop an element off a heap.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap.
+   *  @pre    [__first, __last) is a valid, non-empty range.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation pops the top of the heap.  The elements __first
+   *  and __last-1 are swapped and [__first,__last-1) is made into a
+   *  heap.
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
+      __glibcxx_requires_non_empty_range(__first, __last);
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_heap(__first, __last);
+
+      if (__last - __first > 1)
+	{
+	  --__last;
+	  std::__pop_heap(__first, __last, __last,
+			  __gnu_cxx::__ops::__iter_less_iter());
+	}
+    }
+
+  /**
+   *  @brief  Pop an element off a heap using comparison functor.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap.
+   *  @param  __comp   Comparison functor to use.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation pops the top of the heap.  The elements __first
+   *  and __last-1 are swapped and [__first,__last-1) is made into a
+   *  heap.  Comparisons are made using comp.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+	     _RandomAccessIterator __last, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_non_empty_range(__first, __last);
+      __glibcxx_requires_heap_pred(__first, __last, __comp);
+
+      if (__last - __first > 1)
+	{
+	  --__last;
+	  std::__pop_heap(__first, __last, __last,
+			  __gnu_cxx::__ops::__iter_comp_iter(__comp));
+	}
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+		_Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	  _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	  _DistanceType;
+
+      if (__last - __first < 2)
+	return;
+
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+	{
+	  _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
+	  std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
+			     __comp);
+	  if (__parent == 0)
+	    return;
+	  __parent--;
+	}
+    }
+  
+  /**
+   *  @brief  Construct a heap over a range.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation makes the elements in [__first,__last) into a heap.
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      std::__make_heap(__first, __last,
+		       __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Construct a heap over a range using comparison functor.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap.
+   *  @param  __comp   Comparison functor to use.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation makes the elements in [__first,__last) into a heap.
+   *  Comparisons are made using __comp.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	      _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      std::__make_heap(__first, __last,
+		       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+		_Compare __comp)
+    {
+      while (__last - __first > 1)
+	{
+	  --__last;
+	  std::__pop_heap(__first, __last, __last, __comp);
+	}
+    }
+
+  /**
+   *  @brief  Sort a heap.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation sorts the valid heap in the range [__first,__last).
+  */
+  template<typename _RandomAccessIterator>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_heap(__first, __last);
+
+      std::__sort_heap(__first, __last,
+		       __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Sort a heap using comparison functor.
+   *  @param  __first  Start of heap.
+   *  @param  __last   End of heap.
+   *  @param  __comp   Comparison functor to use.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation sorts the valid heap in the range [__first,__last).
+   *  Comparisons are made using __comp.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	      _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_heap_pred(__first, __last, __comp);
+
+      std::__sort_heap(__first, __last,
+		       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief  Search the end of a heap.
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @return  An iterator pointing to the first element not in the heap.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation returns the last iterator i in [__first, __last) for which
+   *  the range [__first, i) is a heap.
+  */
+  template<typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return __first + 
+	std::__is_heap_until(__first, std::distance(__first, __last),
+			     __gnu_cxx::__ops::__iter_less_iter());
+    }
+
+  /**
+   *  @brief  Search the end of a heap using comparison functor.
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @param  __comp   Comparison functor to use.
+   *  @return  An iterator pointing to the first element not in the heap.
+   *  @ingroup heap_algorithms
+   *
+   *  This operation returns the last iterator i in [__first, __last) for which
+   *  the range [__first, i) is a heap.  Comparisons are made using __comp.
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
+		  _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return __first
+	+ std::__is_heap_until(__first, std::distance(__first, __last),
+			       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  /**
+   *  @brief  Determines whether a range is a heap.
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @return  True if range is a heap, false otherwise.
+   *  @ingroup heap_algorithms
+  */
+  template<typename _RandomAccessIterator>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::is_heap_until(__first, __last) == __last; }
+
+  /**
+   *  @brief  Determines whether a range is a heap using comparison functor.
+   *  @param  __first  Start of range.
+   *  @param  __last   End of range.
+   *  @param  __comp   Comparison functor to use.
+   *  @return  True if range is a heap, false otherwise.
+   *  @ingroup heap_algorithms
+  */
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	    _Compare __comp)
+    { return std::is_heap_until(__first, __last, __comp) == __last; }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _STL_HEAP_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_iterator.h b/gcc-4.9/libstdc++-v3/include/bits/stl_iterator.h
new file mode 100644
index 0000000..1d2a524
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_iterator.h
@@ -0,0 +1,1180 @@
+// Iterators -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_iterator.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ *
+ *  This file implements reverse_iterator, back_insert_iterator,
+ *  front_insert_iterator, insert_iterator, __normal_iterator, and their
+ *  supporting functions and overloaded operators.
+ */
+
+#ifndef _STL_ITERATOR_H
+#define _STL_ITERATOR_H 1
+
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+#include <bits/move.h>
+#include <bits/ptr_traits.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup iterators
+   * @{
+   */
+
+  // 24.4.1 Reverse iterators
+  /**
+   *  Bidirectional and random access iterators have corresponding reverse
+   *  %iterator adaptors that iterate through the data structure in the
+   *  opposite direction.  They have the same signatures as the corresponding
+   *  iterators.  The fundamental relation between a reverse %iterator and its
+   *  corresponding %iterator @c i is established by the identity:
+   *  @code
+   *      &*(reverse_iterator(i)) == &*(i - 1)
+   *  @endcode
+   *
+   *  <em>This mapping is dictated by the fact that while there is always a
+   *  pointer past the end of an array, there might not be a valid pointer
+   *  before the beginning of an array.</em> [24.4.1]/1,2
+   *
+   *  Reverse iterators can be tricky and surprising at first.  Their
+   *  semantics make sense, however, and the trickiness is a side effect of
+   *  the requirement that the iterators must be safe.
+  */
+  template<typename _Iterator>
+    class reverse_iterator
+    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+		      typename iterator_traits<_Iterator>::value_type,
+		      typename iterator_traits<_Iterator>::difference_type,
+		      typename iterator_traits<_Iterator>::pointer,
+                      typename iterator_traits<_Iterator>::reference>
+    {
+    protected:
+      _Iterator current;
+
+      typedef iterator_traits<_Iterator>		__traits_type;
+
+    public:
+      typedef _Iterator					iterator_type;
+      typedef typename __traits_type::difference_type	difference_type;
+      typedef typename __traits_type::pointer		pointer;
+      typedef typename __traits_type::reference		reference;
+
+      /**
+       *  The default constructor value-initializes member @p current.
+       *  If it is a pointer, that means it is zero-initialized.
+      */
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 235 No specification of default ctor for reverse_iterator
+      reverse_iterator() : current() { }
+
+      /**
+       *  This %iterator will move in the opposite direction that @p x does.
+      */
+      explicit
+      reverse_iterator(iterator_type __x) : current(__x) { }
+
+      /**
+       *  The copy constructor is normal.
+      */
+      reverse_iterator(const reverse_iterator& __x)
+      : current(__x.current) { }
+
+      /**
+       *  A %reverse_iterator across other types can be copied if the
+       *  underlying %iterator can be converted to the type of @c current.
+      */
+      template<typename _Iter>
+        reverse_iterator(const reverse_iterator<_Iter>& __x)
+	: current(__x.base()) { }
+
+      /**
+       *  @return  @c current, the %iterator used for underlying work.
+      */
+      iterator_type
+      base() const
+      { return current; }
+
+      /**
+       *  @return  A reference to the value at @c --current
+       *
+       *  This requires that @c --current is dereferenceable.
+       *
+       *  @warning This implementation requires that for an iterator of the
+       *           underlying iterator type, @c x, a reference obtained by
+       *           @c *x remains valid after @c x has been modified or
+       *           destroyed. This is a bug: http://gcc.gnu.org/PR51823
+      */
+      reference
+      operator*() const
+      {
+	_Iterator __tmp = current;
+	return *--__tmp;
+      }
+
+      /**
+       *  @return  A pointer to the value at @c --current
+       *
+       *  This requires that @c --current is dereferenceable.
+      */
+      pointer
+      operator->() const
+      { return &(operator*()); }
+
+      /**
+       *  @return  @c *this
+       *
+       *  Decrements the underlying iterator.
+      */
+      reverse_iterator&
+      operator++()
+      {
+	--current;
+	return *this;
+      }
+
+      /**
+       *  @return  The original value of @c *this
+       *
+       *  Decrements the underlying iterator.
+      */
+      reverse_iterator
+      operator++(int)
+      {
+	reverse_iterator __tmp = *this;
+	--current;
+	return __tmp;
+      }
+
+      /**
+       *  @return  @c *this
+       *
+       *  Increments the underlying iterator.
+      */
+      reverse_iterator&
+      operator--()
+      {
+	++current;
+	return *this;
+      }
+
+      /**
+       *  @return  A reverse_iterator with the previous value of @c *this
+       *
+       *  Increments the underlying iterator.
+      */
+      reverse_iterator
+      operator--(int)
+      {
+	reverse_iterator __tmp = *this;
+	++current;
+	return __tmp;
+      }
+
+      /**
+       *  @return  A reverse_iterator that refers to @c current - @a __n
+       *
+       *  The underlying iterator must be a Random Access Iterator.
+      */
+      reverse_iterator
+      operator+(difference_type __n) const
+      { return reverse_iterator(current - __n); }
+
+      /**
+       *  @return  *this
+       *
+       *  Moves the underlying iterator backwards @a __n steps.
+       *  The underlying iterator must be a Random Access Iterator.
+      */
+      reverse_iterator&
+      operator+=(difference_type __n)
+      {
+	current -= __n;
+	return *this;
+      }
+
+      /**
+       *  @return  A reverse_iterator that refers to @c current - @a __n
+       *
+       *  The underlying iterator must be a Random Access Iterator.
+      */
+      reverse_iterator
+      operator-(difference_type __n) const
+      { return reverse_iterator(current + __n); }
+
+      /**
+       *  @return  *this
+       *
+       *  Moves the underlying iterator forwards @a __n steps.
+       *  The underlying iterator must be a Random Access Iterator.
+      */
+      reverse_iterator&
+      operator-=(difference_type __n)
+      {
+	current += __n;
+	return *this;
+      }
+
+      /**
+       *  @return  The value at @c current - @a __n - 1
+       *
+       *  The underlying iterator must be a Random Access Iterator.
+      */
+      reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+    };
+
+  //@{
+  /**
+   *  @param  __x  A %reverse_iterator.
+   *  @param  __y  A %reverse_iterator.
+   *  @return  A simple bool.
+   *
+   *  Reverse iterators forward many operations to their underlying base()
+   *  iterators.  Others are implemented in terms of one another.
+   *
+  */
+  template<typename _Iterator>
+    inline bool
+    operator==(const reverse_iterator<_Iterator>& __x,
+	       const reverse_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<(const reverse_iterator<_Iterator>& __x,
+	      const reverse_iterator<_Iterator>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator!=(const reverse_iterator<_Iterator>& __x,
+	       const reverse_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>(const reverse_iterator<_Iterator>& __x,
+	      const reverse_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline bool
+    operator<=(const reverse_iterator<_Iterator>& __x,
+	       const reverse_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>=(const reverse_iterator<_Iterator>& __x,
+	       const reverse_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Iterator>
+    inline typename reverse_iterator<_Iterator>::difference_type
+    operator-(const reverse_iterator<_Iterator>& __x,
+	      const reverse_iterator<_Iterator>& __y)
+    { return __y.base() - __x.base(); }
+
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
+	      const reverse_iterator<_Iterator>& __x)
+    { return reverse_iterator<_Iterator>(__x.base() - __n); }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 280. Comparison of reverse_iterator to const reverse_iterator.
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator==(const reverse_iterator<_IteratorL>& __x,
+	       const reverse_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<(const reverse_iterator<_IteratorL>& __x,
+	      const reverse_iterator<_IteratorR>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator!=(const reverse_iterator<_IteratorL>& __x,
+	       const reverse_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>(const reverse_iterator<_IteratorL>& __x,
+	      const reverse_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<=(const reverse_iterator<_IteratorL>& __x,
+	       const reverse_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>=(const reverse_iterator<_IteratorL>& __x,
+	       const reverse_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+#if __cplusplus >= 201103L
+    // DR 685.
+    inline auto
+    operator-(const reverse_iterator<_IteratorL>& __x,
+	      const reverse_iterator<_IteratorR>& __y)
+    -> decltype(__y.base() - __x.base())
+#else
+    inline typename reverse_iterator<_IteratorL>::difference_type
+    operator-(const reverse_iterator<_IteratorL>& __x,
+	      const reverse_iterator<_IteratorR>& __y)
+#endif
+    { return __y.base() - __x.base(); }
+  //@}
+
+  // 24.4.2.2.1 back_insert_iterator
+  /**
+   *  @brief  Turns assignment into insertion.
+   *
+   *  These are output iterators, constructed from a container-of-T.
+   *  Assigning a T to the iterator appends it to the container using
+   *  push_back.
+   *
+   *  Tip:  Using the back_inserter function to create these iterators can
+   *  save typing.
+  */
+  template<typename _Container>
+    class back_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+
+    public:
+      /// A nested typedef for the type of whatever container you used.
+      typedef _Container          container_type;
+
+      /// The only way to create this %iterator is with a container.
+      explicit
+      back_insert_iterator(_Container& __x) : container(&__x) { }
+
+      /**
+       *  @param  __value  An instance of whatever type
+       *                 container_type::const_reference is; presumably a
+       *                 reference-to-const T for container<T>.
+       *  @return  This %iterator, for chained operations.
+       *
+       *  This kind of %iterator doesn't really have a @a position in the
+       *  container (you can think of the position as being permanently at
+       *  the end, if you like).  Assigning a value to the %iterator will
+       *  always append the value to the end of the container.
+      */
+#if __cplusplus < 201103L
+      back_insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+	container->push_back(__value);
+	return *this;
+      }
+#else
+      back_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+	container->push_back(__value);
+	return *this;
+      }
+
+      back_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+	container->push_back(std::move(__value));
+	return *this;
+      }
+#endif
+
+      /// Simply returns *this.
+      back_insert_iterator&
+      operator*()
+      { return *this; }
+
+      /// Simply returns *this.  (This %iterator does not @a move.)
+      back_insert_iterator&
+      operator++()
+      { return *this; }
+
+      /// Simply returns *this.  (This %iterator does not @a move.)
+      back_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+
+  /**
+   *  @param  __x  A container of arbitrary type.
+   *  @return  An instance of back_insert_iterator working on @p __x.
+   *
+   *  This wrapper function helps in creating back_insert_iterator instances.
+   *  Typing the name of the %iterator requires knowing the precise full
+   *  type of the container, which can be tedious and impedes generic
+   *  programming.  Using this function lets you take advantage of automatic
+   *  template parameter deduction, making the compiler match the correct
+   *  types for you.
+  */
+  template<typename _Container>
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+
+  /**
+   *  @brief  Turns assignment into insertion.
+   *
+   *  These are output iterators, constructed from a container-of-T.
+   *  Assigning a T to the iterator prepends it to the container using
+   *  push_front.
+   *
+   *  Tip:  Using the front_inserter function to create these iterators can
+   *  save typing.
+  */
+  template<typename _Container>
+    class front_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+
+    public:
+      /// A nested typedef for the type of whatever container you used.
+      typedef _Container          container_type;
+
+      /// The only way to create this %iterator is with a container.
+      explicit front_insert_iterator(_Container& __x) : container(&__x) { }
+
+      /**
+       *  @param  __value  An instance of whatever type
+       *                 container_type::const_reference is; presumably a
+       *                 reference-to-const T for container<T>.
+       *  @return  This %iterator, for chained operations.
+       *
+       *  This kind of %iterator doesn't really have a @a position in the
+       *  container (you can think of the position as being permanently at
+       *  the front, if you like).  Assigning a value to the %iterator will
+       *  always prepend the value to the front of the container.
+      */
+#if __cplusplus < 201103L
+      front_insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+	container->push_front(__value);
+	return *this;
+      }
+#else
+      front_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+	container->push_front(__value);
+	return *this;
+      }
+
+      front_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+	container->push_front(std::move(__value));
+	return *this;
+      }
+#endif
+
+      /// Simply returns *this.
+      front_insert_iterator&
+      operator*()
+      { return *this; }
+
+      /// Simply returns *this.  (This %iterator does not @a move.)
+      front_insert_iterator&
+      operator++()
+      { return *this; }
+
+      /// Simply returns *this.  (This %iterator does not @a move.)
+      front_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+
+  /**
+   *  @param  __x  A container of arbitrary type.
+   *  @return  An instance of front_insert_iterator working on @p x.
+   *
+   *  This wrapper function helps in creating front_insert_iterator instances.
+   *  Typing the name of the %iterator requires knowing the precise full
+   *  type of the container, which can be tedious and impedes generic
+   *  programming.  Using this function lets you take advantage of automatic
+   *  template parameter deduction, making the compiler match the correct
+   *  types for you.
+  */
+  template<typename _Container>
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+
+  /**
+   *  @brief  Turns assignment into insertion.
+   *
+   *  These are output iterators, constructed from a container-of-T.
+   *  Assigning a T to the iterator inserts it in the container at the
+   *  %iterator's position, rather than overwriting the value at that
+   *  position.
+   *
+   *  (Sequences will actually insert a @e copy of the value before the
+   *  %iterator's position.)
+   *
+   *  Tip:  Using the inserter function to create these iterators can
+   *  save typing.
+  */
+  template<typename _Container>
+    class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+      typename _Container::iterator iter;
+
+    public:
+      /// A nested typedef for the type of whatever container you used.
+      typedef _Container          container_type;
+
+      /**
+       *  The only way to create this %iterator is with a container and an
+       *  initial position (a normal %iterator into the container).
+      */
+      insert_iterator(_Container& __x, typename _Container::iterator __i)
+      : container(&__x), iter(__i) {}
+
+      /**
+       *  @param  __value  An instance of whatever type
+       *                 container_type::const_reference is; presumably a
+       *                 reference-to-const T for container<T>.
+       *  @return  This %iterator, for chained operations.
+       *
+       *  This kind of %iterator maintains its own position in the
+       *  container.  Assigning a value to the %iterator will insert the
+       *  value into the container at the place before the %iterator.
+       *
+       *  The position is maintained such that subsequent assignments will
+       *  insert values immediately after one another.  For example,
+       *  @code
+       *     // vector v contains A and Z
+       *
+       *     insert_iterator i (v, ++v.begin());
+       *     i = 1;
+       *     i = 2;
+       *     i = 3;
+       *
+       *     // vector v contains A, 1, 2, 3, and Z
+       *  @endcode
+      */
+#if __cplusplus < 201103L
+      insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+	iter = container->insert(iter, __value);
+	++iter;
+	return *this;
+      }
+#else
+      insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+	iter = container->insert(iter, __value);
+	++iter;
+	return *this;
+      }
+
+      insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+	iter = container->insert(iter, std::move(__value));
+	++iter;
+	return *this;
+      }
+#endif
+
+      /// Simply returns *this.
+      insert_iterator&
+      operator*()
+      { return *this; }
+
+      /// Simply returns *this.  (This %iterator does not @a move.)
+      insert_iterator&
+      operator++()
+      { return *this; }
+
+      /// Simply returns *this.  (This %iterator does not @a move.)
+      insert_iterator&
+      operator++(int)
+      { return *this; }
+    };
+
+  /**
+   *  @param __x  A container of arbitrary type.
+   *  @return  An instance of insert_iterator working on @p __x.
+   *
+   *  This wrapper function helps in creating insert_iterator instances.
+   *  Typing the name of the %iterator requires knowing the precise full
+   *  type of the container, which can be tedious and impedes generic
+   *  programming.  Using this function lets you take advantage of automatic
+   *  template parameter deduction, making the compiler match the correct
+   *  types for you.
+  */
+  template<typename _Container, typename _Iterator>
+    inline insert_iterator<_Container>
+    inserter(_Container& __x, _Iterator __i)
+    {
+      return insert_iterator<_Container>(__x,
+					 typename _Container::iterator(__i));
+    }
+
+  // @} group iterators
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // This iterator adapter is @a normal in the sense that it does not
+  // change the semantics of any of the operators of its iterator
+  // parameter.  Its primary purpose is to convert an iterator that is
+  // not a class, e.g. a pointer, into an iterator that is a class.
+  // The _Container parameter exists solely so that different containers
+  // using this template can instantiate different types, even if the
+  // _Iterator parameter is the same.
+  using std::iterator_traits;
+  using std::iterator;
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+    {
+    protected:
+      _Iterator _M_current;
+
+      typedef iterator_traits<_Iterator>		__traits_type;
+
+    public:
+      typedef _Iterator					iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type  	value_type;
+      typedef typename __traits_type::difference_type 	difference_type;
+      typedef typename __traits_type::reference 	reference;
+      typedef typename __traits_type::pointer   	pointer;
+
+      _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
+      : _M_current(_Iterator()) { }
+
+      explicit
+      __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
+      : _M_current(__i) { }
+
+      // Allow iterator to const_iterator conversion
+      template<typename _Iter>
+        __normal_iterator(const __normal_iterator<_Iter,
+			  typename __enable_if<
+      	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
+		      _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
+        : _M_current(__i.base()) { }
+
+#if __cplusplus >= 201103L
+      __normal_iterator<typename _Container::pointer, _Container>
+      _M_const_cast() const noexcept
+      {
+	using _PTraits = std::pointer_traits<typename _Container::pointer>;
+	return __normal_iterator<typename _Container::pointer, _Container>
+	  (_PTraits::pointer_to(const_cast<typename _PTraits::element_type&>
+				(*_M_current)));
+      }
+#else
+      __normal_iterator
+      _M_const_cast() const
+      { return *this; }
+#endif
+
+      // Forward iterator requirements
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      { return *_M_current; }
+
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT
+      { return _M_current; }
+
+      __normal_iterator&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	++_M_current;
+	return *this;
+      }
+
+      __normal_iterator
+      operator++(int) _GLIBCXX_NOEXCEPT
+      { return __normal_iterator(_M_current++); }
+
+      // Bidirectional iterator requirements
+      __normal_iterator&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	--_M_current;
+	return *this;
+      }
+
+      __normal_iterator
+      operator--(int) _GLIBCXX_NOEXCEPT
+      { return __normal_iterator(_M_current--); }
+
+      // Random access iterator requirements
+      reference
+      operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
+      { return _M_current[__n]; }
+
+      __normal_iterator&
+      operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
+      { _M_current += __n; return *this; }
+
+      __normal_iterator
+      operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
+      { return __normal_iterator(_M_current + __n); }
+
+      __normal_iterator&
+      operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
+      { _M_current -= __n; return *this; }
+
+      __normal_iterator
+      operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
+      { return __normal_iterator(_M_current - __n); }
+
+      const _Iterator&
+      base() const _GLIBCXX_NOEXCEPT
+      { return _M_current; }
+    };
+
+  // Note: In what follows, the left- and right-hand-side iterators are
+  // allowed to vary in types (conceptually in cv-qualification) so that
+  // comparison between cv-qualified and non-cv-qualified iterators be
+  // valid.  However, the greedy and unfriendly operators in std::rel_ops
+  // will make overload resolution ambiguous (when in scope) if we don't
+  // provide overloads whose operands are of the same type.  Can someone
+  // remind me what generic programming is about? -- Gaby
+
+  // Forward iterator requirements
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
+	       const __normal_iterator<_Iterator, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() != __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
+	       const __normal_iterator<_Iterator, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() != __rhs.base(); }
+
+  // Random access iterator requirements
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	      const __normal_iterator<_IteratorR, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
+	      const __normal_iterator<_Iterator, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	      const __normal_iterator<_IteratorR, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
+	      const __normal_iterator<_Iterator, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
+	       const __normal_iterator<_Iterator, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() >= __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
+	       const __normal_iterator<_Iterator, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() >= __rhs.base(); }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // According to the resolution of DR179 not only the various comparison
+  // operators but also operator- must accept mixed iterator/const_iterator
+  // parameters.
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+#if __cplusplus >= 201103L
+    // DR 685.
+    inline auto
+    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	      const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
+    -> decltype(__lhs.base() - __rhs.base())
+#else
+    inline typename __normal_iterator<_IteratorL, _Container>::difference_type
+    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	      const __normal_iterator<_IteratorR, _Container>& __rhs)
+#endif
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline typename __normal_iterator<_Iterator, _Container>::difference_type
+    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
+	      const __normal_iterator<_Iterator, _Container>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline __normal_iterator<_Iterator, _Container>
+    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
+	      __n, const __normal_iterator<_Iterator, _Container>& __i)
+    _GLIBCXX_NOEXCEPT
+    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if __cplusplus >= 201103L
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup iterators
+   * @{
+   */
+
+  // 24.4.3  Move iterators
+  /**
+   *  Class template move_iterator is an iterator adapter with the same
+   *  behavior as the underlying iterator except that its dereference
+   *  operator implicitly converts the value returned by the underlying
+   *  iterator's dereference operator to an rvalue reference.  Some
+   *  generic algorithms can be called with move iterators to replace
+   *  copying with moving.
+   */
+  template<typename _Iterator>
+    class move_iterator
+    {
+    protected:
+      _Iterator _M_current;
+
+      typedef iterator_traits<_Iterator>		__traits_type;
+
+    public:
+      typedef _Iterator					iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type  	value_type;
+      typedef typename __traits_type::difference_type	difference_type;
+      // NB: DR 680.
+      typedef _Iterator					pointer;
+      typedef value_type&&				reference;
+
+      move_iterator()
+      : _M_current() { }
+
+      explicit
+      move_iterator(iterator_type __i)
+      : _M_current(__i) { }
+
+      template<typename _Iter>
+	move_iterator(const move_iterator<_Iter>& __i)
+	: _M_current(__i.base()) { }
+
+      iterator_type
+      base() const
+      { return _M_current; }
+
+      reference
+      operator*() const
+      { return std::move(*_M_current); }
+
+      pointer
+      operator->() const
+      { return _M_current; }
+
+      move_iterator&
+      operator++()
+      {
+	++_M_current;
+	return *this;
+      }
+
+      move_iterator
+      operator++(int)
+      {
+	move_iterator __tmp = *this;
+	++_M_current;
+	return __tmp;
+      }
+
+      move_iterator&
+      operator--()
+      {
+	--_M_current;
+	return *this;
+      }
+
+      move_iterator
+      operator--(int)
+      {
+	move_iterator __tmp = *this;
+	--_M_current;
+	return __tmp;
+      }
+
+      move_iterator
+      operator+(difference_type __n) const
+      { return move_iterator(_M_current + __n); }
+
+      move_iterator&
+      operator+=(difference_type __n)
+      {
+	_M_current += __n;
+	return *this;
+      }
+
+      move_iterator
+      operator-(difference_type __n) const
+      { return move_iterator(_M_current - __n); }
+    
+      move_iterator&
+      operator-=(difference_type __n)
+      { 
+	_M_current -= __n;
+	return *this;
+      }
+
+      reference
+      operator[](difference_type __n) const
+      { return std::move(_M_current[__n]); }
+    };
+
+  // Note: See __normal_iterator operators note from Gaby to understand
+  // why there are always 2 versions for most of the move_iterator
+  // operators.
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator==(const move_iterator<_IteratorL>& __x,
+	       const move_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator==(const move_iterator<_Iterator>& __x,
+	       const move_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator!=(const move_iterator<_IteratorL>& __x,
+	       const move_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator!=(const move_iterator<_Iterator>& __x,
+	       const move_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<(const move_iterator<_IteratorL>& __x,
+	      const move_iterator<_IteratorR>& __y)
+    { return __x.base() < __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<(const move_iterator<_Iterator>& __x,
+	      const move_iterator<_Iterator>& __y)
+    { return __x.base() < __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<=(const move_iterator<_IteratorL>& __x,
+	       const move_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<=(const move_iterator<_Iterator>& __x,
+	       const move_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>(const move_iterator<_IteratorL>& __x,
+	      const move_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline bool
+    operator>(const move_iterator<_Iterator>& __x,
+	      const move_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>=(const move_iterator<_IteratorL>& __x,
+	       const move_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>=(const move_iterator<_Iterator>& __x,
+	       const move_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+  // DR 685.
+  template<typename _IteratorL, typename _IteratorR>
+    inline auto
+    operator-(const move_iterator<_IteratorL>& __x,
+	      const move_iterator<_IteratorR>& __y)
+    -> decltype(__x.base() - __y.base())
+    { return __x.base() - __y.base(); }
+
+  template<typename _Iterator>
+    inline auto
+    operator-(const move_iterator<_Iterator>& __x,
+	      const move_iterator<_Iterator>& __y)
+    -> decltype(__x.base() - __y.base())
+    { return __x.base() - __y.base(); }
+
+  template<typename _Iterator>
+    inline move_iterator<_Iterator>
+    operator+(typename move_iterator<_Iterator>::difference_type __n,
+	      const move_iterator<_Iterator>& __x)
+    { return __x + __n; }
+
+  template<typename _Iterator>
+    inline move_iterator<_Iterator>
+    make_move_iterator(_Iterator __i)
+    { return move_iterator<_Iterator>(__i); }
+
+  template<typename _Iterator, typename _ReturnType
+    = typename conditional<__move_if_noexcept_cond
+      <typename iterator_traits<_Iterator>::value_type>::value,
+                _Iterator, move_iterator<_Iterator>>::type>
+    inline _ReturnType
+    __make_move_if_noexcept_iterator(_Iterator __i)
+    { return _ReturnType(__i); }
+
+  // @} group iterators
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
+#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
+  std::__make_move_if_noexcept_iterator(_Iter)
+#else
+#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
+#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_iterator_base_funcs.h b/gcc-4.9/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
new file mode 100644
index 0000000..6183a25
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
@@ -0,0 +1,205 @@
+// Functions used by iterators -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_iterator_base_funcs.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ *
+ *  This file contains all of the general iterator-related utility
+ *  functions, such as distance() and advance().
+ */
+
+#ifndef _STL_ITERATOR_BASE_FUNCS_H
+#define _STL_ITERATOR_BASE_FUNCS_H 1
+
+#pragma GCC system_header
+
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    __distance(_InputIterator __first, _InputIterator __last,
+               input_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      while (__first != __last)
+	{
+	  ++__first;
+	  ++__n;
+	}
+      return __n;
+    }
+
+  template<typename _RandomAccessIterator>
+    inline typename iterator_traits<_RandomAccessIterator>::difference_type
+    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               random_access_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      return __last - __first;
+    }
+
+  /**
+   *  @brief A generalization of pointer arithmetic.
+   *  @param  __first  An input iterator.
+   *  @param  __last  An input iterator.
+   *  @return  The distance between them.
+   *
+   *  Returns @c n such that __first + n == __last.  This requires
+   *  that @p __last must be reachable from @p __first.  Note that @c
+   *  n may be negative.
+   *
+   *  For random access iterators, this uses their @c + and @c - operations
+   *  and are constant time.  For other %iterator classes they are linear time.
+  */
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    distance(_InputIterator __first, _InputIterator __last)
+    {
+      // concept requirements -- taken care of in __distance
+      return std::__distance(__first, __last,
+			     std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      _GLIBCXX_DEBUG_ASSERT(__n >= 0);
+      while (__n--)
+	++__i;
+    }
+
+  template<typename _BidirectionalIterator, typename _Distance>
+    inline void
+    __advance(_BidirectionalIterator& __i, _Distance __n,
+	      bidirectional_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
+      if (__n > 0)
+        while (__n--)
+	  ++__i;
+      else
+        while (__n++)
+	  --__i;
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline void
+    __advance(_RandomAccessIterator& __i, _Distance __n,
+              random_access_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __i += __n;
+    }
+
+  /**
+   *  @brief A generalization of pointer arithmetic.
+   *  @param  __i  An input iterator.
+   *  @param  __n  The @a delta by which to change @p __i.
+   *  @return  Nothing.
+   *
+   *  This increments @p i by @p n.  For bidirectional and random access
+   *  iterators, @p __n may be negative, in which case @p __i is decremented.
+   *
+   *  For random access iterators, this uses their @c + and @c - operations
+   *  and are constant time.  For other %iterator classes they are linear time.
+  */
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    advance(_InputIterator& __i, _Distance __n)
+    {
+      // concept requirements -- taken care of in __advance
+      typename iterator_traits<_InputIterator>::difference_type __d = __n;
+      std::__advance(__i, __d, std::__iterator_category(__i));
+    }
+
+#if __cplusplus >= 201103L
+
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    next(_ForwardIterator __x, typename
+	 iterator_traits<_ForwardIterator>::difference_type __n = 1)
+    {
+      std::advance(__x, __n);
+      return __x;
+    }
+
+  template<typename _BidirectionalIterator>
+    inline _BidirectionalIterator
+    prev(_BidirectionalIterator __x, typename
+	 iterator_traits<_BidirectionalIterator>::difference_type __n = 1) 
+    {
+      std::advance(__x, -__n);
+      return __x;
+    }
+
+#endif // C++11
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _STL_ITERATOR_BASE_FUNCS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_iterator_base_types.h b/gcc-4.9/libstdc++-v3/include/bits/stl_iterator_base_types.h
new file mode 100644
index 0000000..bd55987
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_iterator_base_types.h
@@ -0,0 +1,236 @@
+// Types used in iterator implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_iterator_base_types.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ *
+ *  This file contains all of the general iterator-related utility types,
+ *  such as iterator_traits and struct iterator.
+ */
+
+#ifndef _STL_ITERATOR_BASE_TYPES_H
+#define _STL_ITERATOR_BASE_TYPES_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if __cplusplus >= 201103L
+# include <type_traits>  // For _GLIBCXX_HAS_NESTED_TYPE, is_convertible
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @defgroup iterators Iterators
+   *  Abstractions for uniform iterating through various underlying types.
+  */
+  //@{ 
+
+  /**
+   *  @defgroup iterator_tags Iterator Tags
+   *  These are empty types, used to distinguish different iterators.  The
+   *  distinction is not made by what they contain, but simply by what they
+   *  are.  Different underlying algorithms can then be used based on the
+   *  different operations supported by different iterator types.
+  */
+  //@{ 
+  ///  Marking input iterators.
+  struct input_iterator_tag { };
+
+  ///  Marking output iterators.
+  struct output_iterator_tag { };
+
+  /// Forward iterators support a superset of input iterator operations.
+  struct forward_iterator_tag : public input_iterator_tag { };
+
+  /// Bidirectional iterators support a superset of forward iterator
+  /// operations.
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+
+  /// Random-access iterators support a superset of bidirectional
+  /// iterator operations.
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+  //@}
+
+  /**
+   *  @brief  Common %iterator class.
+   *
+   *  This class does nothing but define nested typedefs.  %Iterator classes
+   *  can inherit from this class to save some work.  The typedefs are then
+   *  used in specializations and overloading.
+   *
+   *  In particular, there are no default implementations of requirements
+   *  such as @c operator++ and the like.  (How could there be?)
+  */
+  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
+           typename _Pointer = _Tp*, typename _Reference = _Tp&>
+    struct iterator
+    {
+      /// One of the @link iterator_tags tag types@endlink.
+      typedef _Category  iterator_category;
+      /// The type "pointed to" by the iterator.
+      typedef _Tp        value_type;
+      /// Distance between iterators is represented as this type.
+      typedef _Distance  difference_type;
+      /// This type represents a pointer-to-value_type.
+      typedef _Pointer   pointer;
+      /// This type represents a reference-to-value_type.
+      typedef _Reference reference;
+    };
+
+  /**
+   *  @brief  Traits class for iterators.
+   *
+   *  This class does nothing but define nested typedefs.  The general
+   *  version simply @a forwards the nested typedefs from the Iterator
+   *  argument.  Specialized versions for pointers and pointers-to-const
+   *  provide tighter, more correct semantics.
+  */
+#if __cplusplus >= 201103L
+
+_GLIBCXX_HAS_NESTED_TYPE(iterator_category)
+
+  template<typename _Iterator,
+	   bool = __has_iterator_category<_Iterator>::value>
+    struct __iterator_traits { };
+
+  template<typename _Iterator>
+    struct __iterator_traits<_Iterator, true>
+    {
+      typedef typename _Iterator::iterator_category iterator_category;
+      typedef typename _Iterator::value_type        value_type;
+      typedef typename _Iterator::difference_type   difference_type;
+      typedef typename _Iterator::pointer           pointer;
+      typedef typename _Iterator::reference         reference;
+    };
+
+  template<typename _Iterator>
+    struct iterator_traits
+    : public __iterator_traits<_Iterator> { };
+#else
+  template<typename _Iterator>
+    struct iterator_traits
+    {
+      typedef typename _Iterator::iterator_category iterator_category;
+      typedef typename _Iterator::value_type        value_type;
+      typedef typename _Iterator::difference_type   difference_type;
+      typedef typename _Iterator::pointer           pointer;
+      typedef typename _Iterator::reference         reference;
+    };
+#endif
+
+  /// Partial specialization for pointer types.
+  template<typename _Tp>
+    struct iterator_traits<_Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp                         value_type;
+      typedef ptrdiff_t                   difference_type;
+      typedef _Tp*                        pointer;
+      typedef _Tp&                        reference;
+    };
+
+  /// Partial specialization for const pointer types.
+  template<typename _Tp>
+    struct iterator_traits<const _Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp                         value_type;
+      typedef ptrdiff_t                   difference_type;
+      typedef const _Tp*                  pointer;
+      typedef const _Tp&                  reference;
+    };
+
+  /**
+   *  This function is not a part of the C++ standard but is syntactic
+   *  sugar for internal library use only.
+  */
+  template<typename _Iter>
+    inline typename iterator_traits<_Iter>::iterator_category
+    __iterator_category(const _Iter&)
+    { return typename iterator_traits<_Iter>::iterator_category(); }
+
+  //@}
+
+  // If _Iterator has a base returns it otherwise _Iterator is returned
+  // untouched
+  template<typename _Iterator, bool _HasBase>
+    struct _Iter_base
+    {
+      typedef _Iterator iterator_type;
+      static iterator_type _S_base(_Iterator __it)
+      { return __it; }
+    };
+
+  template<typename _Iterator>
+    struct _Iter_base<_Iterator, true>
+    {
+      typedef typename _Iterator::iterator_type iterator_type;
+      static iterator_type _S_base(_Iterator __it)
+      { return __it.base(); }
+    };
+
+#if __cplusplus >= 201103L
+  template<typename _InIter>
+    using _RequireInputIter = typename
+      enable_if<is_convertible<typename
+		iterator_traits<_InIter>::iterator_category,
+			       input_iterator_tag>::value>::type;
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _STL_ITERATOR_BASE_TYPES_H */
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_list.h b/gcc-4.9/libstdc++-v3/include/bits/stl_list.h
new file mode 100644
index 0000000..e014fbc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_list.h
@@ -0,0 +1,1795 @@
+// List implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_list.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{list}
+ */
+
+#ifndef _STL_LIST_H
+#define _STL_LIST_H 1
+
+#include <bits/concept_check.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    // Supporting structures are split into common and templated
+    // types; the latter publicly inherits from the former in an
+    // effort to reduce code duplication.  This results in some
+    // "needless" static_cast'ing later on, but it's all safe
+    // downcasting.
+
+    /// Common part of a node in the %list. 
+    struct _List_node_base
+    {
+      _List_node_base* _M_next;
+      _List_node_base* _M_prev;
+
+      static void
+      swap(_List_node_base& __x, _List_node_base& __y) _GLIBCXX_USE_NOEXCEPT;
+
+      void
+      _M_transfer(_List_node_base* const __first,
+		  _List_node_base* const __last) _GLIBCXX_USE_NOEXCEPT;
+
+      void
+      _M_reverse() _GLIBCXX_USE_NOEXCEPT;
+
+      void
+      _M_hook(_List_node_base* const __position) _GLIBCXX_USE_NOEXCEPT;
+
+      void
+      _M_unhook() _GLIBCXX_USE_NOEXCEPT;
+    };
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace detail
+
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /// An actual node in the %list.
+  template<typename _Tp>
+    struct _List_node : public __detail::_List_node_base
+    {
+      ///< User's data.
+      _Tp _M_data;
+
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+        _List_node(_Args&&... __args)
+	: __detail::_List_node_base(), _M_data(std::forward<_Args>(__args)...) 
+        { }
+#endif
+    };
+
+  /**
+   *  @brief A list::iterator.
+   *
+   *  All the functions are op overloads.
+  */
+  template<typename _Tp>
+    struct _List_iterator
+    {
+      typedef _List_iterator<_Tp>                _Self;
+      typedef _List_node<_Tp>                    _Node;
+
+      typedef ptrdiff_t                          difference_type;
+      typedef std::bidirectional_iterator_tag    iterator_category;
+      typedef _Tp                                value_type;
+      typedef _Tp*                               pointer;
+      typedef _Tp&                               reference;
+
+      _List_iterator() _GLIBCXX_NOEXCEPT
+      : _M_node() { }
+
+      explicit
+      _List_iterator(__detail::_List_node_base* __x) _GLIBCXX_NOEXCEPT
+      : _M_node(__x) { }
+
+      _Self
+      _M_const_cast() const _GLIBCXX_NOEXCEPT
+      { return *this; }
+
+      // Must downcast from _List_node_base to _List_node to get to _M_data.
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
+
+      _Self&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _M_node->_M_next;
+	return *this;
+      }
+
+      _Self
+      operator++(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _M_node->_M_next;
+	return __tmp;
+      }
+
+      _Self&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _M_node->_M_prev;
+	return *this;
+      }
+
+      _Self
+      operator--(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _M_node->_M_prev;
+	return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node != __x._M_node; }
+
+      // The only member points to the %list element.
+      __detail::_List_node_base* _M_node;
+    };
+
+  /**
+   *  @brief A list::const_iterator.
+   *
+   *  All the functions are op overloads.
+  */
+  template<typename _Tp>
+    struct _List_const_iterator
+    {
+      typedef _List_const_iterator<_Tp>          _Self;
+      typedef const _List_node<_Tp>              _Node;
+      typedef _List_iterator<_Tp>                iterator;
+
+      typedef ptrdiff_t                          difference_type;
+      typedef std::bidirectional_iterator_tag    iterator_category;
+      typedef _Tp                                value_type;
+      typedef const _Tp*                         pointer;
+      typedef const _Tp&                         reference;
+
+      _List_const_iterator() _GLIBCXX_NOEXCEPT
+      : _M_node() { }
+
+      explicit
+      _List_const_iterator(const __detail::_List_node_base* __x)
+      _GLIBCXX_NOEXCEPT
+      : _M_node(__x) { }
+
+      _List_const_iterator(const iterator& __x) _GLIBCXX_NOEXCEPT
+      : _M_node(__x._M_node) { }
+
+      iterator
+      _M_const_cast() const _GLIBCXX_NOEXCEPT
+      { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); }
+
+      // Must downcast from List_node_base to _List_node to get to
+      // _M_data.
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
+
+      _Self&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _M_node->_M_next;
+	return *this;
+      }
+
+      _Self
+      operator++(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _M_node->_M_next;
+	return __tmp;
+      }
+
+      _Self&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _M_node->_M_prev;
+	return *this;
+      }
+
+      _Self
+      operator--(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _M_node->_M_prev;
+	return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node != __x._M_node; }
+
+      // The only member points to the %list element.
+      const __detail::_List_node_base* _M_node;
+    };
+
+  template<typename _Val>
+    inline bool
+    operator==(const _List_iterator<_Val>& __x,
+	       const _List_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT
+    { return __x._M_node == __y._M_node; }
+
+  template<typename _Val>
+    inline bool
+    operator!=(const _List_iterator<_Val>& __x,
+               const _List_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT
+    { return __x._M_node != __y._M_node; }
+
+
+  /// See bits/stl_deque.h's _Deque_base for an explanation.
+  template<typename _Tp, typename _Alloc>
+    class _List_base
+    {
+    protected:
+      // NOTA BENE
+      // The stored instance is not actually of "allocator_type"'s
+      // type.  Instead we rebind the type to
+      // Allocator<List_node<Tp>>, which according to [20.1.5]/4
+      // should probably be the same.  List_node<Tp> is not the same
+      // size as Tp (it's two pointers larger), and specializations on
+      // Tp may go unused because List_node<Tp> is being bound
+      // instead.
+      //
+      // We put this to the test in the constructors and in
+      // get_allocator, where we use conversions between
+      // allocator_type and _Node_alloc_type. The conversion is
+      // required by table 32 in [20.1.5].
+      typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
+        _Node_alloc_type;
+
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+
+      struct _List_impl
+      : public _Node_alloc_type
+      {
+	__detail::_List_node_base _M_node;
+
+	_List_impl()
+	: _Node_alloc_type(), _M_node()
+	{ }
+
+	_List_impl(const _Node_alloc_type& __a) _GLIBCXX_NOEXCEPT
+	: _Node_alloc_type(__a), _M_node()
+	{ }
+
+#if __cplusplus >= 201103L
+	_List_impl(_Node_alloc_type&& __a) _GLIBCXX_NOEXCEPT
+	: _Node_alloc_type(std::move(__a)), _M_node()
+	{ }
+#endif
+      };
+
+      _List_impl _M_impl;
+
+      _List_node<_Tp>*
+      _M_get_node()
+      { return _M_impl._Node_alloc_type::allocate(1); }
+
+      void
+      _M_put_node(_List_node<_Tp>* __p) _GLIBCXX_NOEXCEPT
+      { _M_impl._Node_alloc_type::deallocate(__p, 1); }
+
+  public:
+      typedef _Alloc allocator_type;
+
+      _Node_alloc_type&
+      _M_get_Node_allocator() _GLIBCXX_NOEXCEPT
+      { return *static_cast<_Node_alloc_type*>(&_M_impl); }
+
+      const _Node_alloc_type&
+      _M_get_Node_allocator() const _GLIBCXX_NOEXCEPT
+      { return *static_cast<const _Node_alloc_type*>(&_M_impl); }
+
+      _Tp_alloc_type
+      _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
+      { return _Tp_alloc_type(_M_get_Node_allocator()); }
+
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_get_Node_allocator()); }
+
+      _List_base()
+      : _M_impl()
+      { _M_init(); }
+
+      _List_base(const _Node_alloc_type& __a) _GLIBCXX_NOEXCEPT
+      : _M_impl(__a)
+      { _M_init(); }
+
+#if __cplusplus >= 201103L
+      _List_base(_List_base&& __x) noexcept
+      : _M_impl(std::move(__x._M_get_Node_allocator()))
+      {
+	_M_init();
+	__detail::_List_node_base::swap(_M_impl._M_node, __x._M_impl._M_node);
+      }
+#endif
+
+      // This is what actually destroys the list.
+      ~_List_base() _GLIBCXX_NOEXCEPT
+      { _M_clear(); }
+
+      void
+      _M_clear() _GLIBCXX_NOEXCEPT;
+
+      void
+      _M_init() _GLIBCXX_NOEXCEPT
+      {
+        this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
+        this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
+      }
+    };
+
+  /**
+   *  @brief A standard container with linear time access to elements,
+   *  and fixed time insertion/deletion at any point in the sequence.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Tp  Type of element.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_Tp>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and a
+   *  <a href="tables.html#67">sequence</a>, including the
+   *  <a href="tables.html#68">optional sequence requirements</a> with the
+   *  %exception of @c at and @c operator[].
+   *
+   *  This is a @e doubly @e linked %list.  Traversal up and down the
+   *  %list requires linear time, but adding and removing elements (or
+   *  @e nodes) is done in constant time, regardless of where the
+   *  change takes place.  Unlike std::vector and std::deque,
+   *  random-access iterators are not provided, so subscripting ( @c
+   *  [] ) access is not allowed.  For algorithms which only need
+   *  sequential access, this lack makes no difference.
+   *
+   *  Also unlike the other standard containers, std::list provides
+   *  specialized algorithms %unique to linked lists, such as
+   *  splicing, sorting, and in-place reversal.
+   *
+   *  A couple points on memory allocation for list<Tp>:
+   *
+   *  First, we never actually allocate a Tp, we allocate
+   *  List_node<Tp>'s and trust [20.1.5]/4 to DTRT.  This is to ensure
+   *  that after elements from %list<X,Alloc1> are spliced into
+   *  %list<X,Alloc2>, destroying the memory of the second %list is a
+   *  valid operation, i.e., Alloc1 giveth and Alloc2 taketh away.
+   *
+   *  Second, a %list conceptually represented as
+   *  @code
+   *    A <---> B <---> C <---> D
+   *  @endcode
+   *  is actually circular; a link exists between A and D.  The %list
+   *  class holds (as its only data member) a private list::iterator
+   *  pointing to @e D, not to @e A!  To get to the head of the %list,
+   *  we start at the tail and move forward by one.  When this member
+   *  iterator's next/previous pointers refer to itself, the %list is
+   *  %empty. 
+  */
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class list : protected _List_base<_Tp, _Alloc>
+    {
+      // concept requirements
+      typedef typename _Alloc::value_type                _Alloc_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
+
+      typedef _List_base<_Tp, _Alloc>                    _Base;
+      typedef typename _Base::_Tp_alloc_type		 _Tp_alloc_type;
+      typedef typename _Base::_Node_alloc_type		 _Node_alloc_type;
+
+    public:
+      typedef _Tp                                        value_type;
+      typedef typename _Tp_alloc_type::pointer           pointer;
+      typedef typename _Tp_alloc_type::const_pointer     const_pointer;
+      typedef typename _Tp_alloc_type::reference         reference;
+      typedef typename _Tp_alloc_type::const_reference   const_reference;
+      typedef _List_iterator<_Tp>                        iterator;
+      typedef _List_const_iterator<_Tp>                  const_iterator;
+      typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
+      typedef std::reverse_iterator<iterator>            reverse_iterator;
+      typedef size_t                                     size_type;
+      typedef ptrdiff_t                                  difference_type;
+      typedef _Alloc                                     allocator_type;
+
+    protected:
+      // Note that pointers-to-_Node's can be ctor-converted to
+      // iterator types.
+      typedef _List_node<_Tp>				 _Node;
+
+      using _Base::_M_impl;
+      using _Base::_M_put_node;
+      using _Base::_M_get_node;
+      using _Base::_M_get_Tp_allocator;
+      using _Base::_M_get_Node_allocator;
+
+      /**
+       *  @param  __args  An instance of user data.
+       *
+       *  Allocates space for a new node and constructs a copy of
+       *  @a __args in it.
+       */
+#if __cplusplus < 201103L
+      _Node*
+      _M_create_node(const value_type& __x)
+      {
+	_Node* __p = this->_M_get_node();
+	__try
+	  {
+	    _M_get_Tp_allocator().construct
+	      (std::__addressof(__p->_M_data), __x);
+	  }
+	__catch(...)
+	  {
+	    _M_put_node(__p);
+	    __throw_exception_again;
+	  }
+	return __p;
+      }
+#else
+      template<typename... _Args>
+        _Node*
+        _M_create_node(_Args&&... __args)
+	{
+	  _Node* __p = this->_M_get_node();
+	  __try
+	    {
+	      _M_get_Node_allocator().construct(__p,
+						std::forward<_Args>(__args)...);
+	    }
+	  __catch(...)
+	    {
+	      _M_put_node(__p);
+	      __throw_exception_again;
+	    }
+	  return __p;
+	}
+#endif
+
+    public:
+      // [23.2.2.1] construct/copy/destroy
+      // (assign() and get_allocator() are also listed in this section)
+
+      /**
+       *  @brief  Creates a %list with no elements.
+       */
+      list()
+#if __cplusplus >= 201103L
+      noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value)
+#endif
+      : _Base() { }
+
+      /**
+       *  @brief  Creates a %list with no elements.
+       *  @param  __a  An allocator object.
+       */
+      explicit
+      list(const allocator_type& __a) _GLIBCXX_NOEXCEPT
+      : _Base(_Node_alloc_type(__a)) { }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Creates a %list with default constructed elements.
+       *  @param  __n  The number of elements to initially create.
+       *
+       *  This constructor fills the %list with @a __n default
+       *  constructed elements.
+       */
+      explicit
+      list(size_type __n)
+      : _Base()
+      { _M_default_initialize(__n); }
+
+      /**
+       *  @brief  Creates a %list with copies of an exemplar element.
+       *  @param  __n  The number of elements to initially create.
+       *  @param  __value  An element to copy.
+       *  @param  __a  An allocator object.
+       *
+       *  This constructor fills the %list with @a __n copies of @a __value.
+       */
+      list(size_type __n, const value_type& __value,
+	   const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_fill_initialize(__n, __value); }
+#else
+      /**
+       *  @brief  Creates a %list with copies of an exemplar element.
+       *  @param  __n  The number of elements to initially create.
+       *  @param  __value  An element to copy.
+       *  @param  __a  An allocator object.
+       *
+       *  This constructor fills the %list with @a __n copies of @a __value.
+       */
+      explicit
+      list(size_type __n, const value_type& __value = value_type(),
+	   const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_fill_initialize(__n, __value); }
+#endif
+
+      /**
+       *  @brief  %List copy constructor.
+       *  @param  __x  A %list of identical element and allocator types.
+       *
+       *  The newly-created %list uses a copy of the allocation object used
+       *  by @a __x.
+       */
+      list(const list& __x)
+      : _Base(__x._M_get_Node_allocator())
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %List move constructor.
+       *  @param  __x  A %list of identical element and allocator types.
+       *
+       *  The newly-created %list contains the exact contents of @a __x.
+       *  The contents of @a __x are a valid, but unspecified %list.
+       */
+      list(list&& __x) noexcept
+      : _Base(std::move(__x)) { }
+
+      /**
+       *  @brief  Builds a %list from an initializer_list
+       *  @param  __l  An initializer_list of value_type.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %list consisting of copies of the elements in the
+       *  initializer_list @a __l.  This is linear in __l.size().
+       */
+      list(initializer_list<value_type> __l,
+           const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }
+#endif
+
+      /**
+       *  @brief  Builds a %list from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %list consisting of copies of the elements from
+       *  [@a __first,@a __last).  This is linear in N (where N is
+       *  distance(@a __first,@a __last)).
+       */
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        list(_InputIterator __first, _InputIterator __last,
+	     const allocator_type& __a = allocator_type())
+	: _Base(_Node_alloc_type(__a))
+        { _M_initialize_dispatch(__first, __last, __false_type()); }
+#else
+      template<typename _InputIterator>
+        list(_InputIterator __first, _InputIterator __last,
+	     const allocator_type& __a = allocator_type())
+	: _Base(_Node_alloc_type(__a))
+        { 
+	  // Check whether it's an integral type.  If so, it's not an iterator.
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_initialize_dispatch(__first, __last, _Integral());
+	}
+#endif
+
+      /**
+       *  No explicit dtor needed as the _Base dtor takes care of
+       *  things.  The _Base dtor only erases the elements, and note
+       *  that if the elements themselves are pointers, the pointed-to
+       *  memory is not touched in any way.  Managing the pointer is
+       *  the user's responsibility.
+       */
+
+      /**
+       *  @brief  %List assignment operator.
+       *  @param  __x  A %list of identical element and allocator types.
+       *
+       *  All the elements of @a __x are copied, but unlike the copy
+       *  constructor, the allocator object is not copied.
+       */
+      list&
+      operator=(const list& __x);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %List move assignment operator.
+       *  @param  __x  A %list of identical element and allocator types.
+       *
+       *  The contents of @a __x are moved into this %list (without copying).
+       *  @a __x is a valid, but unspecified %list
+       */
+      list&
+      operator=(list&& __x)
+      {
+	// NB: DR 1204.
+	// NB: DR 675.
+	this->clear();
+	this->swap(__x);
+	return *this;
+      }
+
+      /**
+       *  @brief  %List initializer list assignment operator.
+       *  @param  __l  An initializer_list of value_type.
+       *
+       *  Replace the contents of the %list with copies of the elements
+       *  in the initializer_list @a __l.  This is linear in l.size().
+       */
+      list&
+      operator=(initializer_list<value_type> __l)
+      {
+	this->assign(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      /**
+       *  @brief  Assigns a given value to a %list.
+       *  @param  __n  Number of elements to be assigned.
+       *  @param  __val  Value to be assigned.
+       *
+       *  This function fills a %list with @a __n copies of the given
+       *  value.  Note that the assignment completely changes the %list
+       *  and that the resulting %list's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+
+      /**
+       *  @brief  Assigns a range to a %list.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *
+       *  This function fills a %list with copies of the elements in the
+       *  range [@a __first,@a __last).
+       *
+       *  Note that the assignment completely changes the %list and
+       *  that the resulting %list's size is the same as the number of
+       *  elements assigned.  Old data may be lost.
+       */
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _M_assign_dispatch(__first, __last, __false_type()); }
+#else
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  // Check whether it's an integral type.  If so, it's not an iterator.
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_assign_dispatch(__first, __last, _Integral());
+	}
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Assigns an initializer_list to a %list.
+       *  @param  __l  An initializer_list of value_type.
+       *
+       *  Replace the contents of the %list with copies of the elements
+       *  in the initializer_list @a __l.  This is linear in __l.size().
+       */
+      void
+      assign(initializer_list<value_type> __l)
+      { this->assign(__l.begin(), __l.end()); }
+#endif
+
+      /// Get a copy of the memory allocation object.
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return _Base::get_allocator(); }
+
+      // iterators
+      /**
+       *  Returns a read/write iterator that points to the first element in the
+       *  %list.  Iteration is done in ordinary element order.
+       */
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(this->_M_impl._M_node._M_next); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the
+       *  first element in the %list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(this->_M_impl._M_node._M_next); }
+
+      /**
+       *  Returns a read/write iterator that points one past the last
+       *  element in the %list.  Iteration is done in ordinary element
+       *  order.
+       */
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(&this->_M_impl._M_node); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past
+       *  the last element in the %list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(&this->_M_impl._M_node); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to the last
+       *  element in the %list.  Iteration is done in reverse element
+       *  order.
+       */
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to
+       *  the last element in the %list.  Iteration is done in reverse
+       *  element order.
+       */
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to one
+       *  before the first element in the %list.  Iteration is done in
+       *  reverse element order.
+       */
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to one
+       *  before the first element in the %list.  Iteration is done in reverse
+       *  element order.
+       */
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the
+       *  first element in the %list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_node._M_next); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past
+       *  the last element in the %list.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(&this->_M_impl._M_node); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to
+       *  the last element in the %list.  Iteration is done in reverse
+       *  element order.
+       */
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to one
+       *  before the first element in the %list.  Iteration is done in reverse
+       *  element order.
+       */
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // [23.2.2.2] capacity
+      /**
+       *  Returns true if the %list is empty.  (Thus begin() would equal
+       *  end().)
+       */
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
+
+      /**  Returns the number of elements in the %list.  */
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return std::distance(begin(), end()); }
+
+      /**  Returns the size() of the largest possible %list.  */
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _M_get_Node_allocator().max_size(); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Resizes the %list to the specified number of elements.
+       *  @param __new_size Number of elements the %list should contain.
+       *
+       *  This function will %resize the %list to the specified number
+       *  of elements.  If the number is smaller than the %list's
+       *  current size the %list is truncated, otherwise default
+       *  constructed elements are appended.
+       */
+      void
+      resize(size_type __new_size);
+
+      /**
+       *  @brief Resizes the %list to the specified number of elements.
+       *  @param __new_size Number of elements the %list should contain.
+       *  @param __x Data with which new elements should be populated.
+       *
+       *  This function will %resize the %list to the specified number
+       *  of elements.  If the number is smaller than the %list's
+       *  current size the %list is truncated, otherwise the %list is
+       *  extended and new elements are populated with given data.
+       */
+      void
+      resize(size_type __new_size, const value_type& __x);
+#else
+      /**
+       *  @brief Resizes the %list to the specified number of elements.
+       *  @param __new_size Number of elements the %list should contain.
+       *  @param __x Data with which new elements should be populated.
+       *
+       *  This function will %resize the %list to the specified number
+       *  of elements.  If the number is smaller than the %list's
+       *  current size the %list is truncated, otherwise the %list is
+       *  extended and new elements are populated with given data.
+       */
+      void
+      resize(size_type __new_size, value_type __x = value_type());
+#endif
+
+      // element access
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %list.
+       */
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      { return *begin(); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %list.
+       */
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      { return *begin(); }
+
+      /**
+       *  Returns a read/write reference to the data at the last element
+       *  of the %list.
+       */
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      { 
+	iterator __tmp = end();
+	--__tmp;
+	return *__tmp;
+      }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the last
+       *  element of the %list.
+       */
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      { 
+	const_iterator __tmp = end();
+	--__tmp;
+	return *__tmp;
+      }
+
+      // [23.2.2.3] modifiers
+      /**
+       *  @brief  Add data to the front of the %list.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical stack operation.  The function creates an
+       *  element at the front of the %list and assigns the given data
+       *  to it.  Due to the nature of a %list this operation can be
+       *  done in constant time, and does not invalidate iterators and
+       *  references.
+       */
+      void
+      push_front(const value_type& __x)
+      { this->_M_insert(begin(), __x); }
+
+#if __cplusplus >= 201103L
+      void
+      push_front(value_type&& __x)
+      { this->_M_insert(begin(), std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_front(_Args&&... __args)
+        { this->_M_insert(begin(), std::forward<_Args>(__args)...); }
+#endif
+
+      /**
+       *  @brief  Removes first element.
+       *
+       *  This is a typical stack operation.  It shrinks the %list by
+       *  one.  Due to the nature of a %list this operation can be done
+       *  in constant time, and only invalidates iterators/references to
+       *  the element being removed.
+       *
+       *  Note that no data is returned, and if the first element's data
+       *  is needed, it should be retrieved before pop_front() is
+       *  called.
+       */
+      void
+      pop_front() _GLIBCXX_NOEXCEPT
+      { this->_M_erase(begin()); }
+
+      /**
+       *  @brief  Add data to the end of the %list.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical stack operation.  The function creates an
+       *  element at the end of the %list and assigns the given data to
+       *  it.  Due to the nature of a %list this operation can be done
+       *  in constant time, and does not invalidate iterators and
+       *  references.
+       */
+      void
+      push_back(const value_type& __x)
+      { this->_M_insert(end(), __x); }
+
+#if __cplusplus >= 201103L
+      void
+      push_back(value_type&& __x)
+      { this->_M_insert(end(), std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args)
+        { this->_M_insert(end(), std::forward<_Args>(__args)...); }
+#endif
+
+      /**
+       *  @brief  Removes last element.
+       *
+       *  This is a typical stack operation.  It shrinks the %list by
+       *  one.  Due to the nature of a %list this operation can be done
+       *  in constant time, and only invalidates iterators/references to
+       *  the element being removed.
+       *
+       *  Note that no data is returned, and if the last element's data
+       *  is needed, it should be retrieved before pop_back() is called.
+       */
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Constructs object in %list before specified iterator.
+       *  @param  __position  A const_iterator into the %list.
+       *  @param  __args  Arguments.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert an object of type T constructed
+       *  with T(std::forward<Args>(args)...) before the specified
+       *  location.  Due to the nature of a %list this operation can
+       *  be done in constant time, and does not invalidate iterators
+       *  and references.
+       */
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args);
+
+      /**
+       *  @brief  Inserts given value into %list before specified iterator.
+       *  @param  __position  A const_iterator into the %list.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given value before
+       *  the specified location.  Due to the nature of a %list this
+       *  operation can be done in constant time, and does not
+       *  invalidate iterators and references.
+       */
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+#else
+      /**
+       *  @brief  Inserts given value into %list before specified iterator.
+       *  @param  __position  An iterator into the %list.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given value before
+       *  the specified location.  Due to the nature of a %list this
+       *  operation can be done in constant time, and does not
+       *  invalidate iterators and references.
+       */
+      iterator
+      insert(iterator __position, const value_type& __x);
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts given rvalue into %list before specified iterator.
+       *  @param  __position  A const_iterator into the %list.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given rvalue before
+       *  the specified location.  Due to the nature of a %list this
+       *  operation can be done in constant time, and does not
+       *  invalidate iterators and references.
+        */
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+
+      /**
+       *  @brief  Inserts the contents of an initializer_list into %list
+       *          before specified const_iterator.
+       *  @param  __p  A const_iterator into the %list.
+       *  @param  __l  An initializer_list of value_type.
+       *  @return  An iterator pointing to the first element inserted
+       *           (or __position).
+       *
+       *  This function will insert copies of the data in the
+       *  initializer_list @a l into the %list before the location
+       *  specified by @a p.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts a number of copies of given data into the %list.
+       *  @param  __position  A const_iterator into the %list.
+       *  @param  __n  Number of elements to be inserted.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator pointing to the first element inserted
+       *           (or __position).
+       *
+       *  This function will insert a specified number of copies of the
+       *  given data before the location specified by @a position.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x);
+#else
+      /**
+       *  @brief  Inserts a number of copies of given data into the %list.
+       *  @param  __position  An iterator into the %list.
+       *  @param  __n  Number of elements to be inserted.
+       *  @param  __x  Data to be inserted.
+       *
+       *  This function will insert a specified number of copies of the
+       *  given data before the location specified by @a position.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      {
+	list __tmp(__n, __x, get_allocator());
+	splice(__position, __tmp);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts a range into the %list.
+       *  @param  __position  A const_iterator into the %list.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *  @return  An iterator pointing to the first element inserted
+       *           (or __position).
+       *
+       *  This function will insert copies of the data in the range [@a
+       *  first,@a last) into the %list before the location specified by
+       *  @a position.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	iterator
+	insert(const_iterator __position, _InputIterator __first,
+	       _InputIterator __last);
+#else
+      /**
+       *  @brief  Inserts a range into the %list.
+       *  @param  __position  An iterator into the %list.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *
+       *  This function will insert copies of the data in the range [@a
+       *  first,@a last) into the %list before the location specified by
+       *  @a position.
+       *
+       *  This operation is linear in the number of elements inserted and
+       *  does not invalidate iterators and references.
+       */
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+        {
+	  list __tmp(__first, __last, get_allocator());
+	  splice(__position, __tmp);
+	}
+#endif
+
+      /**
+       *  @brief  Remove element at given position.
+       *  @param  __position  Iterator pointing to element to be erased.
+       *  @return  An iterator pointing to the next element (or end()).
+       *
+       *  This function will erase the element at the given position and thus
+       *  shorten the %list by one.
+       *
+       *  Due to the nature of a %list this operation can be done in
+       *  constant time, and only invalidates iterators/references to
+       *  the element being removed.  The user is also cautioned that
+       *  this function only erases the element, and that if the element
+       *  is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position) noexcept;
+#else
+      erase(iterator __position);
+#endif
+
+      /**
+       *  @brief  Remove a range of elements.
+       *  @param  __first  Iterator pointing to the first element to be erased.
+       *  @param  __last  Iterator pointing to one past the last element to be
+       *                erased.
+       *  @return  An iterator pointing to the element pointed to by @a last
+       *           prior to erasing (or end()).
+       *
+       *  This function will erase the elements in the range @a
+       *  [first,last) and shorten the %list accordingly.
+       *
+       *  This operation is linear time in the size of the range and only
+       *  invalidates iterators/references to the element being removed.
+       *  The user is also cautioned that this function only erases the
+       *  elements, and that if the elements themselves are pointers, the
+       *  pointed-to memory is not touched in any way.  Managing the pointer
+       *  is the user's responsibility.
+       */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last) noexcept
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      {
+	while (__first != __last)
+	  __first = erase(__first);
+	return __last._M_const_cast();
+      }
+
+      /**
+       *  @brief  Swaps data with another %list.
+       *  @param  __x  A %list of the same element and allocator types.
+       *
+       *  This exchanges the elements between two lists in constant
+       *  time.  Note that the global std::swap() function is
+       *  specialized such that std::swap(l1,l2) will feed to this
+       *  function.
+       */
+      void
+      swap(list& __x)
+      {
+	__detail::_List_node_base::swap(this->_M_impl._M_node, 
+					__x._M_impl._M_node);
+
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 431. Swapping containers with unequal allocators.
+	std::__alloc_swap<typename _Base::_Node_alloc_type>::
+	  _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
+      }
+
+      /**
+       *  Erases all the elements.  Note that this function only erases
+       *  the elements, and that if the elements themselves are
+       *  pointers, the pointed-to memory is not touched in any way.
+       *  Managing the pointer is the user's responsibility.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+        _Base::_M_clear();
+        _Base::_M_init();
+      }
+
+      // [23.2.2.4] list operations
+      /**
+       *  @brief  Insert contents of another %list.
+       *  @param  __position  Iterator referencing the element to insert before.
+       *  @param  __x  Source list.
+       *
+       *  The elements of @a __x are inserted in constant time in front of
+       *  the element referenced by @a __position.  @a __x becomes an empty
+       *  list.
+       *
+       *  Requires this != @a __x.
+       */
+      void
+#if __cplusplus >= 201103L
+      splice(const_iterator __position, list&& __x) noexcept
+#else
+      splice(iterator __position, list& __x)
+#endif
+      {
+	if (!__x.empty())
+	  {
+	    _M_check_equal_allocators(__x);
+
+	    this->_M_transfer(__position._M_const_cast(),
+			      __x.begin(), __x.end());
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      void
+      splice(const_iterator __position, list& __x) noexcept
+      { splice(__position, std::move(__x)); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert element from another %list.
+       *  @param  __position  Const_iterator referencing the element to
+       *                      insert before.
+       *  @param  __x  Source list.
+       *  @param  __i  Const_iterator referencing the element to move.
+       *
+       *  Removes the element in list @a __x referenced by @a __i and
+       *  inserts it into the current list before @a __position.
+       */
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
+#else
+      /**
+       *  @brief  Insert element from another %list.
+       *  @param  __position  Iterator referencing the element to insert before.
+       *  @param  __x  Source list.
+       *  @param  __i  Iterator referencing the element to move.
+       *
+       *  Removes the element in list @a __x referenced by @a __i and
+       *  inserts it into the current list before @a __position.
+       */
+      void
+      splice(iterator __position, list& __x, iterator __i)
+#endif
+      {
+	iterator __j = __i._M_const_cast();
+	++__j;
+	if (__position == __i || __position == __j)
+	  return;
+
+	if (this != &__x)
+	  _M_check_equal_allocators(__x);
+
+	this->_M_transfer(__position._M_const_cast(),
+			  __i._M_const_cast(), __j);
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert element from another %list.
+       *  @param  __position  Const_iterator referencing the element to
+       *                      insert before.
+       *  @param  __x  Source list.
+       *  @param  __i  Const_iterator referencing the element to move.
+       *
+       *  Removes the element in list @a __x referenced by @a __i and
+       *  inserts it into the current list before @a __position.
+       */
+      void
+      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
+      { splice(__position, std::move(__x), __i); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert range from another %list.
+       *  @param  __position  Const_iterator referencing the element to
+       *                      insert before.
+       *  @param  __x  Source list.
+       *  @param  __first  Const_iterator referencing the start of range in x.
+       *  @param  __last  Const_iterator referencing the end of range in x.
+       *
+       *  Removes elements in the range [__first,__last) and inserts them
+       *  before @a __position in constant time.
+       *
+       *  Undefined if @a __position is in [__first,__last).
+       */
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __first,
+	     const_iterator __last) noexcept
+#else
+      /**
+       *  @brief  Insert range from another %list.
+       *  @param  __position  Iterator referencing the element to insert before.
+       *  @param  __x  Source list.
+       *  @param  __first  Iterator referencing the start of range in x.
+       *  @param  __last  Iterator referencing the end of range in x.
+       *
+       *  Removes elements in the range [__first,__last) and inserts them
+       *  before @a __position in constant time.
+       *
+       *  Undefined if @a __position is in [__first,__last).
+       */
+      void
+      splice(iterator __position, list& __x, iterator __first,
+	     iterator __last)
+#endif
+      {
+	if (__first != __last)
+	  {
+	    if (this != &__x)
+	      _M_check_equal_allocators(__x);
+
+	    this->_M_transfer(__position._M_const_cast(),
+			      __first._M_const_cast(),
+			      __last._M_const_cast());
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert range from another %list.
+       *  @param  __position  Const_iterator referencing the element to
+       *                      insert before.
+       *  @param  __x  Source list.
+       *  @param  __first  Const_iterator referencing the start of range in x.
+       *  @param  __last  Const_iterator referencing the end of range in x.
+       *
+       *  Removes elements in the range [__first,__last) and inserts them
+       *  before @a __position in constant time.
+       *
+       *  Undefined if @a __position is in [__first,__last).
+       */
+      void
+      splice(const_iterator __position, list& __x, const_iterator __first,
+	     const_iterator __last) noexcept
+      { splice(__position, std::move(__x), __first, __last); }
+#endif
+
+      /**
+       *  @brief  Remove all elements equal to value.
+       *  @param  __value  The value to remove.
+       *
+       *  Removes every element in the list equal to @a value.
+       *  Remaining elements stay in list order.  Note that this
+       *  function only erases the elements, and that if the elements
+       *  themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      void
+      remove(const _Tp& __value);
+
+      /**
+       *  @brief  Remove all elements satisfying a predicate.
+       *  @tparam  _Predicate  Unary predicate function or object.
+       *
+       *  Removes every element in the list for which the predicate
+       *  returns true.  Remaining elements stay in list order.  Note
+       *  that this function only erases the elements, and that if the
+       *  elements themselves are pointers, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      template<typename _Predicate>
+        void
+        remove_if(_Predicate);
+
+      /**
+       *  @brief  Remove consecutive duplicate elements.
+       *
+       *  For each consecutive set of elements with the same value,
+       *  remove all but the first one.  Remaining elements stay in
+       *  list order.  Note that this function only erases the
+       *  elements, and that if the elements themselves are pointers,
+       *  the pointed-to memory is not touched in any way.  Managing
+       *  the pointer is the user's responsibility.
+       */
+      void
+      unique();
+
+      /**
+       *  @brief  Remove consecutive elements satisfying a predicate.
+       *  @tparam _BinaryPredicate  Binary predicate function or object.
+       *
+       *  For each consecutive set of elements [first,last) that
+       *  satisfy predicate(first,i) where i is an iterator in
+       *  [first,last), remove all but the first one.  Remaining
+       *  elements stay in list order.  Note that this function only
+       *  erases the elements, and that if the elements themselves are
+       *  pointers, the pointed-to memory is not touched in any way.
+       *  Managing the pointer is the user's responsibility.
+       */
+      template<typename _BinaryPredicate>
+        void
+        unique(_BinaryPredicate);
+
+      /**
+       *  @brief  Merge sorted lists.
+       *  @param  __x  Sorted list to merge.
+       *
+       *  Assumes that both @a __x and this list are sorted according to
+       *  operator<().  Merges elements of @a __x into this list in
+       *  sorted order, leaving @a __x empty when complete.  Elements in
+       *  this list precede elements in @a __x that are equal.
+       */
+#if __cplusplus >= 201103L
+      void
+      merge(list&& __x);
+
+      void
+      merge(list& __x)
+      { merge(std::move(__x)); }
+#else
+      void
+      merge(list& __x);
+#endif
+
+      /**
+       *  @brief  Merge sorted lists according to comparison function.
+       *  @tparam _StrictWeakOrdering Comparison function defining
+       *  sort order.
+       *  @param  __x  Sorted list to merge.
+       *  @param  __comp  Comparison functor.
+       *
+       *  Assumes that both @a __x and this list are sorted according to
+       *  StrictWeakOrdering.  Merges elements of @a __x into this list
+       *  in sorted order, leaving @a __x empty when complete.  Elements
+       *  in this list precede elements in @a __x that are equivalent
+       *  according to StrictWeakOrdering().
+       */
+#if __cplusplus >= 201103L
+      template<typename _StrictWeakOrdering>
+        void
+        merge(list&& __x, _StrictWeakOrdering __comp);
+
+      template<typename _StrictWeakOrdering>
+        void
+        merge(list& __x, _StrictWeakOrdering __comp)
+        { merge(std::move(__x), __comp); }
+#else
+      template<typename _StrictWeakOrdering>
+        void
+        merge(list& __x, _StrictWeakOrdering __comp);
+#endif
+
+      /**
+       *  @brief  Reverse the elements in list.
+       *
+       *  Reverse the order of elements in the list in linear time.
+       */
+      void
+      reverse() _GLIBCXX_NOEXCEPT
+      { this->_M_impl._M_node._M_reverse(); }
+
+      /**
+       *  @brief  Sort the elements.
+       *
+       *  Sorts the elements of this list in NlogN time.  Equivalent
+       *  elements remain in list order.
+       */
+      void
+      sort();
+
+      /**
+       *  @brief  Sort the elements according to comparison function.
+       *
+       *  Sorts the elements of this list in NlogN time.  Equivalent
+       *  elements remain in list order.
+       */
+      template<typename _StrictWeakOrdering>
+        void
+        sort(_StrictWeakOrdering);
+
+    protected:
+      // Internal constructor functions follow.
+
+      // Called by the range constructor to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+        { _M_fill_initialize(static_cast<size_type>(__n), __x); }
+
+      // Called by the range constructor to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+			       __false_type)
+        {
+	  for (; __first != __last; ++__first)
+#if __cplusplus >= 201103L
+	    emplace_back(*__first);
+#else
+	    push_back(*__first);
+#endif
+	}
+
+      // Called by list(n,v,a), and the range constructor when it turns out
+      // to be the same thing.
+      void
+      _M_fill_initialize(size_type __n, const value_type& __x)
+      {
+	for (; __n; --__n)
+	  push_back(__x);
+      }
+
+#if __cplusplus >= 201103L
+      // Called by list(n).
+      void
+      _M_default_initialize(size_type __n)
+      {
+	for (; __n; --__n)
+	  emplace_back();
+      }
+
+      // Called by resize(sz).
+      void
+      _M_default_append(size_type __n);
+#endif
+
+      // Internal assign functions follow.
+
+      // Called by the range assign to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+
+      // Called by the range assign to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+			   __false_type);
+
+      // Called by assign(n,t), and the range assign when it turns out
+      // to be the same thing.
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+
+
+      // Moves the elements from [first,last) before position.
+      void
+      _M_transfer(iterator __position, iterator __first, iterator __last)
+      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
+
+      // Inserts new element at position given and with value given.
+#if __cplusplus < 201103L
+      void
+      _M_insert(iterator __position, const value_type& __x)
+      {
+        _Node* __tmp = _M_create_node(__x);
+        __tmp->_M_hook(__position._M_node);
+      }
+#else
+     template<typename... _Args>
+       void
+       _M_insert(iterator __position, _Args&&... __args)
+       {
+	 _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
+	 __tmp->_M_hook(__position._M_node);
+       }
+#endif
+
+      // Erases element at position given.
+      void
+      _M_erase(iterator __position) _GLIBCXX_NOEXCEPT
+      {
+        __position._M_node->_M_unhook();
+        _Node* __n = static_cast<_Node*>(__position._M_node);
+#if __cplusplus >= 201103L
+        _M_get_Node_allocator().destroy(__n);
+#else
+	_M_get_Tp_allocator().destroy(std::__addressof(__n->_M_data));
+#endif
+        _M_put_node(__n);
+      }
+
+      // To implement the splice (and merge) bits of N1599.
+      void
+      _M_check_equal_allocators(list& __x) _GLIBCXX_NOEXCEPT
+      {
+	if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
+	    _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
+	  __builtin_abort();
+      }
+    };
+
+  /**
+   *  @brief  List equality comparison.
+   *  @param  __x  A %list.
+   *  @param  __y  A %list of the same type as @a __x.
+   *  @return  True iff the size and elements of the lists are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the size of
+   *  the lists.  Lists are considered equivalent if their sizes are
+   *  equal, and if corresponding elements compare equal.
+  */
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    {
+      typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
+      const_iterator __end1 = __x.end();
+      const_iterator __end2 = __y.end();
+
+      const_iterator __i1 = __x.begin();
+      const_iterator __i2 = __y.begin();
+      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
+	{
+	  ++__i1;
+	  ++__i2;
+	}
+      return __i1 == __end1 && __i2 == __end2;
+    }
+
+  /**
+   *  @brief  List ordering relation.
+   *  @param  __x  A %list.
+   *  @param  __y  A %list of the same type as @a __x.
+   *  @return  True iff @a __x is lexicographically less than @a __y.
+   *
+   *  This is a total ordering relation.  It is linear in the size of the
+   *  lists.  The elements must be comparable with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+  */
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+					  __y.begin(), __y.end()); }
+
+  /// Based on operator==
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  /// See std::list::swap().
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _STL_LIST_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_map.h b/gcc-4.9/libstdc++-v3/include/bits/stl_map.h
new file mode 100644
index 0000000..334c54f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_map.h
@@ -0,0 +1,1059 @@
+// Map implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_map.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{map}
+ */
+
+#ifndef _STL_MAP_H
+#define _STL_MAP_H 1
+
+#include <bits/functexcept.h>
+#include <bits/concept_check.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#include <tuple>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  @brief A standard container made up of (key,value) pairs, which can be
+   *  retrieved based on a key, in logarithmic time.
+   *
+   *  @ingroup associative_containers
+   *
+   *  @tparam _Key  Type of key objects.
+   *  @tparam  _Tp  Type of mapped objects.
+   *  @tparam _Compare  Comparison function object type, defaults to less<_Key>.
+   *  @tparam _Alloc  Allocator type, defaults to 
+   *                  allocator<pair<const _Key, _Tp>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and an
+   *  <a href="tables.html#69">associative container</a> (using unique keys).
+   *  For a @c map<Key,T> the key_type is Key, the mapped_type is T, and the
+   *  value_type is std::pair<const Key,T>.
+   *
+   *  Maps support bidirectional iterators.
+   *
+   *  The private tree data is declared exactly the same way for map and
+   *  multimap; the distinction is made entirely in how the tree functions are
+   *  called (*_unique versus *_equal, same as the standard).
+  */
+  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class map
+    {
+    public:
+      typedef _Key                                          key_type;
+      typedef _Tp                                           mapped_type;
+      typedef std::pair<const _Key, _Tp>                    value_type;
+      typedef _Compare                                      key_compare;
+      typedef _Alloc                                        allocator_type;
+
+    private:
+      // concept requirements
+      typedef typename _Alloc::value_type                   _Alloc_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires4(_Compare, bool, _Key, _Key,
+				_BinaryFunctionConcept)
+      __glibcxx_class_requires2(value_type, _Alloc_value_type, _SameTypeConcept)
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+	friend class map<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+	_Compare comp;
+
+	value_compare(_Compare __c)
+	: comp(__c) { }
+
+      public:
+	bool operator()(const value_type& __x, const value_type& __y) const
+	{ return comp(__x.first, __y.first); }
+      };
+
+    private:
+      /// This turns a red-black tree into a [multi]map. 
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+	rebind<value_type>::other _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+		       key_compare, _Pair_alloc_type> _Rep_type;
+
+      /// The actual tree structure.
+      _Rep_type _M_t;
+
+      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;
+
+    public:
+      // many of these are specified differently in ISO, but the following are
+      // "functionally equivalent"
+      typedef typename _Alloc_traits::pointer            pointer;
+      typedef typename _Alloc_traits::const_pointer      const_pointer;
+      typedef typename _Alloc_traits::reference          reference;
+      typedef typename _Alloc_traits::const_reference    const_reference;
+      typedef typename _Rep_type::iterator               iterator;
+      typedef typename _Rep_type::const_iterator         const_iterator;
+      typedef typename _Rep_type::size_type              size_type;
+      typedef typename _Rep_type::difference_type        difference_type;
+      typedef typename _Rep_type::reverse_iterator       reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+      // [23.3.1.1] construct/copy/destroy
+      // (get_allocator() is also listed in this section)
+
+      /**
+       *  @brief  Default constructor creates no elements.
+       */
+      map()
+      : _M_t() { }
+
+      /**
+       *  @brief  Creates a %map with no elements.
+       *  @param  __comp  A comparison object.
+       *  @param  __a  An allocator object.
+       */
+      explicit
+      map(const _Compare& __comp,
+	  const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+
+      /**
+       *  @brief  %Map copy constructor.
+       *  @param  __x  A %map of identical element and allocator types.
+       *
+       *  The newly-created %map uses a copy of the allocation object
+       *  used by @a __x.
+       */
+      map(const map& __x)
+      : _M_t(__x._M_t) { }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Map move constructor.
+       *  @param  __x  A %map of identical element and allocator types.
+       *
+       *  The newly-created %map contains the exact contents of @a __x.
+       *  The contents of @a __x are a valid, but unspecified %map.
+       */
+      map(map&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _M_t(std::move(__x._M_t)) { }
+
+      /**
+       *  @brief  Builds a %map from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param  __comp  A comparison object.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %map consisting of copies of the elements in the
+       *  initializer_list @a __l.
+       *  This is linear in N if the range is already sorted, and NlogN
+       *  otherwise (where N is @a __l.size()).
+       */
+      map(initializer_list<value_type> __l,
+	  const _Compare& __comp = _Compare(),
+	  const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a))
+      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
+
+      /// Allocator-extended default constructor.
+      explicit
+      map(const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a)) { }
+
+      /// Allocator-extended copy constructor.
+      map(const map& __m, const allocator_type& __a)
+      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
+
+      /// Allocator-extended move constructor.
+      map(map&& __m, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
+
+      /// Allocator-extended initialier-list constructor.
+      map(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a))
+      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
+
+      /// Allocator-extended range constructor.
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	: _M_t(_Compare(), _Pair_alloc_type(__a))
+        { _M_t._M_insert_unique(__first, __last); }
+#endif
+
+      /**
+       *  @brief  Builds a %map from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *
+       *  Create a %map consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N if the range is
+       *  already sorted, and NlogN otherwise (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last)
+	: _M_t()
+        { _M_t._M_insert_unique(__first, __last); }
+
+      /**
+       *  @brief  Builds a %map from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __comp  A comparison functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %map consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N if the range is
+       *  already sorted, and NlogN otherwise (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+	    const _Compare& __comp,
+	    const allocator_type& __a = allocator_type())
+	: _M_t(__comp, _Pair_alloc_type(__a))
+        { _M_t._M_insert_unique(__first, __last); }
+
+      // FIXME There is no dtor declared, but we should have something
+      // generated by Doxygen.  I don't know what tags to add to this
+      // paragraph to make that happen:
+      /**
+       *  The dtor only erases the elements, and note that if the elements
+       *  themselves are pointers, the pointed-to memory is not touched in any
+       *  way.  Managing the pointer is the user's responsibility.
+       */
+
+      /**
+       *  @brief  %Map assignment operator.
+       *  @param  __x  A %map of identical element and allocator types.
+       *
+       *  All the elements of @a __x are copied, but unlike the copy
+       *  constructor, the allocator object is not copied.
+       */
+      map&
+      operator=(const map& __x)
+      {
+	_M_t = __x._M_t;
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Map move assignment operator.
+       *  @param  __x  A %map of identical element and allocator types.
+       *
+       *  The contents of @a __x are moved into this map (without copying
+       *  if the allocators compare equal or get moved on assignment).
+       *  Afterwards @a __x is in a valid, but unspecified state.
+       */
+      map&
+      operator=(map&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	if (!_M_t._M_move_assign(__x._M_t))
+	  {
+	    // The rvalue's allocator cannot be moved and is not equal,
+	    // so we need to individually move each element.
+	    clear();
+	    insert(std::__make_move_if_noexcept_iterator(__x.begin()),
+		   std::__make_move_if_noexcept_iterator(__x.end()));
+	    __x.clear();
+	  }
+	return *this;
+      }
+
+      /**
+       *  @brief  %Map list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %map with copies of the elements in the
+       *  initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %map and
+       *  that the resulting %map's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      map&
+      operator=(initializer_list<value_type> __l)
+      {
+	this->clear();
+	this->insert(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      /// Get a copy of the memory allocation object.
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_t.get_allocator()); }
+
+      // iterators
+      /**
+       *  Returns a read/write iterator that points to the first pair in the
+       *  %map.
+       *  Iteration is done in ascending order according to the keys.
+       */
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first pair
+       *  in the %map.  Iteration is done in ascending order according to the
+       *  keys.
+       */
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read/write iterator that points one past the last
+       *  pair in the %map.  Iteration is done in ascending order
+       *  according to the keys.
+       */
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  pair in the %map.  Iteration is done in ascending order according to
+       *  the keys.
+       */
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to the last pair in
+       *  the %map.  Iteration is done in descending order according to the
+       *  keys.
+       */
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last pair in the %map.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to one before the
+       *  first pair in the %map.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return _M_t.rend(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to one
+       *  before the first pair in the %map.  Iteration is done in descending
+       *  order according to the keys.
+       */
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rend(); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the first pair
+       *  in the %map.  Iteration is done in ascending order according to the
+       *  keys.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  pair in the %map.  Iteration is done in ascending order according to
+       *  the keys.
+       */
+      const_iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last pair in the %map.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to one
+       *  before the first pair in the %map.  Iteration is done in descending
+       *  order according to the keys.
+       */
+      const_reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+#endif
+
+      // capacity
+      /** Returns true if the %map is empty.  (Thus begin() would equal
+       *  end().)
+      */
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return _M_t.empty(); }
+
+      /** Returns the size of the %map.  */
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.size(); }
+
+      /** Returns the maximum size of the %map.  */
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.max_size(); }
+
+      // [23.3.1.2] element access
+      /**
+       *  @brief  Subscript ( @c [] ) access to %map data.
+       *  @param  __k  The key for which data should be retrieved.
+       *  @return  A reference to the data of the (key,data) %pair.
+       *
+       *  Allows for easy lookup with the subscript ( @c [] )
+       *  operator.  Returns data associated with the key specified in
+       *  subscript.  If the key does not exist, a pair with that key
+       *  is created using default values, which is then returned.
+       *
+       *  Lookup requires logarithmic time.
+       */
+      mapped_type&
+      operator[](const key_type& __k)
+      {
+	// concept requirements
+	__glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
+
+	iterator __i = lower_bound(__k);
+	// __i->first is greater than or equivalent to __k.
+	if (__i == end() || key_comp()(__k, (*__i).first))
+#if __cplusplus >= 201103L
+	  __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
+					    std::tuple<const key_type&>(__k),
+					    std::tuple<>());
+#else
+          __i = insert(__i, value_type(__k, mapped_type()));
+#endif
+	return (*__i).second;
+      }
+
+#if __cplusplus >= 201103L
+      mapped_type&
+      operator[](key_type&& __k)
+      {
+	// concept requirements
+	__glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
+
+	iterator __i = lower_bound(__k);
+	// __i->first is greater than or equivalent to __k.
+	if (__i == end() || key_comp()(__k, (*__i).first))
+	  __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
+					std::forward_as_tuple(std::move(__k)),
+					std::tuple<>());
+	return (*__i).second;
+      }
+#endif
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 464. Suggestion for new member functions in standard containers.
+      /**
+       *  @brief  Access to %map data.
+       *  @param  __k  The key for which data should be retrieved.
+       *  @return  A reference to the data whose key is equivalent to @a __k, if
+       *           such a data is present in the %map.
+       *  @throw  std::out_of_range  If no such data is present.
+       */
+      mapped_type&
+      at(const key_type& __k)
+      {
+	iterator __i = lower_bound(__k);
+	if (__i == end() || key_comp()(__k, (*__i).first))
+	  __throw_out_of_range(__N("map::at"));
+	return (*__i).second;
+      }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      {
+	const_iterator __i = lower_bound(__k);
+	if (__i == end() || key_comp()(__k, (*__i).first))
+	  __throw_out_of_range(__N("map::at"));
+	return (*__i).second;
+      }
+
+      // modifiers
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Attempts to build and insert a std::pair into the %map.
+       *
+       *  @param __args  Arguments used to generate a new pair instance (see
+       *	        std::piecewise_contruct for passing arguments to each
+       *	        part of the pair constructor).
+       *
+       *  @return  A pair, of which the first element is an iterator that points
+       *           to the possibly inserted pair, and the second is a bool that
+       *           is true if the pair was actually inserted.
+       *
+       *  This function attempts to build and insert a (key, value) %pair into
+       *  the %map.
+       *  A %map relies on unique keys and thus a %pair is only inserted if its
+       *  first element (the key) is not already present in the %map.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{ return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Attempts to build and insert a std::pair into the %map.
+       *
+       *  @param  __pos  An iterator that serves as a hint as to where the pair
+       *                should be inserted.
+       *  @param  __args  Arguments used to generate a new pair instance (see
+       *	         std::piecewise_contruct for passing arguments to each
+       *	         part of the pair constructor).
+       *  @return An iterator that points to the element with key of the
+       *          std::pair built from @a __args (may or may not be that
+       *          std::pair).
+       *
+       *  This function is not concerned about whether the insertion took place,
+       *  and thus does not return a boolean like the single-argument emplace()
+       *  does.
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process. A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  See
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  return _M_t._M_emplace_hint_unique(__pos,
+					     std::forward<_Args>(__args)...);
+	}
+#endif
+
+      /**
+       *  @brief Attempts to insert a std::pair into the %map.
+
+       *  @param __x Pair to be inserted (see std::make_pair for easy
+       *	     creation of pairs).
+       *
+       *  @return  A pair, of which the first element is an iterator that 
+       *           points to the possibly inserted pair, and the second is 
+       *           a bool that is true if the pair was actually inserted.
+       *
+       *  This function attempts to insert a (key, value) %pair into the %map.
+       *  A %map relies on unique keys and thus a %pair is only inserted if its
+       *  first element (the key) is not already present in the %map.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_t._M_insert_unique(__x); }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        std::pair<iterator, bool>
+        insert(_Pair&& __x)
+        { return _M_t._M_insert_unique(std::forward<_Pair>(__x)); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Attempts to insert a list of std::pairs into the %map.
+       *  @param  __list  A std::initializer_list<value_type> of pairs to be
+       *                  inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(std::initializer_list<value_type> __list)
+      { insert(__list.begin(), __list.end()); }
+#endif
+
+      /**
+       *  @brief Attempts to insert a std::pair into the %map.
+       *  @param  __position  An iterator that serves as a hint as to where the
+       *                    pair should be inserted.
+       *  @param  __x  Pair to be inserted (see std::make_pair for easy creation
+       *               of pairs).
+       *  @return An iterator that points to the element with key of
+       *           @a __x (may or may not be the %pair passed in).
+       *
+
+       *  This function is not concerned about whether the insertion
+       *  took place, and thus does not return a boolean like the
+       *  single-argument insert() does.  Note that the first
+       *  parameter is only a hint and can potentially improve the
+       *  performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  See
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const value_type& __x)
+#else
+      insert(iterator __position, const value_type& __x)
+#endif
+      { return _M_t._M_insert_unique_(__position, __x); }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        { return _M_t._M_insert_unique_(__position,
+					std::forward<_Pair>(__x)); }
+#endif
+
+      /**
+       *  @brief Template function that attempts to insert a range of elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_unique(__first, __last); }
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %map.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a position prior to the element being erased. If no such 
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given
+       *  iterator, from a %map.  Note that this function only erases
+       *  the element, and that if the element is itself a pointer,
+       *  the pointed-to memory is not touched in any way.  Managing
+       *  the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+
+      // LWG 2059
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+#else
+      /**
+       *  @brief Erases an element from a %map.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *
+       *  This function erases an element, pointed to by the given
+       *  iterator, from a %map.  Note that this function only erases
+       *  the element, and that if the element is itself a pointer,
+       *  the pointed-to memory is not touched in any way.  Managing
+       *  the pointer is the user's responsibility.
+       */
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+#endif
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of element to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all the elements located by the given key from
+       *  a %map.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %map.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   erased.
+       *  @param __last Iterator pointing to the end of the range to
+       *                be erased.
+       *  @return The iterator @a __last.
+       *
+       *  This function erases a sequence of elements from a %map.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
+      /**
+       *  @brief Erases a [__first,__last) range of elements from a %map.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   erased.
+       *  @param __last Iterator pointing to the end of the range to
+       *                be erased.
+       *
+       *  This function erases a sequence of elements from a %map.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+#endif
+
+      /**
+       *  @brief  Swaps data with another %map.
+       *  @param  __x  A %map of the same element and allocator types.
+       *
+       *  This exchanges the elements between two maps in constant
+       *  time.  (It is only swapping a pointer, an integer, and an
+       *  instance of the @c Compare type (which itself is often
+       *  stateless and empty), so it should be quite fast.)  Note
+       *  that the global std::swap() function is specialized such
+       *  that std::swap(m1,m2) will feed to this function.
+       */
+      void
+      swap(map& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _M_t.swap(__x._M_t); }
+
+      /**
+       *  Erases all elements in a %map.  Note that this function only
+       *  erases the elements, and that if the elements themselves are
+       *  pointers, the pointed-to memory is not touched in any way.
+       *  Managing the pointer is the user's responsibility.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { _M_t.clear(); }
+
+      // observers
+      /**
+       *  Returns the key comparison object out of which the %map was
+       *  constructed.
+       */
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+      /**
+       *  Returns a value comparison object, built from the key comparison
+       *  object out of which the %map was constructed.
+       */
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+
+      // [23.3.1.3] map operations
+      /**
+       *  @brief Tries to locate an element in a %map.
+       *  @param  __x  Key of (key, value) %pair to be located.
+       *  @return  Iterator pointing to sought-after element, or end() if not
+       *           found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after %pair.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+      /**
+       *  @brief Tries to locate an element in a %map.
+       *  @param  __x  Key of (key, value) %pair to be located.
+       *  @return  Read-only (constant) iterator pointing to sought-after
+       *           element, or end() if not found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns a constant
+       *  iterator pointing to the sought after %pair. If unsuccessful it
+       *  returns the past-the-end ( @c end() ) iterator.
+       */
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+
+      /**
+       *  @brief  Finds the number of elements with given key.
+       *  @param  __x  Key of (key, value) pairs to be located.
+       *  @return  Number of elements with specified key.
+       *
+       *  This function only makes sense for multimaps; for map the result will
+       *  either be 0 (not present) or 1 (present).
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
+
+      /**
+       *  @brief Finds the beginning of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Iterator pointing to first element equal to or greater
+       *           than key, or end().
+       *
+       *  This function returns the first element of a subsequence of elements
+       *  that matches the given key.  If unsuccessful it returns an iterator
+       *  pointing to the first element that has a greater value than given key
+       *  or end() if no such element exists.
+       */
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+
+      /**
+       *  @brief Finds the beginning of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Read-only (constant) iterator pointing to first element
+       *           equal to or greater than key, or end().
+       *
+       *  This function returns the first element of a subsequence of elements
+       *  that matches the given key.  If unsuccessful it returns an iterator
+       *  pointing to the first element that has a greater value than given key
+       *  or end() if no such element exists.
+       */
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+
+      /**
+       *  @brief Finds the end of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return Iterator pointing to the first element
+       *          greater than key, or end().
+       */
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+      /**
+       *  @brief Finds the end of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Read-only (constant) iterator pointing to first iterator
+       *           greater than key, or end().
+       */
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pairs to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       *
+       *  This function is equivalent to
+       *  @code
+       *    std::make_pair(c.lower_bound(val),
+       *                   c.upper_bound(val))
+       *  @endcode
+       *  (but is faster than making the calls separately).
+       *
+       *  This function probably only makes sense for multimaps.
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pairs to be located.
+       *  @return  Pair of read-only (constant) iterators that possibly points
+       *           to the subsequence matching given key.
+       *
+       *  This function is equivalent to
+       *  @code
+       *    std::make_pair(c.lower_bound(val),
+       *                   c.upper_bound(val))
+       *  @endcode
+       *  (but is faster than making the calls separately).
+       *
+       *  This function probably only makes sense for multimaps.
+       */
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const map<_K1, _T1, _C1, _A1>&,
+		   const map<_K1, _T1, _C1, _A1>&);
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const map<_K1, _T1, _C1, _A1>&,
+		  const map<_K1, _T1, _C1, _A1>&);
+    };
+
+  /**
+   *  @brief  Map equality comparison.
+   *  @param  __x  A %map.
+   *  @param  __y  A %map of the same type as @a x.
+   *  @return  True iff the size and elements of the maps are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the size of the
+   *  maps.  Maps are considered equivalent if their sizes are equal,
+   *  and if corresponding elements compare equal.
+  */
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+
+  /**
+   *  @brief  Map ordering relation.
+   *  @param  __x  A %map.
+   *  @param  __y  A %map of the same type as @a x.
+   *  @return  True iff @a x is lexicographically less than @a y.
+   *
+   *  This is a total ordering relation.  It is linear in the size of the
+   *  maps.  The elements must be comparable with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+  */
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+  /// Based on operator==
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  /// Based on operator<
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+  /// Based on operator<
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  /// Based on operator<
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  /// See std::map::swap().
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
+	 map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _STL_MAP_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_multimap.h b/gcc-4.9/libstdc++-v3/include/bits/stl_multimap.h
new file mode 100644
index 0000000..c7b80c9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_multimap.h
@@ -0,0 +1,962 @@
+// Multimap implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_multimap.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{map}
+ */
+
+#ifndef _STL_MULTIMAP_H
+#define _STL_MULTIMAP_H 1
+
+#include <bits/concept_check.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  @brief A standard container made up of (key,value) pairs, which can be
+   *  retrieved based on a key, in logarithmic time.
+   *
+   *  @ingroup associative_containers
+   *
+   *  @tparam _Key  Type of key objects.
+   *  @tparam  _Tp  Type of mapped objects.
+   *  @tparam _Compare  Comparison function object type, defaults to less<_Key>.
+   *  @tparam _Alloc  Allocator type, defaults to 
+   *                  allocator<pair<const _Key, _Tp>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and an
+   *  <a href="tables.html#69">associative container</a> (using equivalent
+   *  keys).  For a @c multimap<Key,T> the key_type is Key, the mapped_type
+   *  is T, and the value_type is std::pair<const Key,T>.
+   *
+   *  Multimaps support bidirectional iterators.
+   *
+   *  The private tree data is declared exactly the same way for map and
+   *  multimap; the distinction is made entirely in how the tree functions are
+   *  called (*_unique versus *_equal, same as the standard).
+  */
+  template <typename _Key, typename _Tp,
+	    typename _Compare = std::less<_Key>,
+	    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class multimap
+    {
+    public:
+      typedef _Key                                          key_type;
+      typedef _Tp                                           mapped_type;
+      typedef std::pair<const _Key, _Tp>                    value_type;
+      typedef _Compare                                      key_compare;
+      typedef _Alloc                                        allocator_type;
+
+    private:
+      // concept requirements
+      typedef typename _Alloc::value_type                   _Alloc_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires4(_Compare, bool, _Key, _Key,
+				_BinaryFunctionConcept)
+      __glibcxx_class_requires2(value_type, _Alloc_value_type, _SameTypeConcept)
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+	friend class multimap<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+	_Compare comp;
+
+	value_compare(_Compare __c)
+	: comp(__c) { }
+
+      public:
+	bool operator()(const value_type& __x, const value_type& __y) const
+	{ return comp(__x.first, __y.first); }
+      };
+
+    private:
+      /// This turns a red-black tree into a [multi]map.
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+	rebind<value_type>::other _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+		       key_compare, _Pair_alloc_type> _Rep_type;
+      /// The actual tree structure.
+      _Rep_type _M_t;
+
+      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;
+
+    public:
+      // many of these are specified differently in ISO, but the following are
+      // "functionally equivalent"
+      typedef typename _Alloc_traits::pointer            pointer;
+      typedef typename _Alloc_traits::const_pointer      const_pointer;
+      typedef typename _Alloc_traits::reference          reference;
+      typedef typename _Alloc_traits::const_reference    const_reference;
+      typedef typename _Rep_type::iterator               iterator;
+      typedef typename _Rep_type::const_iterator         const_iterator;
+      typedef typename _Rep_type::size_type              size_type;
+      typedef typename _Rep_type::difference_type        difference_type;
+      typedef typename _Rep_type::reverse_iterator       reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+      // [23.3.2] construct/copy/destroy
+      // (get_allocator() is also listed in this section)
+
+      /**
+       *  @brief  Default constructor creates no elements.
+       */
+      multimap()
+      : _M_t() { }
+
+      /**
+       *  @brief  Creates a %multimap with no elements.
+       *  @param  __comp  A comparison object.
+       *  @param  __a  An allocator object.
+       */
+      explicit
+      multimap(const _Compare& __comp,
+	       const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+
+      /**
+       *  @brief  %Multimap copy constructor.
+       *  @param  __x  A %multimap of identical element and allocator types.
+       *
+       *  The newly-created %multimap uses a copy of the allocation object
+       *  used by @a __x.
+       */
+      multimap(const multimap& __x)
+      : _M_t(__x._M_t) { }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Multimap move constructor.
+       *  @param   __x  A %multimap of identical element and allocator types.
+       *
+       *  The newly-created %multimap contains the exact contents of @a __x.
+       *  The contents of @a __x are a valid, but unspecified %multimap.
+       */
+      multimap(multimap&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _M_t(std::move(__x._M_t)) { }
+
+      /**
+       *  @brief  Builds a %multimap from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param  __comp  A comparison functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %multimap consisting of copies of the elements from
+       *  the initializer_list.  This is linear in N if the list is already
+       *  sorted, and NlogN otherwise (where N is @a __l.size()).
+       */
+      multimap(initializer_list<value_type> __l,
+	       const _Compare& __comp = _Compare(),
+	       const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a))
+      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
+
+      /// Allocator-extended default constructor.
+      explicit
+      multimap(const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a)) { }
+
+      /// Allocator-extended copy constructor.
+      multimap(const multimap& __m, const allocator_type& __a)
+      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
+
+      /// Allocator-extended move constructor.
+      multimap(multimap&& __m, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
+
+      /// Allocator-extended initialier-list constructor.
+      multimap(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a))
+      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
+
+      /// Allocator-extended range constructor.
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+		 const allocator_type& __a)
+	: _M_t(_Compare(), _Pair_alloc_type(__a))
+        { _M_t._M_insert_equal(__first, __last); }
+#endif
+
+      /**
+       *  @brief  Builds a %multimap from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *
+       *  Create a %multimap consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N if the range is already sorted,
+       *  and NlogN otherwise (where N is distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last)
+	: _M_t()
+        { _M_t._M_insert_equal(__first, __last); }
+
+      /**
+       *  @brief  Builds a %multimap from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __comp  A comparison functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %multimap consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N if the range is already sorted,
+       *  and NlogN otherwise (where N is distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+		 const _Compare& __comp,
+		 const allocator_type& __a = allocator_type())
+	: _M_t(__comp, _Pair_alloc_type(__a))
+        { _M_t._M_insert_equal(__first, __last); }
+
+      // FIXME There is no dtor declared, but we should have something generated
+      // by Doxygen.  I don't know what tags to add to this paragraph to make
+      // that happen:
+      /**
+       *  The dtor only erases the elements, and note that if the elements
+       *  themselves are pointers, the pointed-to memory is not touched in any
+       *  way.  Managing the pointer is the user's responsibility.
+       */
+
+      /**
+       *  @brief  %Multimap assignment operator.
+       *  @param  __x  A %multimap of identical element and allocator types.
+       *
+       *  All the elements of @a __x are copied, but unlike the copy
+       *  constructor, the allocator object is not copied.
+       */
+      multimap&
+      operator=(const multimap& __x)
+      {
+	_M_t = __x._M_t;
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Multimap move assignment operator.
+       *  @param  __x  A %multimap of identical element and allocator types.
+       *
+       *  The contents of @a __x are moved into this multimap (without copying
+       *  if the allocators compare equal or get moved on assignment).
+       *  Afterwards @a __x is in a valid, but unspecified state.
+       */
+      multimap&
+      operator=(multimap&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	if (!_M_t._M_move_assign(__x._M_t))
+	  {
+	    // The rvalue's allocator cannot be moved and is not equal,
+	    // so we need to individually move each element.
+	    clear();
+	    insert(std::__make_move_if_noexcept_iterator(__x.begin()),
+		   std::__make_move_if_noexcept_iterator(__x.end()));
+	    __x.clear();
+	  }
+	return *this;
+      }
+
+      /**
+       *  @brief  %Multimap list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %multimap with copies of the elements
+       *  in the initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %multimap and
+       *  that the resulting %multimap's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+	this->clear();
+	this->insert(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      /// Get a copy of the memory allocation object.
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT 
+      { return allocator_type(_M_t.get_allocator()); }
+
+      // iterators
+      /**
+       *  Returns a read/write iterator that points to the first pair in the
+       *  %multimap.  Iteration is done in ascending order according to the
+       *  keys.
+       */
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first pair
+       *  in the %multimap.  Iteration is done in ascending order according to
+       *  the keys.
+       */
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read/write iterator that points one past the last pair in
+       *  the %multimap.  Iteration is done in ascending order according to the
+       *  keys.
+       */
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  pair in the %multimap.  Iteration is done in ascending order according
+       *  to the keys.
+       */
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to the last pair in
+       *  the %multimap.  Iteration is done in descending order according to the
+       *  keys.
+       */
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last pair in the %multimap.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to one before the
+       *  first pair in the %multimap.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return _M_t.rend(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to one
+       *  before the first pair in the %multimap.  Iteration is done in
+       *  descending order according to the keys.
+       */
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rend(); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the first pair
+       *  in the %multimap.  Iteration is done in ascending order according to
+       *  the keys.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  pair in the %multimap.  Iteration is done in ascending order according
+       *  to the keys.
+       */
+      const_iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last pair in the %multimap.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to one
+       *  before the first pair in the %multimap.  Iteration is done in
+       *  descending order according to the keys.
+       */
+      const_reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+#endif
+
+      // capacity
+      /** Returns true if the %multimap is empty.  */
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return _M_t.empty(); }
+
+      /** Returns the size of the %multimap.  */
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.size(); }
+
+      /** Returns the maximum size of the %multimap.  */
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.max_size(); }
+
+      // modifiers
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Build and insert a std::pair into the %multimap.
+       *
+       *  @param __args  Arguments used to generate a new pair instance (see
+       *	        std::piecewise_contruct for passing arguments to each
+       *	        part of the pair constructor).
+       *
+       *  @return An iterator that points to the inserted (key,value) pair.
+       *
+       *  This function builds and inserts a (key, value) %pair into the
+       *  %multimap.
+       *  Contrary to a std::map the %multimap does not rely on unique keys and
+       *  thus multiple pairs with the same key can be inserted.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{ return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Builds and inserts a std::pair into the %multimap.
+       *
+       *  @param  __pos  An iterator that serves as a hint as to where the pair
+       *                should be inserted.
+       *  @param  __args  Arguments used to generate a new pair instance (see
+       *	         std::piecewise_contruct for passing arguments to each
+       *	         part of the pair constructor).
+       *  @return An iterator that points to the inserted (key,value) pair.
+       *
+       *  This function inserts a (key, value) pair into the %multimap.
+       *  Contrary to a std::map the %multimap does not rely on unique keys and
+       *  thus multiple pairs with the same key can be inserted.
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  return _M_t._M_emplace_hint_equal(__pos,
+					    std::forward<_Args>(__args)...);
+	}
+#endif
+
+      /**
+       *  @brief Inserts a std::pair into the %multimap.
+       *  @param  __x  Pair to be inserted (see std::make_pair for easy creation
+       *             of pairs).
+       *  @return An iterator that points to the inserted (key,value) pair.
+       *
+       *  This function inserts a (key, value) pair into the %multimap.
+       *  Contrary to a std::map the %multimap does not rely on unique keys and
+       *  thus multiple pairs with the same key can be inserted.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      iterator
+      insert(const value_type& __x)
+      { return _M_t._M_insert_equal(__x); }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(_Pair&& __x)
+        { return _M_t._M_insert_equal(std::forward<_Pair>(__x)); }
+#endif
+
+      /**
+       *  @brief Inserts a std::pair into the %multimap.
+       *  @param  __position  An iterator that serves as a hint as to where the
+       *                      pair should be inserted.
+       *  @param  __x  Pair to be inserted (see std::make_pair for easy creation
+       *               of pairs).
+       *  @return An iterator that points to the inserted (key,value) pair.
+       *
+       *  This function inserts a (key, value) pair into the %multimap.
+       *  Contrary to a std::map the %multimap does not rely on unique keys and
+       *  thus multiple pairs with the same key can be inserted.
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const value_type& __x)
+#else
+      insert(iterator __position, const value_type& __x)
+#endif
+      { return _M_t._M_insert_equal_(__position, __x); }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        { return _M_t._M_insert_equal_(__position,
+				       std::forward<_Pair>(__x)); }
+#endif
+
+      /**
+       *  @brief A template function that attempts to insert a range
+       *  of elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_equal(__first, __last); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Attempts to insert a list of std::pairs into the %multimap.
+       *  @param  __l  A std::initializer_list<value_type> of pairs to be
+       *               inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %multimap.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a position prior to the element being erased. If no such 
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %multimap.  Note that this function only erases the element,
+       *  and that if the element is itself a pointer, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+
+      // LWG 2059.
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+#else
+      /**
+       *  @brief Erases an element from a %multimap.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %multimap.  Note that this function only erases the element,
+       *  and that if the element is itself a pointer, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+#endif
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of element to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all elements located by the given key from a
+       *  %multimap.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %multimap.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   erased.
+       *  @param __last Iterator pointing to the end of the range to be
+       *                erased .
+       *  @return The iterator @a __last.
+       *
+       *  This function erases a sequence of elements from a %multimap.
+       *  Note that this function only erases the elements, and that if
+       *  the elements themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %multimap.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                 erased.
+       *  @param __last Iterator pointing to the end of the range to
+       *                be erased.
+       *
+       *  This function erases a sequence of elements from a %multimap.
+       *  Note that this function only erases the elements, and that if
+       *  the elements themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+#endif
+
+      /**
+       *  @brief  Swaps data with another %multimap.
+       *  @param  __x  A %multimap of the same element and allocator types.
+       *
+       *  This exchanges the elements between two multimaps in constant time.
+       *  (It is only swapping a pointer, an integer, and an instance of
+       *  the @c Compare type (which itself is often stateless and empty), so it
+       *  should be quite fast.)
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(m1,m2) will feed to this function.
+       */
+      void
+      swap(multimap& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _M_t.swap(__x._M_t); }
+
+      /**
+       *  Erases all elements in a %multimap.  Note that this function only
+       *  erases the elements, and that if the elements themselves are pointers,
+       *  the pointed-to memory is not touched in any way.  Managing the pointer
+       *  is the user's responsibility.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { _M_t.clear(); }
+
+      // observers
+      /**
+       *  Returns the key comparison object out of which the %multimap
+       *  was constructed.
+       */
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+      /**
+       *  Returns a value comparison object, built from the key comparison
+       *  object out of which the %multimap was constructed.
+       */
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+
+      // multimap operations
+      /**
+       *  @brief Tries to locate an element in a %multimap.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Iterator pointing to sought-after element,
+       *           or end() if not found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after %pair.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+      /**
+       *  @brief Tries to locate an element in a %multimap.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Read-only (constant) iterator pointing to sought-after
+       *           element, or end() if not found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns a constant
+       *  iterator pointing to the sought after %pair.  If unsuccessful it
+       *  returns the past-the-end ( @c end() ) iterator.
+       */
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+
+      /**
+       *  @brief Finds the number of elements with given key.
+       *  @param  __x  Key of (key, value) pairs to be located.
+       *  @return Number of elements with specified key.
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.count(__x); }
+
+      /**
+       *  @brief Finds the beginning of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Iterator pointing to first element equal to or greater
+       *           than key, or end().
+       *
+       *  This function returns the first element of a subsequence of elements
+       *  that matches the given key.  If unsuccessful it returns an iterator
+       *  pointing to the first element that has a greater value than given key
+       *  or end() if no such element exists.
+       */
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+
+      /**
+       *  @brief Finds the beginning of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Read-only (constant) iterator pointing to first element
+       *           equal to or greater than key, or end().
+       *
+       *  This function returns the first element of a subsequence of
+       *  elements that matches the given key.  If unsuccessful the
+       *  iterator will point to the next greatest element or, if no
+       *  such greater element exists, to end().
+       */
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+
+      /**
+       *  @brief Finds the end of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return Iterator pointing to the first element
+       *          greater than key, or end().
+       */
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+      /**
+       *  @brief Finds the end of a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pair to be located.
+       *  @return  Read-only (constant) iterator pointing to first iterator
+       *           greater than key, or end().
+       */
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pairs to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       *
+       *  This function is equivalent to
+       *  @code
+       *    std::make_pair(c.lower_bound(val),
+       *                   c.upper_bound(val))
+       *  @endcode
+       *  (but is faster than making the calls separately).
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key of (key, value) pairs to be located.
+       *  @return  Pair of read-only (constant) iterators that possibly points
+       *           to the subsequence matching given key.
+       *
+       *  This function is equivalent to
+       *  @code
+       *    std::make_pair(c.lower_bound(val),
+       *                   c.upper_bound(val))
+       *  @endcode
+       *  (but is faster than making the calls separately).
+       */
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const multimap<_K1, _T1, _C1, _A1>&,
+		   const multimap<_K1, _T1, _C1, _A1>&);
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const multimap<_K1, _T1, _C1, _A1>&,
+		  const multimap<_K1, _T1, _C1, _A1>&);
+  };
+
+  /**
+   *  @brief  Multimap equality comparison.
+   *  @param  __x  A %multimap.
+   *  @param  __y  A %multimap of the same type as @a __x.
+   *  @return  True iff the size and elements of the maps are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the size of the
+   *  multimaps.  Multimaps are considered equivalent if their sizes are equal,
+   *  and if corresponding elements compare equal.
+  */
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+
+  /**
+   *  @brief  Multimap ordering relation.
+   *  @param  __x  A %multimap.
+   *  @param  __y  A %multimap of the same type as @a __x.
+   *  @return  True iff @a x is lexicographically less than @a y.
+   *
+   *  This is a total ordering relation.  It is linear in the size of the
+   *  multimaps.  The elements must be comparable with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+  */
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+  /// Based on operator==
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  /// Based on operator<
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+  /// Based on operator<
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  /// Based on operator<
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  /// See std::multimap::swap().
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+         multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _STL_MULTIMAP_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_multiset.h b/gcc-4.9/libstdc++-v3/include/bits/stl_multiset.h
new file mode 100644
index 0000000..6d71c1b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_multiset.h
@@ -0,0 +1,836 @@
+// Multiset implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_multiset.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{set}
+ */
+
+#ifndef _STL_MULTISET_H
+#define _STL_MULTISET_H 1
+
+#include <bits/concept_check.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  @brief A standard container made up of elements, which can be retrieved
+   *  in logarithmic time.
+   *
+   *  @ingroup associative_containers
+   *
+   *
+   *  @tparam _Key  Type of key objects.
+   *  @tparam _Compare  Comparison function object type, defaults to less<_Key>.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_Key>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and an
+   *  <a href="tables.html#69">associative container</a> (using equivalent
+   *  keys).  For a @c multiset<Key> the key_type and value_type are Key.
+   *
+   *  Multisets support bidirectional iterators.
+   *
+   *  The private tree data is declared exactly the same way for set and
+   *  multiset; the distinction is made entirely in how the tree functions are
+   *  called (*_unique versus *_equal, same as the standard).
+  */
+  template <typename _Key, typename _Compare = std::less<_Key>,
+	    typename _Alloc = std::allocator<_Key> >
+    class multiset
+    {
+      // concept requirements
+      typedef typename _Alloc::value_type                   _Alloc_value_type;
+      __glibcxx_class_requires(_Key, _SGIAssignableConcept)
+      __glibcxx_class_requires4(_Compare, bool, _Key, _Key,
+				_BinaryFunctionConcept)
+      __glibcxx_class_requires2(_Key, _Alloc_value_type, _SameTypeConcept)	
+
+    public:
+      // typedefs:
+      typedef _Key     key_type;
+      typedef _Key     value_type;
+      typedef _Compare key_compare;
+      typedef _Compare value_compare;
+      typedef _Alloc   allocator_type;
+
+    private:
+      /// This turns a red-black tree into a [multi]set.
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+	rebind<_Key>::other _Key_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
+		       key_compare, _Key_alloc_type> _Rep_type;
+      /// The actual tree structure.
+      _Rep_type _M_t;
+
+      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;
+
+    public:
+      typedef typename _Alloc_traits::pointer		    pointer;
+      typedef typename _Alloc_traits::const_pointer	    const_pointer;
+      typedef typename _Alloc_traits::reference		    reference;
+      typedef typename _Alloc_traits::const_reference	    const_reference;
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 103. set::iterator is required to be modifiable,
+      // but this allows modification of keys.
+      typedef typename _Rep_type::const_iterator            iterator;
+      typedef typename _Rep_type::const_iterator            const_iterator;
+      typedef typename _Rep_type::const_reverse_iterator    reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+      typedef typename _Rep_type::size_type                 size_type;
+      typedef typename _Rep_type::difference_type           difference_type;
+
+      // allocation/deallocation
+      /**
+       *  @brief  Default constructor creates no elements.
+       */
+      multiset()
+      : _M_t() { }
+
+      /**
+       *  @brief  Creates a %multiset with no elements.
+       *  @param  __comp  Comparator to use.
+       *  @param  __a  An allocator object.
+       */
+      explicit
+      multiset(const _Compare& __comp,
+	       const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Key_alloc_type(__a)) { }
+
+      /**
+       *  @brief  Builds a %multiset from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *
+       *  Create a %multiset consisting of copies of the elements from
+       *  [first,last).  This is linear in N if the range is already sorted,
+       *  and NlogN otherwise (where N is distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last)
+	: _M_t()
+        { _M_t._M_insert_equal(__first, __last); }
+
+      /**
+       *  @brief  Builds a %multiset from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __comp  A comparison functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %multiset consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N if the range is already sorted,
+       *  and NlogN otherwise (where N is distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last,
+		 const _Compare& __comp,
+		 const allocator_type& __a = allocator_type())
+	: _M_t(__comp, _Key_alloc_type(__a))
+        { _M_t._M_insert_equal(__first, __last); }
+
+      /**
+       *  @brief  %Multiset copy constructor.
+       *  @param  __x  A %multiset of identical element and allocator types.
+       *
+       *  The newly-created %multiset uses a copy of the allocation object used
+       *  by @a __x.
+       */
+      multiset(const multiset& __x)
+      : _M_t(__x._M_t) { }
+
+#if __cplusplus >= 201103L
+     /**
+       *  @brief  %Multiset move constructor.
+       *  @param  __x  A %multiset of identical element and allocator types.
+       *
+       *  The newly-created %multiset contains the exact contents of @a __x.
+       *  The contents of @a __x are a valid, but unspecified %multiset.
+       */
+      multiset(multiset&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _M_t(std::move(__x._M_t)) { }
+
+      /**
+       *  @brief  Builds a %multiset from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param  __comp  A comparison functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %multiset consisting of copies of the elements from
+       *  the list.  This is linear in N if the list is already sorted,
+       *  and NlogN otherwise (where N is @a __l.size()).
+       */
+      multiset(initializer_list<value_type> __l,
+	       const _Compare& __comp = _Compare(),
+	       const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Key_alloc_type(__a))
+      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
+
+      /// Allocator-extended default constructor.
+      explicit
+      multiset(const allocator_type& __a)
+      : _M_t(_Compare(), _Key_alloc_type(__a)) { }
+
+      /// Allocator-extended copy constructor.
+      multiset(const multiset& __m, const allocator_type& __a)
+      : _M_t(__m._M_t, _Key_alloc_type(__a)) { }
+
+      /// Allocator-extended move constructor.
+      multiset(multiset&& __m, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { }
+
+      /// Allocator-extended initialier-list constructor.
+      multiset(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Compare(), _Key_alloc_type(__a))
+      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
+
+      /// Allocator-extended range constructor.
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last,
+		 const allocator_type& __a)
+	: _M_t(_Compare(), _Key_alloc_type(__a))
+        { _M_t._M_insert_equal(__first, __last); }
+#endif
+
+      /**
+       *  @brief  %Multiset assignment operator.
+       *  @param  __x  A %multiset of identical element and allocator types.
+       *
+       *  All the elements of @a __x are copied, but unlike the copy
+       *  constructor, the allocator object is not copied.
+       */
+      multiset&
+      operator=(const multiset& __x)
+      {
+	_M_t = __x._M_t;
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Multiset move assignment operator.
+       *  @param  __x  A %multiset of identical element and allocator types.
+       *
+       *  The contents of @a __x are moved into this %multiset (without
+       *  copying if the allocators compare equal or get moved on assignment).
+       *  Afterwards @a __x is in a valid, but unspecified state.
+       */
+      multiset&
+      operator=(multiset&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	if (!_M_t._M_move_assign(__x._M_t))
+	  {
+	    // The rvalue's allocator cannot be moved and is not equal,
+	    // so we need to individually move each element.
+	    clear();
+	    insert(std::__make_move_if_noexcept_iterator(__x._M_t.begin()),
+		   std::__make_move_if_noexcept_iterator(__x._M_t.end()));
+	    __x.clear();
+	  }
+	return *this;
+      }
+
+      /**
+       *  @brief  %Multiset list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %multiset with copies of the elements in the
+       *  initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %multiset and
+       *  that the resulting %multiset's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      multiset&
+      operator=(initializer_list<value_type> __l)
+      {
+	this->clear();
+	this->insert(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      // accessors:
+
+      ///  Returns the comparison object.
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+      ///  Returns the comparison object.
+      value_compare
+      value_comp() const
+      { return _M_t.key_comp(); }
+      ///  Returns the memory allocation object.
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_t.get_allocator()); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %multiset.  Iteration is done in ascending order
+       *  according to the keys.
+       */
+      iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %multiset.  Iteration is done in ascending order
+       *  according to the keys.
+       */
+      iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last element in the %multiset.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last element in the %multiset.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rend(); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %multiset.  Iteration is done in ascending order
+       *  according to the keys.
+       */
+      iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %multiset.  Iteration is done in ascending order
+       *  according to the keys.
+       */
+      iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last element in the %multiset.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last element in the %multiset.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+#endif
+
+      ///  Returns true if the %set is empty.
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return _M_t.empty(); }
+
+      ///  Returns the size of the %set.
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.size(); }
+
+      ///  Returns the maximum size of the %set.
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.max_size(); }
+
+      /**
+       *  @brief  Swaps data with another %multiset.
+       *  @param  __x  A %multiset of the same element and allocator types.
+       *
+       *  This exchanges the elements between two multisets in constant time.
+       *  (It is only swapping a pointer, an integer, and an instance of the @c
+       *  Compare type (which itself is often stateless and empty), so it should
+       *  be quite fast.)
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(s1,s2) will feed to this function.
+       */
+      void
+      swap(multiset& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _M_t.swap(__x._M_t); }
+
+      // insert/erase
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Builds and inserts an element into the %multiset.
+       *  @param  __args  Arguments used to generate the element instance to be
+       *                 inserted.
+       *  @return An iterator that points to the inserted element.
+       *
+       *  This function inserts an element into the %multiset.  Contrary
+       *  to a std::set the %multiset does not rely on unique keys and thus
+       *  multiple copies of the same element can be inserted.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{ return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Builds and inserts an element into the %multiset.
+       *  @param  __pos  An iterator that serves as a hint as to where the
+       *                element should be inserted.
+       *  @param  __args  Arguments used to generate the element instance to be
+       *                 inserted.
+       *  @return An iterator that points to the inserted element.
+       *
+       *  This function inserts an element into the %multiset.  Contrary
+       *  to a std::set the %multiset does not rely on unique keys and thus
+       *  multiple copies of the same element can be inserted.
+       *
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  return _M_t._M_emplace_hint_equal(__pos,
+					    std::forward<_Args>(__args)...);
+	}
+#endif
+
+      /**
+       *  @brief Inserts an element into the %multiset.
+       *  @param  __x  Element to be inserted.
+       *  @return An iterator that points to the inserted element.
+       *
+       *  This function inserts an element into the %multiset.  Contrary
+       *  to a std::set the %multiset does not rely on unique keys and thus
+       *  multiple copies of the same element can be inserted.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      iterator
+      insert(const value_type& __x)
+      { return _M_t._M_insert_equal(__x); }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(value_type&& __x)
+      { return _M_t._M_insert_equal(std::move(__x)); }
+#endif
+
+      /**
+       *  @brief Inserts an element into the %multiset.
+       *  @param  __position  An iterator that serves as a hint as to where the
+       *                    element should be inserted.
+       *  @param  __x  Element to be inserted.
+       *  @return An iterator that points to the inserted element.
+       *
+       *  This function inserts an element into the %multiset.  Contrary
+       *  to a std::set the %multiset does not rely on unique keys and thus
+       *  multiple copies of the same element can be inserted.
+       *
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      { return _M_t._M_insert_equal_(__position, __x); }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return _M_t._M_insert_equal_(__position, std::move(__x)); }
+#endif
+
+      /**
+       *  @brief A template function that tries to insert a range of elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_equal(__first, __last); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Attempts to insert a list of elements into the %multiset.
+       *  @param  __l  A std::initializer_list<value_type> of elements
+       *               to be inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %multiset.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a position prior to the element being erased. If no such 
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %multiset.  Note that this function only erases the element,
+       *  and that if the element is itself a pointer, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+#else
+      /**
+       *  @brief Erases an element from a %multiset.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %multiset.  Note that this function only erases the element,
+       *  and that if the element is itself a pointer, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+#endif
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of element to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all elements located by the given key from a
+       *  %multiset.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %multiset.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   erased.
+       *  @param __last Iterator pointing to the end of the range to
+       *                be erased.
+       *  @return The iterator @a last.
+       *
+       *  This function erases a sequence of elements from a %multiset.
+       *  Note that this function only erases the elements, and that if
+       *  the elements themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
+      /**
+       *  @brief Erases a [first,last) range of elements from a %multiset.
+       *  @param  first  Iterator pointing to the start of the range to be
+       *                 erased.
+       *  @param  last  Iterator pointing to the end of the range to be erased.
+       *
+       *  This function erases a sequence of elements from a %multiset.
+       *  Note that this function only erases the elements, and that if
+       *  the elements themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+#endif
+
+      /**
+       *  Erases all elements in a %multiset.  Note that this function only
+       *  erases the elements, and that if the elements themselves are pointers,
+       *  the pointed-to memory is not touched in any way.  Managing the pointer
+       *  is the user's responsibility.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { _M_t.clear(); }
+
+      // multiset operations:
+
+      /**
+       *  @brief Finds the number of elements with given key.
+       *  @param  __x  Key of elements to be located.
+       *  @return Number of elements with specified key.
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.count(__x); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214.  set::find() missing const overload
+      //@{
+      /**
+       *  @brief Tries to locate an element in a %set.
+       *  @param  __x  Element to be located.
+       *  @return  Iterator pointing to sought-after element, or end() if not
+       *           found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after element.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Finds the beginning of a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Iterator pointing to first element equal to or greater
+       *           than key, or end().
+       *
+       *  This function returns the first element of a subsequence of elements
+       *  that matches the given key.  If unsuccessful it returns an iterator
+       *  pointing to the first element that has a greater value than given key
+       *  or end() if no such element exists.
+       */
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Finds the end of a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return Iterator pointing to the first element
+       *          greater than key, or end().
+       */
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       *
+       *  This function is equivalent to
+       *  @code
+       *    std::make_pair(c.lower_bound(val),
+       *                   c.upper_bound(val))
+       *  @endcode
+       *  (but is faster than making the calls separately).
+       *
+       *  This function probably only makes sense for multisets.
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+      //@}
+
+      template<typename _K1, typename _C1, typename _A1>
+        friend bool
+        operator==(const multiset<_K1, _C1, _A1>&,
+		   const multiset<_K1, _C1, _A1>&);
+
+      template<typename _K1, typename _C1, typename _A1>
+        friend bool
+        operator< (const multiset<_K1, _C1, _A1>&,
+		   const multiset<_K1, _C1, _A1>&);
+    };
+
+  /**
+   *  @brief  Multiset equality comparison.
+   *  @param  __x  A %multiset.
+   *  @param  __y  A %multiset of the same type as @a __x.
+   *  @return  True iff the size and elements of the multisets are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the size of the
+   *  multisets.
+   *  Multisets are considered equivalent if their sizes are equal, and if
+   *  corresponding elements compare equal.
+  */
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
+	       const multiset<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+
+  /**
+   *  @brief  Multiset ordering relation.
+   *  @param  __x  A %multiset.
+   *  @param  __y  A %multiset of the same type as @a __x.
+   *  @return  True iff @a __x is lexicographically less than @a __y.
+   *
+   *  This is a total ordering relation.  It is linear in the size of the
+   *  sets.  The elements must be comparable with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+  */
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
+	      const multiset<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+  ///  Returns !(x == y).
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
+	       const multiset<_Key, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  ///  Returns y < x.
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const multiset<_Key,_Compare,_Alloc>& __x,
+	      const multiset<_Key,_Compare,_Alloc>& __y)
+    { return __y < __x; }
+
+  ///  Returns !(y < x)
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
+	       const multiset<_Key, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  ///  Returns !(x < y)
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
+	       const multiset<_Key, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  /// See std::multiset::swap().
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline void
+    swap(multiset<_Key, _Compare, _Alloc>& __x,
+	 multiset<_Key, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _STL_MULTISET_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_numeric.h b/gcc-4.9/libstdc++-v3/include/bits/stl_numeric.h
new file mode 100644
index 0000000..666391b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_numeric.h
@@ -0,0 +1,387 @@
+// Numeric functions implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_numeric.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{numeric}
+ */
+
+#ifndef _STL_NUMERIC_H
+#define _STL_NUMERIC_H 1
+
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+#include <bits/move.h> // For _GLIBCXX_MOVE
+
+#if __cplusplus >= 201103L
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Create a range of sequentially increasing values.
+   *
+   *  For each element in the range @p [first,last) assigns @p value and
+   *  increments @p value as if by @p ++value.
+   *
+   *  @param  __first  Start of range.
+   *  @param  __last  End of range.
+   *  @param  __value  Starting value.
+   *  @return  Nothing.
+   */
+  template<typename _ForwardIterator, typename _Tp>
+    void
+    iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
+      __glibcxx_function_requires(_ConvertibleConcept<_Tp,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first)
+	{
+	  *__first = __value;
+	  ++__value;
+	}
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
+
+  /**
+   *  @brief  Accumulate values in a range.
+   *
+   *  Accumulates the values in the range [first,last) using operator+().  The
+   *  initial value is @a init.  The values are processed in order.
+   *
+   *  @param  __first  Start of range.
+   *  @param  __last  End of range.
+   *  @param  __init  Starting value to add other values to.
+   *  @return  The final sum.
+   */
+  template<typename _InputIterator, typename _Tp>
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first)
+	__init = __init + *__first;
+      return __init;
+    }
+
+  /**
+   *  @brief  Accumulate values in a range with operation.
+   *
+   *  Accumulates the values in the range [first,last) using the function
+   *  object @p __binary_op.  The initial value is @p __init.  The values are
+   *  processed in order.
+   *
+   *  @param  __first  Start of range.
+   *  @param  __last  End of range.
+   *  @param  __init  Starting value to add other values to.
+   *  @param  __binary_op  Function object to accumulate with.
+   *  @return  The final sum.
+   */
+  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
+	       _BinaryOperation __binary_op)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for (; __first != __last; ++__first)
+	__init = __binary_op(__init, *__first);
+      return __init;
+    }
+
+  /**
+   *  @brief  Compute inner product of two ranges.
+   *
+   *  Starting with an initial value of @p __init, multiplies successive
+   *  elements from the two ranges and adds each product into the accumulated
+   *  value using operator+().  The values in the ranges are processed in
+   *  order.
+   *
+   *  @param  __first1  Start of range 1.
+   *  @param  __last1  End of range 1.
+   *  @param  __first2  Start of range 2.
+   *  @param  __init  Starting value to add other values to.
+   *  @return  The final inner product.
+   */
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+		  _InputIterator2 __first2, _Tp __init)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+	__init = __init + (*__first1 * *__first2);
+      return __init;
+    }
+
+  /**
+   *  @brief  Compute inner product of two ranges.
+   *
+   *  Starting with an initial value of @p __init, applies @p __binary_op2 to
+   *  successive elements from the two ranges and accumulates each result into
+   *  the accumulated value using @p __binary_op1.  The values in the ranges are
+   *  processed in order.
+   *
+   *  @param  __first1  Start of range 1.
+   *  @param  __last1  End of range 1.
+   *  @param  __first2  Start of range 2.
+   *  @param  __init  Starting value to add other values to.
+   *  @param  __binary_op1  Function object to accumulate with.
+   *  @param  __binary_op2  Function object to apply to pairs of input values.
+   *  @return  The final inner product.
+   */
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
+	   typename _BinaryOperation1, typename _BinaryOperation2>
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+		  _InputIterator2 __first2, _Tp __init,
+		  _BinaryOperation1 __binary_op1,
+		  _BinaryOperation2 __binary_op2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+	__init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
+      return __init;
+    }
+
+  /**
+   *  @brief  Return list of partial sums
+   *
+   *  Accumulates the values in the range [first,last) using the @c + operator.
+   *  As each successive input value is added into the total, that partial sum
+   *  is written to @p __result.  Therefore, the first value in @p __result is
+   *  the first value of the input, the second value in @p __result is the sum
+   *  of the first and second input values, and so on.
+   *
+   *  @param  __first  Start of input range.
+   *  @param  __last  End of input range.
+   *  @param  __result  Output sum.
+   *  @return  Iterator pointing just beyond the values written to __result.
+   */
+  template<typename _InputIterator, typename _OutputIterator>
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+				                         _ValueType>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+	{
+	  __value = __value + *__first;
+	  *++__result = __value;
+	}
+      return ++__result;
+    }
+
+  /**
+   *  @brief  Return list of partial sums
+   *
+   *  Accumulates the values in the range [first,last) using @p __binary_op.
+   *  As each successive input value is added into the total, that partial sum
+   *  is written to @p __result.  Therefore, the first value in @p __result is
+   *  the first value of the input, the second value in @p __result is the sum
+   *  of the first and second input values, and so on.
+   *
+   *  @param  __first  Start of input range.
+   *  @param  __last  End of input range.
+   *  @param  __result  Output sum.
+   *  @param  __binary_op  Function object.
+   *  @return  Iterator pointing just beyond the values written to __result.
+   */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _BinaryOperation>
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+		_OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+				                         _ValueType>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+	{
+	  __value = __binary_op(__value, *__first);
+	  *++__result = __value;
+	}
+      return ++__result;
+    }
+
+  /**
+   *  @brief  Return differences between adjacent values.
+   *
+   *  Computes the difference between adjacent values in the range
+   *  [first,last) using operator-() and writes the result to @p __result.
+   *
+   *  @param  __first  Start of input range.
+   *  @param  __last  End of input range.
+   *  @param  __result  Output sums.
+   *  @return  Iterator pointing just beyond the values written to result.
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  DR 539. partial_sum and adjacent_difference should mention requirements
+   */
+  template<typename _InputIterator, typename _OutputIterator>
+    _OutputIterator
+    adjacent_difference(_InputIterator __first,
+			_InputIterator __last, _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+				                         _ValueType>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+	{
+	  _ValueType __tmp = *__first;
+	  *++__result = __tmp - __value;
+	  __value = _GLIBCXX_MOVE(__tmp);
+	}
+      return ++__result;
+    }
+
+  /**
+   *  @brief  Return differences between adjacent values.
+   *
+   *  Computes the difference between adjacent values in the range
+   *  [__first,__last) using the function object @p __binary_op and writes the
+   *  result to @p __result.
+   *
+   *  @param  __first  Start of input range.
+   *  @param  __last  End of input range.
+   *  @param  __result  Output sum.
+   *  @param  __binary_op Function object.
+   *  @return  Iterator pointing just beyond the values written to result.
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
+   *  DR 539. partial_sum and adjacent_difference should mention requirements
+   */
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _BinaryOperation>
+    _OutputIterator
+    adjacent_difference(_InputIterator __first, _InputIterator __last,
+			_OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+				                         _ValueType>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+	{
+	  _ValueType __tmp = *__first;
+	  *++__result = __binary_op(__tmp, __value);
+	  __value = _GLIBCXX_MOVE(__tmp);
+	}
+      return ++__result;
+    }
+
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
+
+#endif /* _STL_NUMERIC_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_pair.h b/gcc-4.9/libstdc++-v3/include/bits/stl_pair.h
new file mode 100644
index 0000000..2bcf7bf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_pair.h
@@ -0,0 +1,295 @@
+// Pair implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_pair.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{utility}
+ */
+
+#ifndef _STL_PAIR_H
+#define _STL_PAIR_H 1
+
+#include <bits/move.h> // for std::move / std::forward, and std::swap
+
+#if __cplusplus >= 201103L
+#include <type_traits> // for std::__decay_and_strip too
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @addtogroup utilities
+   *  @{
+   */
+
+#if __cplusplus >= 201103L
+  /// piecewise_construct_t
+  struct piecewise_construct_t { };
+
+  /// piecewise_construct
+  constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
+
+  // Forward declarations.
+  template<typename...>
+    class tuple;
+
+  template<std::size_t...>
+    struct _Index_tuple;
+#endif
+
+ /**
+   *  @brief Struct holding two objects of arbitrary type.
+   *
+   *  @tparam _T1  Type of first object.
+   *  @tparam _T2  Type of second object.
+   */
+  template<class _T1, class _T2>
+    struct pair
+    {
+      typedef _T1 first_type;    /// @c first_type is the first bound type
+      typedef _T2 second_type;   /// @c second_type is the second bound type
+
+      _T1 first;                 /// @c first is a copy of the first object
+      _T2 second;                /// @c second is a copy of the second object
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 265.  std::pair::pair() effects overly restrictive
+      /** The default constructor creates @c first and @c second using their
+       *  respective default constructors.  */
+      _GLIBCXX_CONSTEXPR pair()
+      : first(), second() { }
+
+      /** Two objects may be passed to a @c pair constructor to be copied.  */
+      _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+
+      /** There is also a templated copy ctor for the @c pair class itself.  */
+#if __cplusplus < 201103L
+      template<class _U1, class _U2>
+	pair(const pair<_U1, _U2>& __p)
+	: first(__p.first), second(__p.second) { }
+#else
+      template<class _U1, class _U2, class = typename
+	       enable_if<__and_<is_convertible<const _U1&, _T1>,
+				is_convertible<const _U2&, _T2>>::value>::type>
+	constexpr pair(const pair<_U1, _U2>& __p)
+	: first(__p.first), second(__p.second) { }
+
+      constexpr pair(const pair&) = default;
+      constexpr pair(pair&&) = default;
+
+      // DR 811.
+      template<class _U1, class = typename
+	       enable_if<is_convertible<_U1, _T1>::value>::type>
+	constexpr pair(_U1&& __x, const _T2& __y)
+	: first(std::forward<_U1>(__x)), second(__y) { }
+
+      template<class _U2, class = typename
+	       enable_if<is_convertible<_U2, _T2>::value>::type>
+	constexpr pair(const _T1& __x, _U2&& __y)
+	: first(__x), second(std::forward<_U2>(__y)) { }
+
+      template<class _U1, class _U2, class = typename
+	       enable_if<__and_<is_convertible<_U1, _T1>,
+				is_convertible<_U2, _T2>>::value>::type>
+	constexpr pair(_U1&& __x, _U2&& __y)
+	: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
+
+      template<class _U1, class _U2, class = typename
+	       enable_if<__and_<is_convertible<_U1, _T1>,
+				is_convertible<_U2, _T2>>::value>::type>
+	constexpr pair(pair<_U1, _U2>&& __p)
+	: first(std::forward<_U1>(__p.first)),
+	  second(std::forward<_U2>(__p.second)) { }
+
+      template<typename... _Args1, typename... _Args2>
+        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
+
+      pair&
+      operator=(const pair& __p)
+      {
+	first = __p.first;
+	second = __p.second;
+	return *this;
+      }
+
+      pair&
+      operator=(pair&& __p)
+      noexcept(__and_<is_nothrow_move_assignable<_T1>,
+	              is_nothrow_move_assignable<_T2>>::value)
+      {
+	first = std::forward<first_type>(__p.first);
+	second = std::forward<second_type>(__p.second);
+	return *this;
+      }
+
+      template<class _U1, class _U2>
+	pair&
+	operator=(const pair<_U1, _U2>& __p)
+	{
+	  first = __p.first;
+	  second = __p.second;
+	  return *this;
+	}
+
+      template<class _U1, class _U2>
+	pair&
+	operator=(pair<_U1, _U2>&& __p)
+	{
+	  first = std::forward<_U1>(__p.first);
+	  second = std::forward<_U2>(__p.second);
+	  return *this;
+	}
+
+      void
+      swap(pair& __p)
+      noexcept(noexcept(swap(first, __p.first))
+	       && noexcept(swap(second, __p.second)))
+      {
+	using std::swap;
+	swap(first, __p.first);
+	swap(second, __p.second);
+      }
+
+    private:
+      template<typename... _Args1, std::size_t... _Indexes1,
+               typename... _Args2, std::size_t... _Indexes2>
+        pair(tuple<_Args1...>&, tuple<_Args2...>&,
+             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
+#endif
+    };
+
+  /// Two pairs of the same type are equal iff their members are equal.
+  template<class _T1, class _T2>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first == __y.first && __x.second == __y.second; }
+
+  /// <http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html>
+  template<class _T1, class _T2>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first < __y.first
+	     || (!(__y.first < __x.first) && __x.second < __y.second); }
+
+  /// Uses @c operator== to find the result.
+  template<class _T1, class _T2>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x == __y); }
+
+  /// Uses @c operator< to find the result.
+  template<class _T1, class _T2>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __y < __x; }
+
+  /// Uses @c operator< to find the result.
+  template<class _T1, class _T2>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__y < __x); }
+
+  /// Uses @c operator< to find the result.
+  template<class _T1, class _T2>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x < __y); }
+
+#if __cplusplus >= 201103L
+  /// See std::pair::swap().
+  // Note:  no std::swap overloads in C++03 mode, this has performance
+  //        implications, see, eg, libstdc++/38466.
+  template<class _T1, class _T2>
+    inline void
+    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+#endif
+
+  /**
+   *  @brief A convenience wrapper for creating a pair from two objects.
+   *  @param  __x  The first object.
+   *  @param  __y  The second object.
+   *  @return   A newly-constructed pair<> object of the appropriate type.
+   *
+   *  The standard requires that the objects be passed by reference-to-const,
+   *  but LWG issue #181 says they should be passed by const value.  We follow
+   *  the LWG by default.
+   */
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 181.  make_pair() unintended behavior
+#if __cplusplus >= 201103L
+  // NB: DR 706.
+  template<class _T1, class _T2>
+    constexpr pair<typename __decay_and_strip<_T1>::__type,
+                   typename __decay_and_strip<_T2>::__type>
+    make_pair(_T1&& __x, _T2&& __y)
+    {
+      typedef typename __decay_and_strip<_T1>::__type __ds_type1;
+      typedef typename __decay_and_strip<_T2>::__type __ds_type2;
+      typedef pair<__ds_type1, __ds_type2> 	      __pair_type;
+      return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
+    }
+#else
+  template<class _T1, class _T2>
+    inline pair<_T1, _T2>
+    make_pair(_T1 __x, _T2 __y)
+    { return pair<_T1, _T2>(__x, __y); }
+#endif
+
+  /// @}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif /* _STL_PAIR_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_queue.h b/gcc-4.9/libstdc++-v3/include/bits/stl_queue.h
new file mode 100644
index 0000000..b516664
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_queue.h
@@ -0,0 +1,569 @@
+// Queue implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_queue.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{queue}
+ */
+
+#ifndef _STL_QUEUE_H
+#define _STL_QUEUE_H 1
+
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  A standard container giving FIFO behavior.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Tp  Type of element.
+   *  @tparam _Sequence  Type of underlying sequence, defaults to deque<_Tp>.
+   *
+   *  Meets many of the requirements of a
+   *  <a href="tables.html#65">container</a>,
+   *  but does not define anything to do with iterators.  Very few of the
+   *  other standard container interfaces are defined.
+   *
+   *  This is not a true container, but an @e adaptor.  It holds another
+   *  container, and provides a wrapper interface to that container.  The
+   *  wrapper is what enforces strict first-in-first-out %queue behavior.
+   *
+   *  The second template parameter defines the type of the underlying
+   *  sequence/container.  It defaults to std::deque, but it can be any type
+   *  that supports @c front, @c back, @c push_back, and @c pop_front,
+   *  such as std::list or an appropriate user-defined type.
+   *
+   *  Members not found in @a normal containers are @c container_type,
+   *  which is a typedef for the second Sequence parameter, and @c push and
+   *  @c pop, which are standard %queue/FIFO operations.
+  */
+  template<typename _Tp, typename _Sequence = deque<_Tp> >
+    class queue
+    {
+      // concept requirements
+      typedef typename _Sequence::value_type _Sequence_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires(_Sequence, _FrontInsertionSequenceConcept)
+      __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
+      __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
+
+      template<typename _Tp1, typename _Seq1>
+        friend bool
+        operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
+
+      template<typename _Tp1, typename _Seq1>
+        friend bool
+        operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
+
+    public:
+      typedef typename _Sequence::value_type                value_type;
+      typedef typename _Sequence::reference                 reference;
+      typedef typename _Sequence::const_reference           const_reference;
+      typedef typename _Sequence::size_type                 size_type;
+      typedef          _Sequence                            container_type;
+
+    protected:
+      /**
+       *  'c' is the underlying container.  Maintainers wondering why
+       *  this isn't uglified as per style guidelines should note that
+       *  this name is specified in the standard, [23.2.3.1].  (Why?
+       *  Presumably for the same reason that it's protected instead
+       *  of private: to allow derivation.  But none of the other
+       *  containers allow for derivation.  Odd.)
+       */
+      _Sequence c;
+
+    public:
+      /**
+       *  @brief  Default constructor creates no elements.
+       */
+#if __cplusplus < 201103L
+      explicit
+      queue(const _Sequence& __c = _Sequence())
+      : c(__c) { }
+#else
+      explicit
+      queue(const _Sequence& __c)
+      : c(__c) { }
+
+      explicit
+      queue(_Sequence&& __c = _Sequence())
+      : c(std::move(__c)) { }
+#endif
+
+      /**
+       *  Returns true if the %queue is empty.
+       */
+      bool
+      empty() const
+      { return c.empty(); }
+
+      /**  Returns the number of elements in the %queue.  */
+      size_type
+      size() const
+      { return c.size(); }
+
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %queue.
+       */
+      reference
+      front()
+      {
+	__glibcxx_requires_nonempty();
+	return c.front();
+      }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %queue.
+       */
+      const_reference
+      front() const
+      {
+	__glibcxx_requires_nonempty();
+	return c.front();
+      }
+
+      /**
+       *  Returns a read/write reference to the data at the last
+       *  element of the %queue.
+       */
+      reference
+      back()
+      {
+	__glibcxx_requires_nonempty();
+	return c.back();
+      }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the last
+       *  element of the %queue.
+       */
+      const_reference
+      back() const
+      {
+	__glibcxx_requires_nonempty();
+	return c.back();
+      }
+
+      /**
+       *  @brief  Add data to the end of the %queue.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical %queue operation.  The function creates an
+       *  element at the end of the %queue and assigns the given data
+       *  to it.  The time complexity of the operation depends on the
+       *  underlying sequence.
+       */
+      void
+      push(const value_type& __x)
+      { c.push_back(__x); }
+
+#if __cplusplus >= 201103L
+      void
+      push(value_type&& __x)
+      { c.push_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace(_Args&&... __args)
+	{ c.emplace_back(std::forward<_Args>(__args)...); }
+#endif
+
+      /**
+       *  @brief  Removes first element.
+       *
+       *  This is a typical %queue operation.  It shrinks the %queue by one.
+       *  The time complexity of the operation depends on the underlying
+       *  sequence.
+       *
+       *  Note that no data is returned, and if the first element's
+       *  data is needed, it should be retrieved before pop() is
+       *  called.
+       */
+      void
+      pop()
+      {
+	__glibcxx_requires_nonempty();
+	c.pop_front();
+      }
+
+#if __cplusplus >= 201103L
+      void
+      swap(queue& __q)
+      noexcept(noexcept(swap(c, __q.c)))
+      {
+	using std::swap;
+	swap(c, __q.c);
+      }
+#endif
+    };
+
+  /**
+   *  @brief  Queue equality comparison.
+   *  @param  __x  A %queue.
+   *  @param  __y  A %queue of the same type as @a __x.
+   *  @return  True iff the size and elements of the queues are equal.
+   *
+   *  This is an equivalence relation.  Complexity and semantics depend on the
+   *  underlying sequence type, but the expected rules are:  this relation is
+   *  linear in the size of the sequences, and queues are considered equivalent
+   *  if their sequences compare equal.
+  */
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return __x.c == __y.c; }
+
+  /**
+   *  @brief  Queue ordering relation.
+   *  @param  __x  A %queue.
+   *  @param  __y  A %queue of the same type as @a x.
+   *  @return  True iff @a __x is lexicographically less than @a __y.
+   *
+   *  This is an total ordering relation.  Complexity and semantics
+   *  depend on the underlying sequence type, but the expected rules
+   *  are: this relation is linear in the size of the sequences, the
+   *  elements must be comparable with @c <, and
+   *  std::lexicographical_compare() is usually used to make the
+   *  determination.
+  */
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return __x.c < __y.c; }
+
+  /// Based on operator==
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return !(__x == __y); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return __y < __x; }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return !(__y < __x); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return !(__x < __y); }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Seq>
+    inline void
+    swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<typename _Tp, typename _Seq, typename _Alloc>
+    struct uses_allocator<queue<_Tp, _Seq>, _Alloc>
+    : public uses_allocator<_Seq, _Alloc>::type { };
+#endif
+
+  /**
+   *  @brief  A standard container automatically sorting its contents.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Tp  Type of element.
+   *  @tparam _Sequence  Type of underlying sequence, defaults to vector<_Tp>.
+   *  @tparam _Compare  Comparison function object type, defaults to 
+   *                    less<_Sequence::value_type>.
+   *
+   *  This is not a true container, but an @e adaptor.  It holds
+   *  another container, and provides a wrapper interface to that
+   *  container.  The wrapper is what enforces priority-based sorting 
+   *  and %queue behavior.  Very few of the standard container/sequence
+   *  interface requirements are met (e.g., iterators).
+   *
+   *  The second template parameter defines the type of the underlying
+   *  sequence/container.  It defaults to std::vector, but it can be
+   *  any type that supports @c front(), @c push_back, @c pop_back,
+   *  and random-access iterators, such as std::deque or an
+   *  appropriate user-defined type.
+   *
+   *  The third template parameter supplies the means of making
+   *  priority comparisons.  It defaults to @c less<value_type> but
+   *  can be anything defining a strict weak ordering.
+   *
+   *  Members not found in @a normal containers are @c container_type,
+   *  which is a typedef for the second Sequence parameter, and @c
+   *  push, @c pop, and @c top, which are standard %queue operations.
+   *
+   *  @note No equality/comparison operators are provided for
+   *  %priority_queue.
+   *
+   *  @note Sorting of the elements takes place as they are added to,
+   *  and removed from, the %priority_queue using the
+   *  %priority_queue's member functions.  If you access the elements
+   *  by other means, and change their data such that the sorting
+   *  order would be different, the %priority_queue will not re-sort
+   *  the elements for you.  (How could it know to do so?)
+  */
+  template<typename _Tp, typename _Sequence = vector<_Tp>,
+	   typename _Compare  = less<typename _Sequence::value_type> >
+    class priority_queue
+    {
+      // concept requirements
+      typedef typename _Sequence::value_type _Sequence_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires(_Sequence, _SequenceConcept)
+      __glibcxx_class_requires(_Sequence, _RandomAccessContainerConcept)
+      __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
+      __glibcxx_class_requires4(_Compare, bool, _Tp, _Tp,
+				_BinaryFunctionConcept)
+
+    public:
+      typedef typename _Sequence::value_type                value_type;
+      typedef typename _Sequence::reference                 reference;
+      typedef typename _Sequence::const_reference           const_reference;
+      typedef typename _Sequence::size_type                 size_type;
+      typedef          _Sequence                            container_type;
+
+    protected:
+      //  See queue::c for notes on these names.
+      _Sequence  c;
+      _Compare   comp;
+
+    public:
+      /**
+       *  @brief  Default constructor creates no elements.
+       */
+#if __cplusplus < 201103L
+      explicit
+      priority_queue(const _Compare& __x = _Compare(),
+		     const _Sequence& __s = _Sequence())
+      : c(__s), comp(__x)
+      { std::make_heap(c.begin(), c.end(), comp); }
+#else
+      explicit
+      priority_queue(const _Compare& __x,
+		     const _Sequence& __s)
+      : c(__s), comp(__x)
+      { std::make_heap(c.begin(), c.end(), comp); }
+
+      explicit
+      priority_queue(const _Compare& __x = _Compare(),
+		     _Sequence&& __s = _Sequence())
+      : c(std::move(__s)), comp(__x)
+      { std::make_heap(c.begin(), c.end(), comp); }
+#endif
+
+      /**
+       *  @brief  Builds a %queue from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __x  A comparison functor describing a strict weak ordering.
+       *  @param  __s  An initial sequence with which to start.
+       *
+       *  Begins by copying @a __s, inserting a copy of the elements
+       *  from @a [first,last) into the copy of @a __s, then ordering
+       *  the copy according to @a __x.
+       *
+       *  For more information on function objects, see the
+       *  documentation on @link functors functor base
+       *  classes@endlink.
+       */
+#if __cplusplus < 201103L
+      template<typename _InputIterator>
+        priority_queue(_InputIterator __first, _InputIterator __last,
+		       const _Compare& __x = _Compare(),
+		       const _Sequence& __s = _Sequence())
+	: c(__s), comp(__x)
+        {
+	  __glibcxx_requires_valid_range(__first, __last);
+	  c.insert(c.end(), __first, __last);
+	  std::make_heap(c.begin(), c.end(), comp);
+	}
+#else
+      template<typename _InputIterator>
+        priority_queue(_InputIterator __first, _InputIterator __last,
+		       const _Compare& __x,
+		       const _Sequence& __s)
+	: c(__s), comp(__x)
+        {
+	  __glibcxx_requires_valid_range(__first, __last);
+	  c.insert(c.end(), __first, __last);
+	  std::make_heap(c.begin(), c.end(), comp);
+	}
+
+      template<typename _InputIterator>
+        priority_queue(_InputIterator __first, _InputIterator __last,
+		       const _Compare& __x = _Compare(),
+		       _Sequence&& __s = _Sequence())
+	: c(std::move(__s)), comp(__x)
+        {
+	  __glibcxx_requires_valid_range(__first, __last);
+	  c.insert(c.end(), __first, __last);
+	  std::make_heap(c.begin(), c.end(), comp);
+	}
+#endif
+
+      /**
+       *  Returns true if the %queue is empty.
+       */
+      bool
+      empty() const
+      { return c.empty(); }
+
+      /**  Returns the number of elements in the %queue.  */
+      size_type
+      size() const
+      { return c.size(); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %queue.
+       */
+      const_reference
+      top() const
+      {
+	__glibcxx_requires_nonempty();
+	return c.front();
+      }
+
+      /**
+       *  @brief  Add data to the %queue.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical %queue operation.
+       *  The time complexity of the operation depends on the underlying
+       *  sequence.
+       */
+      void
+      push(const value_type& __x)
+      {
+	c.push_back(__x);
+	std::push_heap(c.begin(), c.end(), comp);
+      }
+
+#if __cplusplus >= 201103L
+      void
+      push(value_type&& __x)
+      {
+	c.push_back(std::move(__x));
+	std::push_heap(c.begin(), c.end(), comp);
+      }
+
+      template<typename... _Args>
+        void
+        emplace(_Args&&... __args)
+	{
+	  c.emplace_back(std::forward<_Args>(__args)...);
+	  std::push_heap(c.begin(), c.end(), comp);
+	}
+#endif
+
+      /**
+       *  @brief  Removes first element.
+       *
+       *  This is a typical %queue operation.  It shrinks the %queue
+       *  by one.  The time complexity of the operation depends on the
+       *  underlying sequence.
+       *
+       *  Note that no data is returned, and if the first element's
+       *  data is needed, it should be retrieved before pop() is
+       *  called.
+       */
+      void
+      pop()
+      {
+	__glibcxx_requires_nonempty();
+	std::pop_heap(c.begin(), c.end(), comp);
+	c.pop_back();
+      }
+
+#if __cplusplus >= 201103L
+      void
+      swap(priority_queue& __pq)
+      noexcept(noexcept(swap(c, __pq.c)) && noexcept(swap(comp, __pq.comp)))
+      {
+	using std::swap;
+	swap(c, __pq.c);
+	swap(comp, __pq.comp);
+      }
+#endif
+    };
+
+  // No equality/comparison operators are provided for priority_queue.
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Sequence, typename _Compare>
+    inline void
+    swap(priority_queue<_Tp, _Sequence, _Compare>& __x,
+	 priority_queue<_Tp, _Sequence, _Compare>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<typename _Tp, typename _Sequence, typename _Compare,
+	   typename _Alloc>
+    struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
+    : public uses_allocator<_Sequence, _Alloc>::type { };
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _STL_QUEUE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_raw_storage_iter.h b/gcc-4.9/libstdc++-v3/include/bits/stl_raw_storage_iter.h
new file mode 100644
index 0000000..6a4014b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_raw_storage_iter.h
@@ -0,0 +1,108 @@
+// -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_raw_storage_iter.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _STL_RAW_STORAGE_ITERATOR_H
+#define _STL_RAW_STORAGE_ITERATOR_H 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  This iterator class lets algorithms store their results into
+   *  uninitialized memory.
+  */
+  template <class _OutputIterator, class _Tp>
+    class raw_storage_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _OutputIterator _M_iter;
+
+    public:
+      explicit
+      raw_storage_iterator(_OutputIterator __x)
+      : _M_iter(__x) {}
+
+      raw_storage_iterator&
+      operator*() { return *this; }
+
+      raw_storage_iterator&
+      operator=(const _Tp& __element)
+      {
+	std::_Construct(std::__addressof(*_M_iter), __element);
+	return *this;
+      }
+
+      raw_storage_iterator<_OutputIterator, _Tp>&
+      operator++()
+      {
+	++_M_iter;
+	return *this;
+      }
+
+      raw_storage_iterator<_OutputIterator, _Tp>
+      operator++(int)
+      {
+	raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this;
+	++_M_iter;
+	return __tmp;
+      }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_relops.h b/gcc-4.9/libstdc++-v3/include/bits/stl_relops.h
new file mode 100644
index 0000000..fbd2493
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_relops.h
@@ -0,0 +1,134 @@
+// std::rel_ops implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the, 2009 Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file bits/stl_relops.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{utility}
+ *
+ *  Inclusion of this file has been removed from
+ *  all of the other STL headers for safety reasons, except std_utility.h.
+ *  For more information, see the thread of about twenty messages starting
+ *  with http://gcc.gnu.org/ml/libstdc++/2001-01/msg00223.html, or
+ *  http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#faq.ambiguous_overloads
+ *
+ *  Short summary: the rel_ops operators should be avoided for the present.
+ */
+
+#ifndef _STL_RELOPS_H
+#define _STL_RELOPS_H 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  namespace rel_ops
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /** @namespace std::rel_ops
+     *  @brief  The generated relational operators are sequestered here.
+     */
+
+    /**
+     *  @brief Defines @c != for arbitrary types, in terms of @c ==.
+     *  @param  __x  A thing.
+     *  @param  __y  Another thing.
+     *  @return   __x != __y
+     *
+     *  This function uses @c == to determine its result.
+     */
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+
+    /**
+     *  @brief Defines @c > for arbitrary types, in terms of @c <.
+     *  @param  __x  A thing.
+     *  @param  __y  Another thing.
+     *  @return   __x > __y
+     *
+     *  This function uses @c < to determine its result.
+     */
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+
+    /**
+     *  @brief Defines @c <= for arbitrary types, in terms of @c <.
+     *  @param  __x  A thing.
+     *  @param  __y  Another thing.
+     *  @return   __x <= __y
+     *
+     *  This function uses @c < to determine its result.
+     */
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+
+    /**
+     *  @brief Defines @c >= for arbitrary types, in terms of @c <.
+     *  @param  __x  A thing.
+     *  @param  __y  Another thing.
+     *  @return   __x >= __y
+     *
+     *  This function uses @c < to determine its result.
+     */
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace rel_ops
+
+} // namespace std
+
+#endif /* _STL_RELOPS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_set.h b/gcc-4.9/libstdc++-v3/include/bits/stl_set.h
new file mode 100644
index 0000000..3a39154
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_set.h
@@ -0,0 +1,850 @@
+// Set implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_set.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{set}
+ */
+
+#ifndef _STL_SET_H
+#define _STL_SET_H 1
+
+#include <bits/concept_check.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  @brief A standard container made up of unique keys, which can be
+   *  retrieved in logarithmic time.
+   *
+   *  @ingroup associative_containers
+   *
+   *  @tparam _Key  Type of key objects.
+   *  @tparam _Compare  Comparison function object type, defaults to less<_Key>.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_Key>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and an
+   *  <a href="tables.html#69">associative container</a> (using unique keys).
+   *
+   *  Sets support bidirectional iterators.
+   *
+   *  The private tree data is declared exactly the same way for set and
+   *  multiset; the distinction is made entirely in how the tree functions are
+   *  called (*_unique versus *_equal, same as the standard).
+  */
+  template<typename _Key, typename _Compare = std::less<_Key>,
+	   typename _Alloc = std::allocator<_Key> >
+    class set
+    {
+      // concept requirements
+      typedef typename _Alloc::value_type                   _Alloc_value_type;
+      __glibcxx_class_requires(_Key, _SGIAssignableConcept)
+      __glibcxx_class_requires4(_Compare, bool, _Key, _Key,
+				_BinaryFunctionConcept)
+      __glibcxx_class_requires2(_Key, _Alloc_value_type, _SameTypeConcept)
+
+    public:
+      // typedefs:
+      //@{
+      /// Public typedefs.
+      typedef _Key     key_type;
+      typedef _Key     value_type;
+      typedef _Compare key_compare;
+      typedef _Compare value_compare;
+      typedef _Alloc   allocator_type;
+      //@}
+
+    private:
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+	rebind<_Key>::other _Key_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
+		       key_compare, _Key_alloc_type> _Rep_type;
+      _Rep_type _M_t;  // Red-black tree representing set.
+
+      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;
+
+    public:
+      //@{
+      ///  Iterator-related typedefs.
+      typedef typename _Alloc_traits::pointer		    pointer;
+      typedef typename _Alloc_traits::const_pointer	    const_pointer;
+      typedef typename _Alloc_traits::reference		    reference;
+      typedef typename _Alloc_traits::const_reference	    const_reference;
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 103. set::iterator is required to be modifiable,
+      // but this allows modification of keys.
+      typedef typename _Rep_type::const_iterator            iterator;
+      typedef typename _Rep_type::const_iterator            const_iterator;
+      typedef typename _Rep_type::const_reverse_iterator    reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+      typedef typename _Rep_type::size_type                 size_type;
+      typedef typename _Rep_type::difference_type           difference_type;
+      //@}
+
+      // allocation/deallocation
+      /**
+       *  @brief  Default constructor creates no elements.
+       */
+      set()
+      : _M_t() { }
+
+      /**
+       *  @brief  Creates a %set with no elements.
+       *  @param  __comp  Comparator to use.
+       *  @param  __a  An allocator object.
+       */
+      explicit
+      set(const _Compare& __comp,
+	  const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Key_alloc_type(__a)) { }
+
+      /**
+       *  @brief  Builds a %set from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *
+       *  Create a %set consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N if the range is
+       *  already sorted, and NlogN otherwise (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+	set(_InputIterator __first, _InputIterator __last)
+	: _M_t()
+	{ _M_t._M_insert_unique(__first, __last); }
+
+      /**
+       *  @brief  Builds a %set from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __comp  A comparison functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %set consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N if the range is
+       *  already sorted, and NlogN otherwise (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+	set(_InputIterator __first, _InputIterator __last,
+	    const _Compare& __comp,
+	    const allocator_type& __a = allocator_type())
+	: _M_t(__comp, _Key_alloc_type(__a))
+        { _M_t._M_insert_unique(__first, __last); }
+
+      /**
+       *  @brief  %Set copy constructor.
+       *  @param  __x  A %set of identical element and allocator types.
+       *
+       *  The newly-created %set uses a copy of the allocation object used
+       *  by @a __x.
+       */
+      set(const set& __x)
+      : _M_t(__x._M_t) { }
+
+#if __cplusplus >= 201103L
+     /**
+       *  @brief %Set move constructor
+       *  @param __x  A %set of identical element and allocator types.
+       *
+       *  The newly-created %set contains the exact contents of @a x.
+       *  The contents of @a x are a valid, but unspecified %set.
+       */
+      set(set&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _M_t(std::move(__x._M_t)) { }
+
+      /**
+       *  @brief  Builds a %set from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param  __comp  A comparison functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create a %set consisting of copies of the elements in the list.
+       *  This is linear in N if the list is already sorted, and NlogN
+       *  otherwise (where N is @a __l.size()).
+       */
+      set(initializer_list<value_type> __l,
+	  const _Compare& __comp = _Compare(),
+	  const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Key_alloc_type(__a))
+      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
+
+      /// Allocator-extended default constructor.
+      explicit
+      set(const allocator_type& __a)
+      : _M_t(_Compare(), _Key_alloc_type(__a)) { }
+
+      /// Allocator-extended copy constructor.
+      set(const set& __x, const allocator_type& __a)
+      : _M_t(__x._M_t, _Key_alloc_type(__a)) { }
+
+      /// Allocator-extended move constructor.
+      set(set&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { }
+
+      /// Allocator-extended initialier-list constructor.
+      set(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Compare(), _Key_alloc_type(__a))
+      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
+
+      /// Allocator-extended range constructor.
+      template<typename _InputIterator>
+        set(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	: _M_t(_Compare(), _Key_alloc_type(__a))
+        { _M_t._M_insert_unique(__first, __last); }
+#endif
+
+      /**
+       *  @brief  %Set assignment operator.
+       *  @param  __x  A %set of identical element and allocator types.
+       *
+       *  All the elements of @a __x are copied, but unlike the copy
+       *  constructor, the allocator object is not copied.
+       */
+      set&
+      operator=(const set& __x)
+      {
+	_M_t = __x._M_t;
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief %Set move assignment operator.
+       *  @param __x  A %set of identical element and allocator types.
+       *
+       *  The contents of @a __x are moved into this %set (without copying
+       *  if the allocators compare equal or get moved on assignment).
+       *  Afterwards @a __x is in a valid, but unspecified state.
+       */
+      set&
+      operator=(set&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	if (!_M_t._M_move_assign(__x._M_t))
+	  {
+	    // The rvalue's allocator cannot be moved and is not equal,
+	    // so we need to individually move each element.
+	    clear();
+	    insert(std::__make_move_if_noexcept_iterator(__x._M_t.begin()),
+		   std::__make_move_if_noexcept_iterator(__x._M_t.end()));
+	    __x.clear();
+	  }
+      	return *this;
+      }
+
+      /**
+       *  @brief  %Set list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %set with copies of the elements in the
+       *  initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %set and
+       *  that the resulting %set's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      set&
+      operator=(initializer_list<value_type> __l)
+      {
+	this->clear();
+	this->insert(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      // accessors:
+
+      ///  Returns the comparison object with which the %set was constructed.
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+      ///  Returns the comparison object with which the %set was constructed.
+      value_compare
+      value_comp() const
+      { return _M_t.key_comp(); }
+      ///  Returns the allocator object with which the %set was constructed.
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_t.get_allocator()); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %set.  Iteration is done in ascending order according
+       *  to the keys.
+       */
+      iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %set.  Iteration is done in ascending order according
+       *  to the keys.
+       */
+      iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the last
+       *  element in the %set.  Iteration is done in descending order according
+       *  to the keys.
+       */
+      reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last pair in the %set.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return _M_t.rend(); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %set.  Iteration is done in ascending order according
+       *  to the keys.
+       */
+      iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %set.  Iteration is done in ascending order according
+       *  to the keys.
+       */
+      iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the last
+       *  element in the %set.  Iteration is done in descending order according
+       *  to the keys.
+       */
+      reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points to the
+       *  last pair in the %set.  Iteration is done in descending order
+       *  according to the keys.
+       */
+      reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+#endif
+
+      ///  Returns true if the %set is empty.
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return _M_t.empty(); }
+
+      ///  Returns the size of the %set.
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.size(); }
+
+      ///  Returns the maximum size of the %set.
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _M_t.max_size(); }
+
+      /**
+       *  @brief  Swaps data with another %set.
+       *  @param  __x  A %set of the same element and allocator types.
+       *
+       *  This exchanges the elements between two sets in constant
+       *  time.  (It is only swapping a pointer, an integer, and an
+       *  instance of the @c Compare type (which itself is often
+       *  stateless and empty), so it should be quite fast.)  Note
+       *  that the global std::swap() function is specialized such
+       *  that std::swap(s1,s2) will feed to this function.
+       */
+      void
+      swap(set& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _M_t.swap(__x._M_t); }
+
+      // insert/erase
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Attempts to build and insert an element into the %set.
+       *  @param __args  Arguments used to generate an element.
+       *  @return  A pair, of which the first element is an iterator that points
+       *           to the possibly inserted element, and the second is a bool
+       *           that is true if the element was actually inserted.
+       *
+       *  This function attempts to build and insert an element into the %set.
+       *  A %set relies on unique keys and thus an element is only inserted if
+       *  it is not already present in the %set.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{ return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Attempts to insert an element into the %set.
+       *  @param  __pos  An iterator that serves as a hint as to where the
+       *                element should be inserted.
+       *  @param  __args  Arguments used to generate the element to be
+       *                 inserted.
+       *  @return An iterator that points to the element with key equivalent to
+       *          the one generated from @a __args (may or may not be the
+       *          element itself).
+       *
+       *  This function is not concerned about whether the insertion took place,
+       *  and thus does not return a boolean like the single-argument emplace()
+       *  does.  Note that the first parameter is only a hint and can
+       *  potentially improve the performance of the insertion process.  A bad
+       *  hint would cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  return _M_t._M_emplace_hint_unique(__pos,
+					     std::forward<_Args>(__args)...);
+	}
+#endif
+
+      /**
+       *  @brief Attempts to insert an element into the %set.
+       *  @param  __x  Element to be inserted.
+       *  @return  A pair, of which the first element is an iterator that points
+       *           to the possibly inserted element, and the second is a bool
+       *           that is true if the element was actually inserted.
+       *
+       *  This function attempts to insert an element into the %set.  A %set
+       *  relies on unique keys and thus an element is only inserted if it is
+       *  not already present in the %set.
+       *
+       *  Insertion requires logarithmic time.
+       */
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      {
+	std::pair<typename _Rep_type::iterator, bool> __p =
+	  _M_t._M_insert_unique(__x);
+	return std::pair<iterator, bool>(__p.first, __p.second);
+      }
+
+#if __cplusplus >= 201103L
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      {
+	std::pair<typename _Rep_type::iterator, bool> __p =
+	  _M_t._M_insert_unique(std::move(__x));
+	return std::pair<iterator, bool>(__p.first, __p.second);
+      }
+#endif
+
+      /**
+       *  @brief Attempts to insert an element into the %set.
+       *  @param  __position  An iterator that serves as a hint as to where the
+       *                    element should be inserted.
+       *  @param  __x  Element to be inserted.
+       *  @return An iterator that points to the element with key of
+       *           @a __x (may or may not be the element passed in).
+       *
+       *  This function is not concerned about whether the insertion took place,
+       *  and thus does not return a boolean like the single-argument insert()
+       *  does.  Note that the first parameter is only a hint and can
+       *  potentially improve the performance of the insertion process.  A bad
+       *  hint would cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires logarithmic time (if the hint is not taken).
+       */
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      { return _M_t._M_insert_unique_(__position, __x); }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return _M_t._M_insert_unique_(__position, std::move(__x)); }
+#endif
+
+      /**
+       *  @brief A template function that attempts to insert a range
+       *  of elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{ _M_t._M_insert_unique(__first, __last); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief Attempts to insert a list of elements into the %set.
+       *  @param  __l  A std::initializer_list<value_type> of elements
+       *               to be inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %set.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a __position prior to the element being erased. If no such
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %set.  Note that this function only erases the element, and
+       *  that if the element is itself a pointer, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+#else
+      /**
+       *  @brief Erases an element from a %set.
+       *  @param  position  An iterator pointing to the element to be erased.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %set.  Note that this function only erases the element, and
+       *  that if the element is itself a pointer, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+#endif
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of element to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all the elements located by the given key from
+       *  a %set.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [__first,__last) range of elements from a %set.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                 erased.
+
+       *  @param __last Iterator pointing to the end of the range to
+       *  be erased.
+       *  @return The iterator @a __last.
+       *
+       *  This function erases a sequence of elements from a %set.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
+      /**
+       *  @brief Erases a [first,last) range of elements from a %set.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                 erased.
+       *  @param __last Iterator pointing to the end of the range to
+       *  be erased.
+       *
+       *  This function erases a sequence of elements from a %set.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+#endif
+
+      /**
+       *  Erases all elements in a %set.  Note that this function only erases
+       *  the elements, and that if the elements themselves are pointers, the
+       *  pointed-to memory is not touched in any way.  Managing the pointer is
+       *  the user's responsibility.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { _M_t.clear(); }
+
+      // set operations:
+
+      /**
+       *  @brief  Finds the number of elements.
+       *  @param  __x  Element to located.
+       *  @return  Number of elements with specified key.
+       *
+       *  This function only makes sense for multisets; for set the result will
+       *  either be 0 (not present) or 1 (present).
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214.  set::find() missing const overload
+      //@{
+      /**
+       *  @brief Tries to locate an element in a %set.
+       *  @param  __x  Element to be located.
+       *  @return  Iterator pointing to sought-after element, or end() if not
+       *           found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after element.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Finds the beginning of a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Iterator pointing to first element equal to or greater
+       *           than key, or end().
+       *
+       *  This function returns the first element of a subsequence of elements
+       *  that matches the given key.  If unsuccessful it returns an iterator
+       *  pointing to the first element that has a greater value than given key
+       *  or end() if no such element exists.
+       */
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Finds the end of a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return Iterator pointing to the first element
+       *          greater than key, or end().
+       */
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       *
+       *  This function is equivalent to
+       *  @code
+       *    std::make_pair(c.lower_bound(val),
+       *                   c.upper_bound(val))
+       *  @endcode
+       *  (but is faster than making the calls separately).
+       *
+       *  This function probably only makes sense for multisets.
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+      //@}
+
+      template<typename _K1, typename _C1, typename _A1>
+	friend bool
+	operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+
+      template<typename _K1, typename _C1, typename _A1>
+	friend bool
+	operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+    };
+
+
+  /**
+   *  @brief  Set equality comparison.
+   *  @param  __x  A %set.
+   *  @param  __y  A %set of the same type as @a x.
+   *  @return  True iff the size and elements of the sets are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the size of the sets.
+   *  Sets are considered equivalent if their sizes are equal, and if
+   *  corresponding elements compare equal.
+  */
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const set<_Key, _Compare, _Alloc>& __x,
+	       const set<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+
+  /**
+   *  @brief  Set ordering relation.
+   *  @param  __x  A %set.
+   *  @param  __y  A %set of the same type as @a x.
+   *  @return  True iff @a __x is lexicographically less than @a __y.
+   *
+   *  This is a total ordering relation.  It is linear in the size of the
+   *  sets.  The elements must be comparable with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+  */
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const set<_Key, _Compare, _Alloc>& __x,
+	      const set<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+  ///  Returns !(x == y).
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const set<_Key, _Compare, _Alloc>& __x,
+	       const set<_Key, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  ///  Returns y < x.
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const set<_Key, _Compare, _Alloc>& __x,
+	      const set<_Key, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+  ///  Returns !(y < x)
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const set<_Key, _Compare, _Alloc>& __x,
+	       const set<_Key, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  ///  Returns !(x < y)
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const set<_Key, _Compare, _Alloc>& __x,
+	       const set<_Key, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  /// See std::set::swap().
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline void
+    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} //namespace std
+#endif /* _STL_SET_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_stack.h b/gcc-4.9/libstdc++-v3/include/bits/stl_stack.h
new file mode 100644
index 0000000..ee187da
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_stack.h
@@ -0,0 +1,303 @@
+// Stack implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_stack.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{stack}
+ */
+
+#ifndef _STL_STACK_H
+#define _STL_STACK_H 1
+
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  A standard container giving FILO behavior.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Tp  Type of element.
+   *  @tparam _Sequence  Type of underlying sequence, defaults to deque<_Tp>.
+   *
+   *  Meets many of the requirements of a
+   *  <a href="tables.html#65">container</a>,
+   *  but does not define anything to do with iterators.  Very few of the
+   *  other standard container interfaces are defined.
+   *
+   *  This is not a true container, but an @e adaptor.  It holds
+   *  another container, and provides a wrapper interface to that
+   *  container.  The wrapper is what enforces strict
+   *  first-in-last-out %stack behavior.
+   *
+   *  The second template parameter defines the type of the underlying
+   *  sequence/container.  It defaults to std::deque, but it can be
+   *  any type that supports @c back, @c push_back, and @c pop_front,
+   *  such as std::list, std::vector, or an appropriate user-defined
+   *  type.
+   *
+   *  Members not found in @a normal containers are @c container_type,
+   *  which is a typedef for the second Sequence parameter, and @c
+   *  push, @c pop, and @c top, which are standard %stack/FILO
+   *  operations.
+  */
+  template<typename _Tp, typename _Sequence = deque<_Tp> >
+    class stack
+    {
+      // concept requirements
+      typedef typename _Sequence::value_type _Sequence_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
+      __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
+
+      template<typename _Tp1, typename _Seq1>
+        friend bool
+        operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
+
+      template<typename _Tp1, typename _Seq1>
+        friend bool
+        operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
+
+    public:
+      typedef typename _Sequence::value_type                value_type;
+      typedef typename _Sequence::reference                 reference;
+      typedef typename _Sequence::const_reference           const_reference;
+      typedef typename _Sequence::size_type                 size_type;
+      typedef          _Sequence                            container_type;
+
+    protected:
+      //  See queue::c for notes on this name.
+      _Sequence c;
+
+    public:
+      // XXX removed old def ctor, added def arg to this one to match 14882
+      /**
+       *  @brief  Default constructor creates no elements.
+       */
+#if __cplusplus < 201103L
+      explicit
+      stack(const _Sequence& __c = _Sequence())
+      : c(__c) { }
+#else
+      explicit
+      stack(const _Sequence& __c)
+      : c(__c) { }
+
+      explicit
+      stack(_Sequence&& __c = _Sequence())
+      : c(std::move(__c)) { }
+#endif
+
+      /**
+       *  Returns true if the %stack is empty.
+       */
+      bool
+      empty() const
+      { return c.empty(); }
+
+      /**  Returns the number of elements in the %stack.  */
+      size_type
+      size() const
+      { return c.size(); }
+
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %stack.
+       */
+      reference
+      top()
+      {
+	__glibcxx_requires_nonempty();
+	return c.back();
+      }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %stack.
+       */
+      const_reference
+      top() const
+      {
+	__glibcxx_requires_nonempty();
+	return c.back();
+      }
+
+      /**
+       *  @brief  Add data to the top of the %stack.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical %stack operation.  The function creates an
+       *  element at the top of the %stack and assigns the given data
+       *  to it.  The time complexity of the operation depends on the
+       *  underlying sequence.
+       */
+      void
+      push(const value_type& __x)
+      { c.push_back(__x); }
+
+#if __cplusplus >= 201103L
+      void
+      push(value_type&& __x)
+      { c.push_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace(_Args&&... __args)
+	{ c.emplace_back(std::forward<_Args>(__args)...); }
+#endif
+
+      /**
+       *  @brief  Removes first element.
+       *
+       *  This is a typical %stack operation.  It shrinks the %stack
+       *  by one.  The time complexity of the operation depends on the
+       *  underlying sequence.
+       *
+       *  Note that no data is returned, and if the first element's
+       *  data is needed, it should be retrieved before pop() is
+       *  called.
+       */
+      void
+      pop()
+      {
+	__glibcxx_requires_nonempty();
+	c.pop_back();
+      }
+
+#if __cplusplus >= 201103L
+      void
+      swap(stack& __s)
+      noexcept(noexcept(swap(c, __s.c)))
+      {
+	using std::swap;
+	swap(c, __s.c);
+      }
+#endif
+    };
+
+  /**
+   *  @brief  Stack equality comparison.
+   *  @param  __x  A %stack.
+   *  @param  __y  A %stack of the same type as @a __x.
+   *  @return  True iff the size and elements of the stacks are equal.
+   *
+   *  This is an equivalence relation.  Complexity and semantics
+   *  depend on the underlying sequence type, but the expected rules
+   *  are: this relation is linear in the size of the sequences, and
+   *  stacks are considered equivalent if their sequences compare
+   *  equal.
+  */
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return __x.c == __y.c; }
+
+  /**
+   *  @brief  Stack ordering relation.
+   *  @param  __x  A %stack.
+   *  @param  __y  A %stack of the same type as @a x.
+   *  @return  True iff @a x is lexicographically less than @a __y.
+   *
+   *  This is an total ordering relation.  Complexity and semantics
+   *  depend on the underlying sequence type, but the expected rules
+   *  are: this relation is linear in the size of the sequences, the
+   *  elements must be comparable with @c <, and
+   *  std::lexicographical_compare() is usually used to make the
+   *  determination.
+  */
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return __x.c < __y.c; }
+
+  /// Based on operator==
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return !(__x == __y); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return __y < __x; }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return !(__y < __x); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return !(__x < __y); }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Seq>
+    inline void
+    swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<typename _Tp, typename _Seq, typename _Alloc>
+    struct uses_allocator<stack<_Tp, _Seq>, _Alloc>
+    : public uses_allocator<_Seq, _Alloc>::type { };
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _STL_STACK_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_tempbuf.h b/gcc-4.9/libstdc++-v3/include/bits/stl_tempbuf.h
new file mode 100644
index 0000000..ff5ab44
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_tempbuf.h
@@ -0,0 +1,271 @@
+// Temporary buffer implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_tempbuf.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _STL_TEMPBUF_H
+#define _STL_TEMPBUF_H 1
+
+#include <bits/stl_algobase.h>
+#include <bits/stl_construct.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief Allocates a temporary buffer.
+   *  @param  __len  The number of objects of type Tp.
+   *  @return See full description.
+   *
+   *  Reinventing the wheel, but this time with prettier spokes!
+   *
+   *  This function tries to obtain storage for @c __len adjacent Tp
+   *  objects.  The objects themselves are not constructed, of course.
+   *  A pair<> is returned containing <em>the buffer s address and
+   *  capacity (in the units of sizeof(_Tp)), or a pair of 0 values if
+   *  no storage can be obtained.</em>  Note that the capacity obtained
+   *  may be less than that requested if the memory is unavailable;
+   *  you should compare len with the .second return value.
+   *
+   * Provides the nothrow exception guarantee.
+   */
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    get_temporary_buffer(ptrdiff_t __len) _GLIBCXX_NOEXCEPT
+    {
+      const ptrdiff_t __max =
+	__gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+      if (__len > __max)
+	__len = __max;
+      
+      while (__len > 0) 
+	{
+	  _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), 
+							std::nothrow));
+	  if (__tmp != 0)
+	    return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
+	  __len /= 2;
+	}
+      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
+    }
+
+  /**
+   *  @brief The companion to get_temporary_buffer().
+   *  @param  __p  A buffer previously allocated by get_temporary_buffer.
+   *  @return   None.
+   *
+   *  Frees the memory pointed to by __p.
+   */
+  template<typename _Tp>
+    inline void
+    return_temporary_buffer(_Tp* __p)
+    { ::operator delete(__p, std::nothrow); }
+
+
+  /**
+   *  This class is used in two places: stl_algo.h and ext/memory,
+   *  where it is wrapped as the temporary_buffer class.  See
+   *  temporary_buffer docs for more notes.
+   */
+  template<typename _ForwardIterator, typename _Tp>
+    class _Temporary_buffer
+    {
+      // concept requirements
+      __glibcxx_class_requires(_ForwardIterator, _ForwardIteratorConcept)
+
+    public:
+      typedef _Tp         value_type;
+      typedef value_type* pointer;
+      typedef pointer     iterator;
+      typedef ptrdiff_t   size_type;
+
+    protected:
+      size_type  _M_original_len;
+      size_type  _M_len;
+      pointer    _M_buffer;
+
+    public:
+      /// As per Table mumble.
+      size_type
+      size() const
+      { return _M_len; }
+
+      /// Returns the size requested by the constructor; may be >size().
+      size_type
+      requested_size() const
+      { return _M_original_len; }
+
+      /// As per Table mumble.
+      iterator
+      begin()
+      { return _M_buffer; }
+
+      /// As per Table mumble.
+      iterator
+      end()
+      { return _M_buffer + _M_len; }
+
+      /**
+       * Constructs a temporary buffer of a size somewhere between
+       * zero and the size of the given range.
+       */
+      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
+
+      ~_Temporary_buffer()
+      {
+	std::_Destroy(_M_buffer, _M_buffer + _M_len);
+	std::return_temporary_buffer(_M_buffer);
+      }
+
+    private:
+      // Disable copy constructor and assignment operator.
+      _Temporary_buffer(const _Temporary_buffer&);
+
+      void
+      operator=(const _Temporary_buffer&);
+    };
+
+
+  template<bool>
+    struct __uninitialized_construct_buf_dispatch
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer __first, _Pointer __last,
+	      _ForwardIterator __seed)
+        {
+	  if(__first == __last)
+	    return;
+
+	  _Pointer __cur = __first;
+	  __try
+	    {
+	      std::_Construct(std::__addressof(*__first),
+			      _GLIBCXX_MOVE(*__seed));
+	      _Pointer __prev = __cur;
+	      ++__cur;
+	      for(; __cur != __last; ++__cur, ++__prev)
+		std::_Construct(std::__addressof(*__cur),
+				_GLIBCXX_MOVE(*__prev));
+	      *__seed = _GLIBCXX_MOVE(*__prev);
+	    }
+	  __catch(...)
+	    {
+	      std::_Destroy(__first, __cur);
+	      __throw_exception_again;
+	    }
+	}
+    };
+
+  template<>
+    struct __uninitialized_construct_buf_dispatch<true>
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
+    };
+
+  // Constructs objects in the range [first, last).
+  // Note that while these new objects will take valid values,
+  // their exact value is not defined. In particular they may
+  // be 'moved from'.
+  //
+  // While *__seed may be altered during this algorithm, it will have
+  // the same value when the algorithm finishes, unless one of the
+  // constructions throws.
+  //
+  // Requirements: _Pointer::value_type(_Tp&&) is valid.
+  template<typename _Pointer, typename _ForwardIterator>
+    inline void
+    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
+				  _ForwardIterator __seed)
+    {
+      typedef typename std::iterator_traits<_Pointer>::value_type
+	_ValueType;
+
+      std::__uninitialized_construct_buf_dispatch<
+        __has_trivial_constructor(_ValueType)>::
+	  __ucr(__first, __last, __seed);
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    _Temporary_buffer<_ForwardIterator, _Tp>::
+    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+    : _M_original_len(std::distance(__first, __last)),
+      _M_len(0), _M_buffer(0)
+    {
+      __try
+	{
+	  std::pair<pointer, size_type> __p(std::get_temporary_buffer<
+					    value_type>(_M_original_len));
+	  _M_buffer = __p.first;
+	  _M_len = __p.second;
+	  if (_M_buffer)
+	    std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
+					       __first);
+	}
+      __catch(...)
+	{
+	  std::return_temporary_buffer(_M_buffer);
+	  _M_buffer = 0;
+	  _M_len = 0;
+	  __throw_exception_again;
+	}
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _STL_TEMPBUF_H */
+
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_tree.h b/gcc-4.9/libstdc++-v3/include/bits/stl_tree.h
new file mode 100644
index 0000000..4bc3c60
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_tree.h
@@ -0,0 +1,1987 @@
+// RB tree implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ */
+
+/** @file bits/stl_tree.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{map,set}
+ */
+
+#ifndef _STL_TREE_H
+#define _STL_TREE_H 1
+
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/stl_function.h>
+#include <bits/cpp_type_traits.h>
+#include <ext/alloc_traits.h>
+#if __cplusplus >= 201103L
+#include <ext/aligned_buffer.h>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Red-black tree class, designed for use in implementing STL
+  // associative containers (set, multiset, map, and multimap). The
+  // insertion and deletion algorithms are based on those in Cormen,
+  // Leiserson, and Rivest, Introduction to Algorithms (MIT Press,
+  // 1990), except that
+  //
+  // (1) the header cell is maintained with links not only to the root
+  // but also to the leftmost node of the tree, to enable constant
+  // time begin(), and to the rightmost node of the tree, to enable
+  // linear time performance when used with the generic set algorithms
+  // (set_union, etc.)
+  // 
+  // (2) when a node being deleted has two children its successor node
+  // is relinked into its place, rather than copied, so that the only
+  // iterators invalidated are those referring to the deleted node.
+
+  enum _Rb_tree_color { _S_red = false, _S_black = true };
+
+  struct _Rb_tree_node_base
+  {
+    typedef _Rb_tree_node_base* _Base_ptr;
+    typedef const _Rb_tree_node_base* _Const_Base_ptr;
+
+    _Rb_tree_color	_M_color;
+    _Base_ptr		_M_parent;
+    _Base_ptr		_M_left;
+    _Base_ptr		_M_right;
+
+    static _Base_ptr
+    _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+
+    static _Const_Base_ptr
+    _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+
+    static _Base_ptr
+    _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+
+    static _Const_Base_ptr
+    _S_maximum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+  };
+
+  template<typename _Val>
+    struct _Rb_tree_node : public _Rb_tree_node_base
+    {
+      typedef _Rb_tree_node<_Val>* _Link_type;
+
+#if __cplusplus < 201103L
+      _Val _M_value_field;
+
+      _Val*
+      _M_valptr()
+      { return std::__addressof(_M_value_field); }
+
+      const _Val*
+      _M_valptr() const
+      { return std::__addressof(_M_value_field); }
+#else
+      __gnu_cxx::__aligned_buffer<_Val> _M_storage;
+
+      _Val*
+      _M_valptr()
+      { return _M_storage._M_ptr(); }
+
+      const _Val*
+      _M_valptr() const
+      { return _M_storage._M_ptr(); }
+#endif
+    };
+
+  _GLIBCXX_PURE _Rb_tree_node_base*
+  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
+
+  _GLIBCXX_PURE const _Rb_tree_node_base*
+  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
+
+  _GLIBCXX_PURE _Rb_tree_node_base*
+  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
+
+  _GLIBCXX_PURE const _Rb_tree_node_base*
+  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
+
+  template<typename _Tp>
+    struct _Rb_tree_iterator
+    {
+      typedef _Tp  value_type;
+      typedef _Tp& reference;
+      typedef _Tp* pointer;
+
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t                  difference_type;
+
+      typedef _Rb_tree_iterator<_Tp>        _Self;
+      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
+      typedef _Rb_tree_node<_Tp>*           _Link_type;
+
+      _Rb_tree_iterator() _GLIBCXX_NOEXCEPT
+      : _M_node() { }
+
+      explicit
+      _Rb_tree_iterator(_Link_type __x) _GLIBCXX_NOEXCEPT
+      : _M_node(__x) { }
+
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT
+      { return static_cast<_Link_type> (_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _Rb_tree_increment(_M_node);
+	return *this;
+      }
+
+      _Self
+      operator++(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _Rb_tree_increment(_M_node);
+	return __tmp;
+      }
+
+      _Self&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _Rb_tree_decrement(_M_node);
+	return *this;
+      }
+
+      _Self
+      operator--(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _Rb_tree_decrement(_M_node);
+	return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node != __x._M_node; }
+
+      _Base_ptr _M_node;
+  };
+
+  template<typename _Tp>
+    struct _Rb_tree_const_iterator
+    {
+      typedef _Tp        value_type;
+      typedef const _Tp& reference;
+      typedef const _Tp* pointer;
+
+      typedef _Rb_tree_iterator<_Tp> iterator;
+
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t                  difference_type;
+
+      typedef _Rb_tree_const_iterator<_Tp>        _Self;
+      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
+      typedef const _Rb_tree_node<_Tp>*           _Link_type;
+
+      _Rb_tree_const_iterator() _GLIBCXX_NOEXCEPT
+      : _M_node() { }
+
+      explicit
+      _Rb_tree_const_iterator(_Link_type __x) _GLIBCXX_NOEXCEPT
+      : _M_node(__x) { }
+
+      _Rb_tree_const_iterator(const iterator& __it) _GLIBCXX_NOEXCEPT
+      : _M_node(__it._M_node) { }
+
+      iterator
+      _M_const_cast() const _GLIBCXX_NOEXCEPT
+      { return iterator(static_cast<typename iterator::_Link_type>
+			(const_cast<typename iterator::_Base_ptr>(_M_node))); }
+
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT
+      { return static_cast<_Link_type>(_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _Rb_tree_increment(_M_node);
+	return *this;
+      }
+
+      _Self
+      operator++(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _Rb_tree_increment(_M_node);
+	return __tmp;
+      }
+
+      _Self&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	_M_node = _Rb_tree_decrement(_M_node);
+	return *this;
+      }
+
+      _Self
+      operator--(int) _GLIBCXX_NOEXCEPT
+      {
+	_Self __tmp = *this;
+	_M_node = _Rb_tree_decrement(_M_node);
+	return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_node != __x._M_node; }
+
+      _Base_ptr _M_node;
+    };
+
+  template<typename _Val>
+    inline bool
+    operator==(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT
+    { return __x._M_node == __y._M_node; }
+
+  template<typename _Val>
+    inline bool
+    operator!=(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT
+    { return __x._M_node != __y._M_node; }
+
+  void
+  _Rb_tree_insert_and_rebalance(const bool __insert_left,
+                                _Rb_tree_node_base* __x,
+                                _Rb_tree_node_base* __p,
+                                _Rb_tree_node_base& __header) throw ();
+
+  _Rb_tree_node_base*
+  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
+			       _Rb_tree_node_base& __header) throw ();
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc = allocator<_Val> >
+    class _Rb_tree
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
+
+      typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;
+
+    protected:
+      typedef _Rb_tree_node_base* 		_Base_ptr;
+      typedef const _Rb_tree_node_base* 	_Const_Base_ptr;
+
+    public:
+      typedef _Key 				key_type;
+      typedef _Val 				value_type;
+      typedef value_type* 			pointer;
+      typedef const value_type* 		const_pointer;
+      typedef value_type& 			reference;
+      typedef const value_type& 		const_reference;
+      typedef _Rb_tree_node<_Val>* 		_Link_type;
+      typedef const _Rb_tree_node<_Val>*	_Const_Link_type;
+      typedef size_t 				size_type;
+      typedef ptrdiff_t 			difference_type;
+      typedef _Alloc 				allocator_type;
+
+      _Node_allocator&
+      _M_get_Node_allocator() _GLIBCXX_NOEXCEPT
+      { return *static_cast<_Node_allocator*>(&this->_M_impl); }
+      
+      const _Node_allocator&
+      _M_get_Node_allocator() const _GLIBCXX_NOEXCEPT
+      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_get_Node_allocator()); }
+
+    protected:
+      _Link_type
+      _M_get_node()
+      { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }
+
+      void
+      _M_put_node(_Link_type __p) _GLIBCXX_NOEXCEPT
+      { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }
+
+#if __cplusplus < 201103L
+      _Link_type
+      _M_create_node(const value_type& __x)
+      {
+	_Link_type __tmp = _M_get_node();
+	__try
+	  { get_allocator().construct(__tmp->_M_valptr(), __x); }
+	__catch(...)
+	  {
+	    _M_put_node(__tmp);
+	    __throw_exception_again;
+	  }
+	return __tmp;
+      }
+
+      void
+      _M_destroy_node(_Link_type __p)
+      {
+	get_allocator().destroy(__p->_M_valptr());
+	_M_put_node(__p);
+      }
+#else
+      template<typename... _Args>
+        _Link_type
+        _M_create_node(_Args&&... __args)
+	{
+	  _Link_type __tmp = _M_get_node();
+	  __try
+	    {
+	      ::new(__tmp) _Rb_tree_node<_Val>;
+	      _Alloc_traits::construct(_M_get_Node_allocator(),
+				       __tmp->_M_valptr(),
+				       std::forward<_Args>(__args)...);
+	    }
+	  __catch(...)
+	    {
+	      _M_put_node(__tmp);
+	      __throw_exception_again;
+	    }
+	  return __tmp;
+	}
+
+      void
+      _M_destroy_node(_Link_type __p) noexcept
+      {
+	_Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
+	__p->~_Rb_tree_node<_Val>();
+	_M_put_node(__p);
+      }
+#endif
+
+      _Link_type
+      _M_clone_node(_Const_Link_type __x)
+      {
+	_Link_type __tmp = _M_create_node(*__x->_M_valptr());
+	__tmp->_M_color = __x->_M_color;
+	__tmp->_M_left = 0;
+	__tmp->_M_right = 0;
+	return __tmp;
+      }
+
+    protected:
+      template<typename _Key_compare, 
+	       bool _Is_pod_comparator = __is_pod(_Key_compare)>
+        struct _Rb_tree_impl : public _Node_allocator
+        {
+	  _Key_compare		_M_key_compare;
+	  _Rb_tree_node_base 	_M_header;
+	  size_type 		_M_node_count; // Keeps track of size of tree.
+
+	  _Rb_tree_impl()
+	  : _Node_allocator(), _M_key_compare(), _M_header(),
+	    _M_node_count(0)
+	  { _M_initialize(); }
+
+	  _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
+	  : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
+	    _M_node_count(0)
+	  { _M_initialize(); }
+
+#if __cplusplus >= 201103L
+	  _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
+	  : _Node_allocator(std::move(__a)), _M_key_compare(__comp),
+	    _M_header(), _M_node_count(0)
+	  { _M_initialize(); }
+#endif
+
+	private:
+	  void
+	  _M_initialize()
+	  {
+	    this->_M_header._M_color = _S_red;
+	    this->_M_header._M_parent = 0;
+	    this->_M_header._M_left = &this->_M_header;
+	    this->_M_header._M_right = &this->_M_header;
+	  }	    
+	};
+
+      _Rb_tree_impl<_Compare> _M_impl;
+
+    protected:
+      _Base_ptr&
+      _M_root() _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_header._M_parent; }
+
+      _Const_Base_ptr
+      _M_root() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_header._M_parent; }
+
+      _Base_ptr&
+      _M_leftmost() _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_header._M_left; }
+
+      _Const_Base_ptr
+      _M_leftmost() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_header._M_left; }
+
+      _Base_ptr&
+      _M_rightmost() _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_header._M_right; }
+
+      _Const_Base_ptr
+      _M_rightmost() const _GLIBCXX_NOEXCEPT
+      { return this->_M_impl._M_header._M_right; }
+
+      _Link_type
+      _M_begin() _GLIBCXX_NOEXCEPT
+      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
+
+      _Const_Link_type
+      _M_begin() const _GLIBCXX_NOEXCEPT
+      {
+	return static_cast<_Const_Link_type>
+	  (this->_M_impl._M_header._M_parent);
+      }
+
+      _Link_type
+      _M_end() _GLIBCXX_NOEXCEPT
+      { return static_cast<_Link_type>(&this->_M_impl._M_header); }
+
+      _Const_Link_type
+      _M_end() const _GLIBCXX_NOEXCEPT
+      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
+
+      static const_reference
+      _S_value(_Const_Link_type __x)
+      { return *__x->_M_valptr(); }
+
+      static const _Key&
+      _S_key(_Const_Link_type __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+
+      static _Link_type
+      _S_left(_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return static_cast<_Link_type>(__x->_M_left); }
+
+      static _Const_Link_type
+      _S_left(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return static_cast<_Const_Link_type>(__x->_M_left); }
+
+      static _Link_type
+      _S_right(_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return static_cast<_Link_type>(__x->_M_right); }
+
+      static _Const_Link_type
+      _S_right(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return static_cast<_Const_Link_type>(__x->_M_right); }
+
+      static const_reference
+      _S_value(_Const_Base_ptr __x)
+      { return *static_cast<_Const_Link_type>(__x)->_M_valptr(); }
+
+      static const _Key&
+      _S_key(_Const_Base_ptr __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+
+      static _Base_ptr
+      _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+
+      static _Const_Base_ptr
+      _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+
+      static _Base_ptr
+      _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+
+      static _Const_Base_ptr
+      _S_maximum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+
+    public:
+      typedef _Rb_tree_iterator<value_type>       iterator;
+      typedef _Rb_tree_const_iterator<value_type> const_iterator;
+
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    private:
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_unique_pos(const key_type& __k);
+
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_equal_pos(const key_type& __k);
+
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_hint_unique_pos(const_iterator __pos,
+				    const key_type& __k);
+
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_hint_equal_pos(const_iterator __pos,
+				   const key_type& __k);
+
+#if __cplusplus >= 201103L
+      template<typename _Arg>
+        iterator
+        _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v);
+
+      iterator
+      _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_lower(_Base_ptr __y, _Arg&& __v);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_equal_lower(_Arg&& __x);
+
+      iterator
+      _M_insert_lower_node(_Base_ptr __p, _Link_type __z);
+
+      iterator
+      _M_insert_equal_lower_node(_Link_type __z);
+#else
+      iterator
+      _M_insert_(_Base_ptr __x, _Base_ptr __y,
+		 const value_type& __v);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 233. Insertion hints in associative containers.
+      iterator
+      _M_insert_lower(_Base_ptr __y, const value_type& __v);
+
+      iterator
+      _M_insert_equal_lower(const value_type& __x);
+#endif
+
+      _Link_type
+      _M_copy(_Const_Link_type __x, _Link_type __p);
+
+      void
+      _M_erase(_Link_type __x);
+
+      iterator
+      _M_lower_bound(_Link_type __x, _Link_type __y,
+		     const _Key& __k);
+
+      const_iterator
+      _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+		     const _Key& __k) const;
+
+      iterator
+      _M_upper_bound(_Link_type __x, _Link_type __y,
+		     const _Key& __k);
+
+      const_iterator
+      _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+		     const _Key& __k) const;
+
+    public:
+      // allocation/deallocation
+      _Rb_tree() { }
+
+      _Rb_tree(const _Compare& __comp,
+	       const allocator_type& __a = allocator_type())
+      : _M_impl(__comp, _Node_allocator(__a)) { }
+
+      _Rb_tree(const _Rb_tree& __x)
+      : _M_impl(__x._M_impl._M_key_compare,
+	        _Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator()))
+      {
+	if (__x._M_root() != 0)
+	  {
+	    _M_root() = _M_copy(__x._M_begin(), _M_end());
+	    _M_leftmost() = _S_minimum(_M_root());
+	    _M_rightmost() = _S_maximum(_M_root());
+	    _M_impl._M_node_count = __x._M_impl._M_node_count;
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      _Rb_tree(const allocator_type& __a)
+      : _M_impl(_Compare(), _Node_allocator(__a))
+      { }
+
+      _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
+      : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
+      {
+	if (__x._M_root() != 0)
+	  {
+	    _M_root() = _M_copy(__x._M_begin(), _M_end());
+	    _M_leftmost() = _S_minimum(_M_root());
+	    _M_rightmost() = _S_maximum(_M_root());
+	    _M_impl._M_node_count = __x._M_impl._M_node_count;
+	  }
+      }
+
+      _Rb_tree(_Rb_tree&& __x)
+      : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
+      {
+	if (__x._M_root() != 0)
+	  _M_move_data(__x, std::true_type());
+      }
+
+      _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
+      : _Rb_tree(std::move(__x), _Node_allocator(__a))
+      { }
+
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a);
+#endif
+
+      ~_Rb_tree() _GLIBCXX_NOEXCEPT
+      { _M_erase(_M_begin()); }
+
+      _Rb_tree&
+      operator=(const _Rb_tree& __x);
+
+      // Accessors.
+      _Compare
+      key_comp() const
+      { return _M_impl._M_key_compare; }
+
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { 
+	return iterator(static_cast<_Link_type>
+			(this->_M_impl._M_header._M_left));
+      }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { 
+	return const_iterator(static_cast<_Const_Link_type>
+			      (this->_M_impl._M_header._M_left));
+      }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { 
+	return const_iterator(static_cast<_Const_Link_type>
+			      (&this->_M_impl._M_header));
+      }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return _M_impl._M_node_count == 0; }
+
+      size_type
+      size() const _GLIBCXX_NOEXCEPT 
+      { return _M_impl._M_node_count; }
+
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _Alloc_traits::max_size(_M_get_Node_allocator()); }
+
+      void
+#if __cplusplus >= 201103L
+      swap(_Rb_tree& __t) noexcept(_Alloc_traits::_S_nothrow_swap());
+#else
+      swap(_Rb_tree& __t);
+#endif
+
+      // Insert/erase.
+#if __cplusplus >= 201103L
+      template<typename _Arg>
+        pair<iterator, bool>
+        _M_insert_unique(_Arg&& __x);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_equal(_Arg&& __x);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_unique_(const_iterator __position, _Arg&& __x);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_equal_(const_iterator __position, _Arg&& __x);
+
+      template<typename... _Args>
+	pair<iterator, bool>
+	_M_emplace_unique(_Args&&... __args);
+
+      template<typename... _Args>
+	iterator
+	_M_emplace_equal(_Args&&... __args);
+
+      template<typename... _Args>
+	iterator
+	_M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
+
+      template<typename... _Args>
+	iterator
+	_M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
+#else
+      pair<iterator, bool>
+      _M_insert_unique(const value_type& __x);
+
+      iterator
+      _M_insert_equal(const value_type& __x);
+
+      iterator
+      _M_insert_unique_(const_iterator __position, const value_type& __x);
+
+      iterator
+      _M_insert_equal_(const_iterator __position, const value_type& __x);
+#endif
+
+      template<typename _InputIterator>
+        void
+        _M_insert_unique(_InputIterator __first, _InputIterator __last);
+
+      template<typename _InputIterator>
+        void
+        _M_insert_equal(_InputIterator __first, _InputIterator __last);
+
+    private:
+      void
+      _M_erase_aux(const_iterator __position);
+
+      void
+      _M_erase_aux(const_iterator __first, const_iterator __last);
+
+    public:
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(const_iterator __position)
+      {
+	const_iterator __result = __position;
+	++__result;
+	_M_erase_aux(__position);
+	return __result._M_const_cast();
+      }
+
+      // LWG 2059.
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(iterator __position)
+      {
+	iterator __result = __position;
+	++__result;
+	_M_erase_aux(__position);
+	return __result;
+      }
+#else
+      void
+      erase(iterator __position)
+      { _M_erase_aux(__position); }
+
+      void
+      erase(const_iterator __position)
+      { _M_erase_aux(__position); }
+#endif
+      size_type
+      erase(const key_type& __x);
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      _GLIBCXX_ABI_TAG_CXX11
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	_M_erase_aux(__first, __last);
+	return __last._M_const_cast();
+      }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      { _M_erase_aux(__first, __last); }
+
+      void
+      erase(const_iterator __first, const_iterator __last)
+      { _M_erase_aux(__first, __last); }
+#endif
+      void
+      erase(const key_type* __first, const key_type* __last);
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+        _M_erase(_M_begin());
+        _M_leftmost() = _M_end();
+        _M_root() = 0;
+        _M_rightmost() = _M_end();
+        _M_impl._M_node_count = 0;
+      }
+
+      // Set operations.
+      iterator
+      find(const key_type& __k);
+
+      const_iterator
+      find(const key_type& __k) const;
+
+      size_type
+      count(const key_type& __k) const;
+
+      iterator
+      lower_bound(const key_type& __k)
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+
+      const_iterator
+      lower_bound(const key_type& __k) const
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+
+      iterator
+      upper_bound(const key_type& __k)
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+
+      const_iterator
+      upper_bound(const key_type& __k) const
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __k);
+
+      pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+
+      // Debugging.
+      bool
+      __rb_verify() const;
+
+#if __cplusplus >= 201103L
+      bool
+      _M_move_assign(_Rb_tree&);
+
+    private:
+      // Move elements from container with equal allocator.
+      void
+      _M_move_data(_Rb_tree&, std::true_type);
+
+      // Move elements from container with possibly non-equal allocator,
+      // which might result in a copy not a move.
+      void
+      _M_move_data(_Rb_tree&, std::false_type);
+#endif
+    };
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+	       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return __x.size() == __y.size()
+	     && std::equal(__x.begin(), __x.end(), __y.begin());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+	      const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return std::lexicographical_compare(__x.begin(), __x.end(), 
+					  __y.begin(), __y.end());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+	       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+	      const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+	       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+	       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline void
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+	 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+#if __cplusplus >= 201103L
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
+    : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
+    {
+      using __eq = integral_constant<bool, _Alloc_traits::_S_always_equal()>;
+      if (__x._M_root() != 0)
+	_M_move_data(__x, __eq());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_data(_Rb_tree& __x, std::true_type)
+    {
+      _M_root() = __x._M_root();
+      _M_leftmost() = __x._M_leftmost();
+      _M_rightmost() = __x._M_rightmost();
+      _M_root()->_M_parent = _M_end();
+
+      __x._M_root() = 0;
+      __x._M_leftmost() = __x._M_end();
+      __x._M_rightmost() = __x._M_end();
+
+      this->_M_impl._M_node_count = __x._M_impl._M_node_count;
+      __x._M_impl._M_node_count = 0;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_data(_Rb_tree& __x, std::false_type)
+    {
+      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
+	  _M_move_data(__x, std::true_type());
+      else
+	{
+	  _M_root() = _M_copy(__x._M_begin(), _M_end());
+	  _M_leftmost() = _S_minimum(_M_root());
+	  _M_rightmost() = _S_maximum(_M_root());
+	  _M_impl._M_node_count = __x._M_impl._M_node_count;
+	}
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    bool
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_assign(_Rb_tree& __x)
+    {
+      if (_Alloc_traits::_S_propagate_on_move_assign()
+	  || _Alloc_traits::_S_always_equal()
+	  || _M_get_Node_allocator() == __x._M_get_Node_allocator())
+	{
+	  clear();
+	  if (__x._M_root() != 0)
+	    _M_move_data(__x, std::true_type());
+	  std::__alloc_on_move(_M_get_Node_allocator(),
+			       __x._M_get_Node_allocator());
+	  return true;
+	}
+      return false;
+    }
+#endif
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    operator=(const _Rb_tree& __x)
+    {
+      if (this != &__x)
+	{
+	  // Note that _Key may be a constant type.
+	  clear();
+#if __cplusplus >= 201103L
+	  if (_Alloc_traits::_S_propagate_on_copy_assign())
+	    {
+	      auto& __this_alloc = this->_M_get_Node_allocator();
+	      auto& __that_alloc = __x._M_get_Node_allocator();
+	      if (!_Alloc_traits::_S_always_equal()
+		  && __this_alloc != __that_alloc)
+		{
+		  std::__alloc_on_copy(__this_alloc, __that_alloc);
+		}
+	    }
+#endif
+	  _M_impl._M_key_compare = __x._M_impl._M_key_compare;
+	  if (__x._M_root() != 0)
+	    {
+	      _M_root() = _M_copy(__x._M_begin(), _M_end());
+	      _M_leftmost() = _S_minimum(_M_root());
+	      _M_rightmost() = _S_maximum(_M_root());
+	      _M_impl._M_node_count = __x._M_impl._M_node_count;
+	    }
+	}
+      return *this;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename _Arg>
+#endif
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#if __cplusplus >= 201103L
+    _M_insert_(_Base_ptr __x, _Base_ptr __p, _Arg&& __v)
+#else
+    _M_insert_(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
+#endif
+    {
+      bool __insert_left = (__x != 0 || __p == _M_end()
+			    || _M_impl._M_key_compare(_KeyOfValue()(__v),
+						      _S_key(__p)));
+
+      _Link_type __z = _M_create_node(_GLIBCXX_FORWARD(_Arg, __v));
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+				    this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename _Arg>
+#endif
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#if __cplusplus >= 201103L
+    _M_insert_lower(_Base_ptr __p, _Arg&& __v)
+#else
+    _M_insert_lower(_Base_ptr __p, const _Val& __v)
+#endif
+    {
+      bool __insert_left = (__p == _M_end()
+			    || !_M_impl._M_key_compare(_S_key(__p),
+						       _KeyOfValue()(__v)));
+
+      _Link_type __z = _M_create_node(_GLIBCXX_FORWARD(_Arg, __v));
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+				    this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename _Arg>
+#endif
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#if __cplusplus >= 201103L
+    _M_insert_equal_lower(_Arg&& __v)
+#else
+    _M_insert_equal_lower(const _Val& __v)
+#endif
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+	{
+	  __y = __x;
+	  __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
+	        _S_left(__x) : _S_right(__x);
+	}
+      return _M_insert_lower(__y, _GLIBCXX_FORWARD(_Arg, __v));
+    }
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
+    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
+    _M_copy(_Const_Link_type __x, _Link_type __p)
+    {
+      // Structural copy.  __x and __p must be non-null.
+      _Link_type __top = _M_clone_node(__x);
+      __top->_M_parent = __p;
+
+      __try
+	{
+	  if (__x->_M_right)
+	    __top->_M_right = _M_copy(_S_right(__x), __top);
+	  __p = __top;
+	  __x = _S_left(__x);
+
+	  while (__x != 0)
+	    {
+	      _Link_type __y = _M_clone_node(__x);
+	      __p->_M_left = __y;
+	      __y->_M_parent = __p;
+	      if (__x->_M_right)
+		__y->_M_right = _M_copy(_S_right(__x), __y);
+	      __p = __y;
+	      __x = _S_left(__x);
+	    }
+	}
+      __catch(...)
+	{
+	  _M_erase(__top);
+	  __throw_exception_again;
+	}
+      return __top;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase(_Link_type __x)
+    {
+      // Erase without rebalancing.
+      while (__x != 0)
+	{
+	  _M_erase(_S_right(__x));
+	  _Link_type __y = _S_left(__x);
+	  _M_destroy_node(__x);
+	  __x = __y;
+	}
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+		      _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Link_type __x, _Link_type __y,
+		   const _Key& __k)
+    {
+      while (__x != 0)
+	if (!_M_impl._M_key_compare(_S_key(__x), __k))
+	  __y = __x, __x = _S_left(__x);
+	else
+	  __x = _S_right(__x);
+      return iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+		      _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+		   const _Key& __k) const
+    {
+      while (__x != 0)
+	if (!_M_impl._M_key_compare(_S_key(__x), __k))
+	  __y = __x, __x = _S_left(__x);
+	else
+	  __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+		      _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Link_type __x, _Link_type __y,
+		   const _Key& __k)
+    {
+      while (__x != 0)
+	if (_M_impl._M_key_compare(__k, _S_key(__x)))
+	  __y = __x, __x = _S_left(__x);
+	else
+	  __x = _S_right(__x);
+      return iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+		      _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+		   const _Key& __k) const
+    {
+      while (__x != 0)
+	if (_M_impl._M_key_compare(__k, _S_key(__x)))
+	  __y = __x, __x = _S_left(__x);
+	else
+	  __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::iterator,
+	 typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+	{
+	  if (_M_impl._M_key_compare(_S_key(__x), __k))
+	    __x = _S_right(__x);
+	  else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+	    __y = __x, __x = _S_left(__x);
+	  else
+	    {
+	      _Link_type __xu(__x), __yu(__y);
+	      __y = __x, __x = _S_left(__x);
+	      __xu = _S_right(__xu);
+	      return pair<iterator,
+		          iterator>(_M_lower_bound(__x, __y, __k),
+				    _M_upper_bound(__xu, __yu, __k));
+	    }
+	}
+      return pair<iterator, iterator>(iterator(__y),
+				      iterator(__y));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::const_iterator,
+	 typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::const_iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k) const
+    {
+      _Const_Link_type __x = _M_begin();
+      _Const_Link_type __y = _M_end();
+      while (__x != 0)
+	{
+	  if (_M_impl._M_key_compare(_S_key(__x), __k))
+	    __x = _S_right(__x);
+	  else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+	    __y = __x, __x = _S_left(__x);
+	  else
+	    {
+	      _Const_Link_type __xu(__x), __yu(__y);
+	      __y = __x, __x = _S_left(__x);
+	      __xu = _S_right(__xu);
+	      return pair<const_iterator,
+		          const_iterator>(_M_lower_bound(__x, __y, __k),
+					  _M_upper_bound(__xu, __yu, __k));
+	    }
+	}
+      return pair<const_iterator, const_iterator>(const_iterator(__y),
+						  const_iterator(__y));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
+#if __cplusplus >= 201103L
+    noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+    {
+      if (_M_root() == 0)
+	{
+	  if (__t._M_root() != 0)
+	    {
+	      _M_root() = __t._M_root();
+	      _M_leftmost() = __t._M_leftmost();
+	      _M_rightmost() = __t._M_rightmost();
+	      _M_root()->_M_parent = _M_end();
+	      
+	      __t._M_root() = 0;
+	      __t._M_leftmost() = __t._M_end();
+	      __t._M_rightmost() = __t._M_end();
+	    }
+	}
+      else if (__t._M_root() == 0)
+	{
+	  __t._M_root() = _M_root();
+	  __t._M_leftmost() = _M_leftmost();
+	  __t._M_rightmost() = _M_rightmost();
+	  __t._M_root()->_M_parent = __t._M_end();
+	  
+	  _M_root() = 0;
+	  _M_leftmost() = _M_end();
+	  _M_rightmost() = _M_end();
+	}
+      else
+	{
+	  std::swap(_M_root(),__t._M_root());
+	  std::swap(_M_leftmost(),__t._M_leftmost());
+	  std::swap(_M_rightmost(),__t._M_rightmost());
+	  
+	  _M_root()->_M_parent = _M_end();
+	  __t._M_root()->_M_parent = __t._M_end();
+	}
+      // No need to swap header's color as it does not change.
+      std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
+      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
+
+      _Alloc_traits::_S_on_swap(_M_get_Node_allocator(),
+				__t._M_get_Node_allocator());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr,
+	 typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_unique_pos(const key_type& __k)
+    {
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      bool __comp = true;
+      while (__x != 0)
+	{
+	  __y = __x;
+	  __comp = _M_impl._M_key_compare(__k, _S_key(__x));
+	  __x = __comp ? _S_left(__x) : _S_right(__x);
+	}
+      iterator __j = iterator(__y);
+      if (__comp)
+	{
+	  if (__j == begin())
+	    return _Res(__x, __y);
+	  else
+	    --__j;
+	}
+      if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
+	return _Res(__x, __y);
+      return _Res(__j._M_node, 0);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr,
+	 typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_equal_pos(const key_type& __k)
+    {
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+	{
+	  __y = __x;
+	  __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
+	        _S_left(__x) : _S_right(__x);
+	}
+      return _Res(__x, __y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename _Arg>
+#endif
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::iterator, bool>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#if __cplusplus >= 201103L
+    _M_insert_unique(_Arg&& __v)
+#else
+    _M_insert_unique(const _Val& __v)
+#endif
+    {
+      typedef pair<iterator, bool> _Res;
+      pair<_Base_ptr, _Base_ptr> __res
+	= _M_get_insert_unique_pos(_KeyOfValue()(__v));
+
+      if (__res.second)
+	return _Res(_M_insert_(__res.first, __res.second,
+			       _GLIBCXX_FORWARD(_Arg, __v)),
+		    true);
+
+      return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename _Arg>
+#endif
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#if __cplusplus >= 201103L
+    _M_insert_equal(_Arg&& __v)
+#else
+    _M_insert_equal(const _Val& __v)
+#endif
+    {
+      pair<_Base_ptr, _Base_ptr> __res
+	= _M_get_insert_equal_pos(_KeyOfValue()(__v));
+      return _M_insert_(__res.first, __res.second, _GLIBCXX_FORWARD(_Arg, __v));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr,
+         typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_hint_unique_pos(const_iterator __position,
+				  const key_type& __k)
+    {
+      iterator __pos = __position._M_const_cast();
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+
+      // end()
+      if (__pos._M_node == _M_end())
+	{
+	  if (size() > 0
+	      && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
+	    return _Res(0, _M_rightmost());
+	  else
+	    return _M_get_insert_unique_pos(__k);
+	}
+      else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
+	{
+	  // First, try before...
+	  iterator __before = __pos;
+	  if (__pos._M_node == _M_leftmost()) // begin()
+	    return _Res(_M_leftmost(), _M_leftmost());
+	  else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
+	    {
+	      if (_S_right(__before._M_node) == 0)
+		return _Res(0, __before._M_node);
+	      else
+		return _Res(__pos._M_node, __pos._M_node);
+	    }
+	  else
+	    return _M_get_insert_unique_pos(__k);
+	}
+      else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
+	{
+	  // ... then try after.
+	  iterator __after = __pos;
+	  if (__pos._M_node == _M_rightmost())
+	    return _Res(0, _M_rightmost());
+	  else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
+	    {
+	      if (_S_right(__pos._M_node) == 0)
+		return _Res(0, __pos._M_node);
+	      else
+		return _Res(__after._M_node, __after._M_node);
+	    }
+	  else
+	    return _M_get_insert_unique_pos(__k);
+	}
+      else
+	// Equivalent keys.
+	return _Res(__pos._M_node, 0);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename _Arg>
+#endif
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#if __cplusplus >= 201103L
+    _M_insert_unique_(const_iterator __position, _Arg&& __v)
+#else
+    _M_insert_unique_(const_iterator __position, const _Val& __v)
+#endif
+    {
+      pair<_Base_ptr, _Base_ptr> __res
+	= _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
+
+      if (__res.second)
+	return _M_insert_(__res.first, __res.second,
+			  _GLIBCXX_FORWARD(_Arg, __v));
+      return iterator(static_cast<_Link_type>(__res.first));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr,
+         typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			   _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
+    {
+      iterator __pos = __position._M_const_cast();
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+
+      // end()
+      if (__pos._M_node == _M_end())
+	{
+	  if (size() > 0
+	      && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
+	    return _Res(0, _M_rightmost());
+	  else
+	    return _M_get_insert_equal_pos(__k);
+	}
+      else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
+	{
+	  // First, try before...
+	  iterator __before = __pos;
+	  if (__pos._M_node == _M_leftmost()) // begin()
+	    return _Res(_M_leftmost(), _M_leftmost());
+	  else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
+	    {
+	      if (_S_right(__before._M_node) == 0)
+		return _Res(0, __before._M_node);
+	      else
+		return _Res(__pos._M_node, __pos._M_node);
+	    }
+	  else
+	    return _M_get_insert_equal_pos(__k);
+	}
+      else
+	{
+	  // ... then try after.  
+	  iterator __after = __pos;
+	  if (__pos._M_node == _M_rightmost())
+	    return _Res(0, _M_rightmost());
+	  else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
+	    {
+	      if (_S_right(__pos._M_node) == 0)
+		return _Res(0, __pos._M_node);
+	      else
+		return _Res(__after._M_node, __after._M_node);
+	    }
+	  else
+	    return _Res(0, 0);
+	}
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+#if __cplusplus >= 201103L
+    template<typename _Arg>
+#endif
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#if __cplusplus >= 201103L
+    _M_insert_equal_(const_iterator __position, _Arg&& __v)
+#else
+    _M_insert_equal_(const_iterator __position, const _Val& __v)
+#endif
+    {
+      pair<_Base_ptr, _Base_ptr> __res
+	= _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
+
+      if (__res.second)
+	return _M_insert_(__res.first, __res.second,
+			  _GLIBCXX_FORWARD(_Arg, __v));
+
+      return _M_insert_equal_lower(_GLIBCXX_FORWARD(_Arg, __v));
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
+    {
+      bool __insert_left = (__x != 0 || __p == _M_end()
+			    || _M_impl._M_key_compare(_S_key(__z),
+						      _S_key(__p)));
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+				    this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
+    {
+      bool __insert_left = (__p == _M_end()
+			    || !_M_impl._M_key_compare(_S_key(__p),
+						       _S_key(__z)));
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+				    this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal_lower_node(_Link_type __z)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+	{
+	  __y = __x;
+	  __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
+	        _S_left(__x) : _S_right(__x);
+	}
+      return _M_insert_lower_node(__y, __z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+			     _Compare, _Alloc>::iterator, bool>
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_unique(_Args&&... __args)
+      {
+	_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+	__try
+	  {
+	    typedef pair<iterator, bool> _Res;
+	    auto __res = _M_get_insert_unique_pos(_S_key(__z));
+	    if (__res.second)
+	      return _Res(_M_insert_node(__res.first, __res.second, __z), true);
+	
+	    _M_destroy_node(__z);
+	    return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
+	  }
+	__catch(...)
+	  {
+	    _M_destroy_node(__z);
+	    __throw_exception_again;
+	  }
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_equal(_Args&&... __args)
+      {
+	_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+	__try
+	  {
+	    auto __res = _M_get_insert_equal_pos(_S_key(__z));
+	    return _M_insert_node(__res.first, __res.second, __z);
+	  }
+	__catch(...)
+	  {
+	    _M_destroy_node(__z);
+	    __throw_exception_again;
+	  }
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
+      {
+	_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+	__try
+	  {
+	    auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z));
+
+	    if (__res.second)
+	      return _M_insert_node(__res.first, __res.second, __z);
+
+	    _M_destroy_node(__z);
+	    return iterator(static_cast<_Link_type>(__res.first));
+	  }
+	__catch(...)
+	  {
+	    _M_destroy_node(__z);
+	    __throw_exception_again;
+	  }
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
+      {
+	_Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+	__try
+	  {
+	    auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z));
+
+	    if (__res.second)
+	      return _M_insert_node(__res.first, __res.second, __z);
+
+	    return _M_insert_equal_lower_node(__z);
+	  }
+	__catch(...)
+	  {
+	    _M_destroy_node(__z);
+	    __throw_exception_again;
+	  }
+      }
+#endif
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_unique(_II __first, _II __last)
+      {
+	for (; __first != __last; ++__first)
+	  _M_insert_unique_(end(), *__first);
+      }
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_equal(_II __first, _II __last)
+      {
+	for (; __first != __last; ++__first)
+	  _M_insert_equal_(end(), *__first);
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase_aux(const_iterator __position)
+    {
+      _Link_type __y =
+	static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
+				(const_cast<_Base_ptr>(__position._M_node),
+				 this->_M_impl._M_header));
+      _M_destroy_node(__y);
+      --_M_impl._M_node_count;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase_aux(const_iterator __first, const_iterator __last)
+    {
+      if (__first == begin() && __last == end())
+	clear();
+      else
+	while (__first != __last)
+	  erase(__first++);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key& __x)
+    {
+      pair<iterator, iterator> __p = equal_range(__x);
+      const size_type __old_size = size();
+      erase(__p.first, __p.second);
+      return __old_size - size();
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key* __first, const _Key* __last)
+    {
+      while (__first != __last)
+	erase(*__first++);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+		      _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k)
+    {
+      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+	      || _M_impl._M_key_compare(__k,
+					_S_key(__j._M_node))) ? end() : __j;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+		      _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k) const
+    {
+      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+	      || _M_impl._M_key_compare(__k, 
+					_S_key(__j._M_node))) ? end() : __j;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    count(const _Key& __k) const
+    {
+      pair<const_iterator, const_iterator> __p = equal_range(__k);
+      const size_type __n = std::distance(__p.first, __p.second);
+      return __n;
+    }
+
+  _GLIBCXX_PURE unsigned int
+  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
+                       const _Rb_tree_node_base* __root) throw ();
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    bool
+    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
+    {
+      if (_M_impl._M_node_count == 0 || begin() == end())
+	return _M_impl._M_node_count == 0 && begin() == end()
+	       && this->_M_impl._M_header._M_left == _M_end()
+	       && this->_M_impl._M_header._M_right == _M_end();
+
+      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
+      for (const_iterator __it = begin(); __it != end(); ++__it)
+	{
+	  _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
+	  _Const_Link_type __L = _S_left(__x);
+	  _Const_Link_type __R = _S_right(__x);
+
+	  if (__x->_M_color == _S_red)
+	    if ((__L && __L->_M_color == _S_red)
+		|| (__R && __R->_M_color == _S_red))
+	      return false;
+
+	  if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
+	    return false;
+	  if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
+	    return false;
+
+	  if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
+	    return false;
+	}
+
+      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
+	return false;
+      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
+	return false;
+      return true;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_uninitialized.h b/gcc-4.9/libstdc++-v3/include/bits/stl_uninitialized.h
new file mode 100644
index 0000000..cd2a482
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_uninitialized.h
@@ -0,0 +1,682 @@
+// Raw memory manipulators -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_uninitialized.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _STL_UNINITIALIZED_H
+#define _STL_UNINITIALIZED_H 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<bool _TrivialValueTypes>
+    struct __uninitialized_copy
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+		      _ForwardIterator __result)
+        {
+	  _ForwardIterator __cur = __result;
+	  __try
+	    {
+	      for (; __first != __last; ++__first, ++__cur)
+		std::_Construct(std::__addressof(*__cur), *__first);
+	      return __cur;
+	    }
+	  __catch(...)
+	    {
+	      std::_Destroy(__result, __cur);
+	      __throw_exception_again;
+	    }
+	}
+    };
+
+  template<>
+    struct __uninitialized_copy<true>
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+		      _ForwardIterator __result)
+        { return std::copy(__first, __last, __result); }
+    };
+
+  /**
+   *  @brief Copies the range [first,last) into result.
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __result An output iterator.
+   *  @return   __result + (__first - __last)
+   *
+   *  Like copy(), but does not require an initialized output range.
+  */
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last,
+		       _ForwardIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+	_ValueType1;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType2;
+#if __cplusplus < 201103L
+      const bool __assignable = true;
+#else
+      // trivial types can have deleted assignment
+      typedef typename iterator_traits<_InputIterator>::reference _RefType;
+      const bool __assignable = is_assignable<_ValueType1, _RefType>::value;
+#endif
+
+      return std::__uninitialized_copy<__is_trivial(_ValueType1)
+				       && __is_trivial(_ValueType2)
+				       && __assignable>::
+	__uninit_copy(__first, __last, __result);
+    }
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+		      const _Tp& __x)
+        {
+	  _ForwardIterator __cur = __first;
+	  __try
+	    {
+	      for (; __cur != __last; ++__cur)
+		std::_Construct(std::__addressof(*__cur), __x);
+	    }
+	  __catch(...)
+	    {
+	      std::_Destroy(__first, __cur);
+	      __throw_exception_again;
+	    }
+	}
+    };
+
+  template<>
+    struct __uninitialized_fill<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+		      const _Tp& __x)
+        { std::fill(__first, __last, __x); }
+    };
+
+  /**
+   *  @brief Copies the value x into the range [first,last).
+   *  @param  __first  An input iterator.
+   *  @param  __last   An input iterator.
+   *  @param  __x      The source value.
+   *  @return   Nothing.
+   *
+   *  Like fill(), but does not require an initialized output range.
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
+		       const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+#if __cplusplus < 201103L
+      const bool __assignable = true;
+#else
+      // trivial types can have deleted assignment
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+#endif
+
+      std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
+	__uninit_fill(__first, __last, __x);
+    }
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill_n
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static void
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+			const _Tp& __x)
+        {
+	  _ForwardIterator __cur = __first;
+	  __try
+	    {
+	      for (; __n > 0; --__n, ++__cur)
+		std::_Construct(std::__addressof(*__cur), __x);
+	    }
+	  __catch(...)
+	    {
+	      std::_Destroy(__first, __cur);
+	      __throw_exception_again;
+	    }
+	}
+    };
+
+  template<>
+    struct __uninitialized_fill_n<true>
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static void
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+			const _Tp& __x)
+        { std::fill_n(__first, __n, __x); }
+    };
+
+  /**
+   *  @brief Copies the value x into the range [first,first+n).
+   *  @param  __first  An input iterator.
+   *  @param  __n      The number of copies to make.
+   *  @param  __x      The source value.
+   *  @return   Nothing.
+   *
+   *  Like fill_n(), but does not require an initialized output range.
+  */
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline void
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+#if __cplusplus < 201103L
+      const bool __assignable = true;
+#else
+      // trivial types can have deleted assignment
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+#endif
+
+      std::__uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
+	__uninit_fill_n(__first, __n, __x);
+    }
+
+  // Extensions: versions of uninitialized_copy, uninitialized_fill,
+  //  and uninitialized_fill_n that take an allocator parameter.
+  //  We dispatch back to the standard versions when we're given the
+  //  default allocator.  For nondefault allocators we do not use 
+  //  any of the POD optimizations.
+
+  template<typename _InputIterator, typename _ForwardIterator,
+	   typename _Allocator>
+    _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+			   _ForwardIterator __result, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __result;
+      __try
+	{
+	  typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+	  for (; __first != __last; ++__first, ++__cur)
+	    __traits::construct(__alloc, std::__addressof(*__cur), *__first);
+	  return __cur;
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__result, __cur, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+			   _ForwardIterator __result, allocator<_Tp>&)
+    { return std::uninitialized_copy(__first, __last, __result); }
+
+  template<typename _InputIterator, typename _ForwardIterator,
+	   typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
+			   _ForwardIterator __result, _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
+					 _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
+					 __result, __alloc);
+    }
+
+  template<typename _InputIterator, typename _ForwardIterator,
+	   typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_if_noexcept_a(_InputIterator __first,
+				       _InputIterator __last,
+				       _ForwardIterator __result,
+				       _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a
+	(_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
+	 _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
+    void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+			   const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      __try
+	{
+	  typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+	  for (; __cur != __last; ++__cur)
+	    __traits::construct(__alloc, std::__addressof(*__cur), __x);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__first, __cur, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
+    inline void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+			   const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill(__first, __last, __x); }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+	   typename _Allocator>
+    void
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, 
+			     const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      __try
+	{
+	  typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+	  for (; __n > 0; --__n, ++__cur)
+	    __traits::construct(__alloc, std::__addressof(*__cur), __x);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__first, __cur, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+	   typename _Tp2>
+    inline void
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, 
+			     const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill_n(__first, __n, __x); }
+
+
+  // Extensions: __uninitialized_copy_move, __uninitialized_move_copy,
+  // __uninitialized_fill_move, __uninitialized_move_fill.
+  // All of these algorithms take a user-supplied allocator, which is used
+  // for construction and destruction.
+
+  // __uninitialized_copy_move
+  // Copies [first1, last1) into [result, result + (last1 - first1)), and
+  //  move [first2, last2) into
+  //  [result, result + (last1 - first1) + (last2 - first2)).
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_copy_move(_InputIterator1 __first1,
+			      _InputIterator1 __last1,
+			      _InputIterator2 __first2,
+			      _InputIterator2 __last2,
+			      _ForwardIterator __result,
+			      _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
+							   __result,
+							   __alloc);
+      __try
+	{
+	  return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__result, __mid, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  // __uninitialized_move_copy
+  // Moves [first1, last1) into [result, result + (last1 - first1)), and
+  //  copies [first2, last2) into
+  //  [result, result + (last1 - first1) + (last2 - first2)).
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_copy(_InputIterator1 __first1,
+			      _InputIterator1 __last1,
+			      _InputIterator2 __first2,
+			      _InputIterator2 __last2,
+			      _ForwardIterator __result,
+			      _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
+							   __result,
+							   __alloc);
+      __try
+	{
+	  return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__result, __mid, __alloc);
+	  __throw_exception_again;
+	}
+    }
+  
+  // __uninitialized_fill_move
+  // Fills [result, mid) with x, and moves [first, last) into
+  //  [mid, mid + (last - first)).
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
+	   typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
+			      const _Tp& __x, _InputIterator __first,
+			      _InputIterator __last, _Allocator& __alloc)
+    {
+      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+      __try
+	{
+	  return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__result, __mid, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  // __uninitialized_move_fill
+  // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and
+  //  fills [first2 + (last1 - first1), last2) with x.
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
+	   typename _Allocator>
+    inline void
+    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
+			      _ForwardIterator __first2,
+			      _ForwardIterator __last2, const _Tp& __x,
+			      _Allocator& __alloc)
+    {
+      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
+							    __first2,
+							    __alloc);
+      __try
+	{
+	  std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__first2, __mid2, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+#if __cplusplus >= 201103L
+  // Extensions: __uninitialized_default, __uninitialized_default_n,
+  // __uninitialized_default_a, __uninitialized_default_n_a.
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_1
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+	  _ForwardIterator __cur = __first;
+	  __try
+	    {
+	      for (; __cur != __last; ++__cur)
+		std::_Construct(std::__addressof(*__cur));
+	    }
+	  __catch(...)
+	    {
+	      std::_Destroy(__first, __cur);
+	      __throw_exception_again;
+	    }
+	}
+    };
+
+  template<>
+    struct __uninitialized_default_1<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+	  typedef typename iterator_traits<_ForwardIterator>::value_type
+	    _ValueType;
+
+	  std::fill(__first, __last, _ValueType());
+	}
+    };
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_n_1
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static void
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+	  _ForwardIterator __cur = __first;
+	  __try
+	    {
+	      for (; __n > 0; --__n, ++__cur)
+		std::_Construct(std::__addressof(*__cur));
+	    }
+	  __catch(...)
+	    {
+	      std::_Destroy(__first, __cur);
+	      __throw_exception_again;
+	    }
+	}
+    };
+
+  template<>
+    struct __uninitialized_default_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static void
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+	  typedef typename iterator_traits<_ForwardIterator>::value_type
+	    _ValueType;
+
+	  std::fill_n(__first, __n, _ValueType());
+	}
+    };
+
+  // __uninitialized_default
+  // Fills [first, last) with std::distance(first, last) default
+  // constructed value_types(s).
+  template<typename _ForwardIterator>
+    inline void
+    __uninitialized_default(_ForwardIterator __first,
+			    _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      // trivial types can have deleted assignment
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      std::__uninitialized_default_1<__is_trivial(_ValueType)
+				     && __assignable>::
+	__uninit_default(__first, __last);
+    }
+
+  // __uninitialized_default_n
+  // Fills [first, first + n) with n default constructed value_type(s).
+  template<typename _ForwardIterator, typename _Size>
+    inline void
+    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      // trivial types can have deleted assignment
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      std::__uninitialized_default_n_1<__is_trivial(_ValueType)
+				       && __assignable>::
+	__uninit_default_n(__first, __n);
+    }
+
+
+  // __uninitialized_default_a
+  // Fills [first, last) with std::distance(first, last) default
+  // constructed value_types(s), constructed with the allocator alloc.
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    __uninitialized_default_a(_ForwardIterator __first,
+			      _ForwardIterator __last,
+			      _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      __try
+	{
+	  typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+	  for (; __cur != __last; ++__cur)
+	    __traits::construct(__alloc, std::__addressof(*__cur));
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__first, __cur, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    __uninitialized_default_a(_ForwardIterator __first,
+			      _ForwardIterator __last,
+			      allocator<_Tp>&)
+    { std::__uninitialized_default(__first, __last); }
+
+
+  // __uninitialized_default_n_a
+  // Fills [first, first + n) with n default constructed value_types(s),
+  // constructed with the allocator alloc.
+  template<typename _ForwardIterator, typename _Size, typename _Allocator>
+    void
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, 
+				_Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      __try
+	{
+	  typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+	  for (; __n > 0; --__n, ++__cur)
+	    __traits::construct(__alloc, std::__addressof(*__cur));
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__first, __cur, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline void
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, 
+				allocator<_Tp>&)
+    { std::__uninitialized_default_n(__first, __n); }
+
+
+  template<typename _InputIterator, typename _Size,
+	   typename _ForwardIterator>
+    _ForwardIterator
+    __uninitialized_copy_n(_InputIterator __first, _Size __n,
+			   _ForwardIterator __result, input_iterator_tag)
+    {
+      _ForwardIterator __cur = __result;
+      __try
+	{
+	  for (; __n > 0; --__n, ++__first, ++__cur)
+	    std::_Construct(std::__addressof(*__cur), *__first);
+	  return __cur;
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__result, __cur);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+	   typename _ForwardIterator>
+    inline _ForwardIterator
+    __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
+			   _ForwardIterator __result,
+			   random_access_iterator_tag)
+    { return std::uninitialized_copy(__first, __first + __n, __result); }
+
+  /**
+   *  @brief Copies the range [first,first+n) into result.
+   *  @param  __first  An input iterator.
+   *  @param  __n      The number of elements to copy.
+   *  @param  __result An output iterator.
+   *  @return  __result + __n
+   *
+   *  Like copy_n(), but does not require an initialized output range.
+  */
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy_n(_InputIterator __first, _Size __n,
+			 _ForwardIterator __result)
+    { return std::__uninitialized_copy_n(__first, __n, __result,
+					 std::__iterator_category(__first)); }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _STL_UNINITIALIZED_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stl_vector.h b/gcc-4.9/libstdc++-v3/include/bits/stl_vector.h
new file mode 100644
index 0000000..7e52fde
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stl_vector.h
@@ -0,0 +1,1559 @@
+// Vector implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this  software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/stl_vector.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{vector}
+ */
+
+#ifndef _STL_VECTOR_H
+#define _STL_VECTOR_H 1
+
+#include <bits/stl_iterator_base_funcs.h>
+#include <bits/functexcept.h>
+#include <bits/concept_check.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /// See bits/stl_deque.h's _Deque_base for an explanation.
+  template<typename _Tp, typename _Alloc>
+    struct _Vector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Tp>::other _Tp_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
+       	pointer;
+
+      struct _Vector_impl 
+      : public _Tp_alloc_type
+      {
+	pointer _M_start;
+	pointer _M_finish;
+	pointer _M_end_of_storage;
+
+	_Vector_impl()
+	: _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
+	{ }
+
+	_Vector_impl(_Tp_alloc_type const& __a) _GLIBCXX_NOEXCEPT
+	: _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
+	{ }
+
+#if __cplusplus >= 201103L
+	_Vector_impl(_Tp_alloc_type&& __a) noexcept
+	: _Tp_alloc_type(std::move(__a)),
+	  _M_start(0), _M_finish(0), _M_end_of_storage(0)
+	{ }
+#endif
+
+	void _M_swap_data(_Vector_impl& __x) _GLIBCXX_NOEXCEPT
+	{
+	  std::swap(_M_start, __x._M_start);
+	  std::swap(_M_finish, __x._M_finish);
+	  std::swap(_M_end_of_storage, __x._M_end_of_storage);
+	}
+      };
+      
+    public:
+      typedef _Alloc allocator_type;
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() _GLIBCXX_NOEXCEPT
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+      _Vector_base()
+      : _M_impl() { }
+
+      _Vector_base(const allocator_type& __a) _GLIBCXX_NOEXCEPT
+      : _M_impl(__a) { }
+
+      _Vector_base(size_t __n)
+      : _M_impl()
+      { _M_create_storage(__n); }
+
+      _Vector_base(size_t __n, const allocator_type& __a)
+      : _M_impl(__a)
+      { _M_create_storage(__n); }
+
+#if __cplusplus >= 201103L
+      _Vector_base(_Tp_alloc_type&& __a) noexcept
+      : _M_impl(std::move(__a)) { }
+
+      _Vector_base(_Vector_base&& __x) noexcept
+      : _M_impl(std::move(__x._M_get_Tp_allocator()))
+      { this->_M_impl._M_swap_data(__x._M_impl); }
+
+      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
+      : _M_impl(__a)
+      {
+	if (__x.get_allocator() == __a)
+	  this->_M_impl._M_swap_data(__x._M_impl);
+	else
+	  {
+	    size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
+	    _M_create_storage(__n);
+	  }
+      }
+#endif
+
+      ~_Vector_base() _GLIBCXX_NOEXCEPT
+      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
+		      - this->_M_impl._M_start); }
+
+    public:
+      _Vector_impl _M_impl;
+
+      pointer
+      _M_allocate(size_t __n)
+      {
+	typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+	return __n != 0 ? _Tr::allocate(_M_impl, __n) : 0;
+      }
+
+      void
+      _M_deallocate(pointer __p, size_t __n)
+      {
+	typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+	if (__p)
+	  _Tr::deallocate(_M_impl, __p, __n);
+      }
+
+    private:
+      void
+      _M_create_storage(size_t __n)
+      {
+	this->_M_impl._M_start = this->_M_allocate(__n);
+	this->_M_impl._M_finish = this->_M_impl._M_start;
+	this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+      }
+    };
+
+
+  /**
+   *  @brief A standard container which offers fixed time access to
+   *  individual elements in any order.
+   *
+   *  @ingroup sequences
+   *
+   *  @tparam _Tp  Type of element.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_Tp>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and a
+   *  <a href="tables.html#67">sequence</a>, including the
+   *  <a href="tables.html#68">optional sequence requirements</a> with the
+   *  %exception of @c push_front and @c pop_front.
+   *
+   *  In some terminology a %vector can be described as a dynamic
+   *  C-style array, it offers fast and efficient access to individual
+   *  elements in any order and saves the user from worrying about
+   *  memory and size allocation.  Subscripting ( @c [] ) access is
+   *  also provided as with C-style arrays.
+  */
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class vector : protected _Vector_base<_Tp, _Alloc>
+    {
+      // Concept requirements.
+      typedef typename _Alloc::value_type                _Alloc_value_type;
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+      __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
+      
+      typedef _Vector_base<_Tp, _Alloc>			 _Base;
+      typedef typename _Base::_Tp_alloc_type		 _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type>  _Alloc_traits;
+
+    public:
+      typedef _Tp					 value_type;
+      typedef typename _Base::pointer                    pointer;
+      typedef typename _Alloc_traits::const_pointer      const_pointer;
+      typedef typename _Alloc_traits::reference          reference;
+      typedef typename _Alloc_traits::const_reference    const_reference;
+      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
+      const_iterator;
+      typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
+      typedef std::reverse_iterator<iterator>		 reverse_iterator;
+      typedef size_t					 size_type;
+      typedef ptrdiff_t					 difference_type;
+      typedef _Alloc                        		 allocator_type;
+
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_M_impl;
+      using _Base::_M_get_Tp_allocator;
+
+    public:
+      // [23.2.4.1] construct/copy/destroy
+      // (assign() and get_allocator() are also listed in this section)
+
+      /**
+       *  @brief  Creates a %vector with no elements.
+       */
+      vector()
+#if __cplusplus >= 201103L
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+#endif
+      : _Base() { }
+
+      /**
+       *  @brief  Creates a %vector with no elements.
+       *  @param  __a  An allocator object.
+       */
+      explicit
+      vector(const allocator_type& __a) _GLIBCXX_NOEXCEPT
+      : _Base(__a) { }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Creates a %vector with default constructed elements.
+       *  @param  __n  The number of elements to initially create.
+       *  @param  __a  An allocator.
+       *
+       *  This constructor fills the %vector with @a __n default
+       *  constructed elements.
+       */
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_default_initialize(__n); }
+
+      /**
+       *  @brief  Creates a %vector with copies of an exemplar element.
+       *  @param  __n  The number of elements to initially create.
+       *  @param  __value  An element to copy.
+       *  @param  __a  An allocator.
+       *
+       *  This constructor fills the %vector with @a __n copies of @a __value.
+       */
+      vector(size_type __n, const value_type& __value,
+	     const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_fill_initialize(__n, __value); }
+#else
+      /**
+       *  @brief  Creates a %vector with copies of an exemplar element.
+       *  @param  __n  The number of elements to initially create.
+       *  @param  __value  An element to copy.
+       *  @param  __a  An allocator.
+       *
+       *  This constructor fills the %vector with @a __n copies of @a __value.
+       */
+      explicit
+      vector(size_type __n, const value_type& __value = value_type(),
+	     const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_fill_initialize(__n, __value); }
+#endif
+
+      /**
+       *  @brief  %Vector copy constructor.
+       *  @param  __x  A %vector of identical element and allocator types.
+       *
+       *  The newly-created %vector uses a copy of the allocation
+       *  object used by @a __x.  All the elements of @a __x are copied,
+       *  but any extra memory in
+       *  @a __x (for fast expansion) will not be copied.
+       */
+      vector(const vector& __x)
+      : _Base(__x.size(),
+        _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
+      { this->_M_impl._M_finish =
+	  std::__uninitialized_copy_a(__x.begin(), __x.end(),
+				      this->_M_impl._M_start,
+				      _M_get_Tp_allocator());
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Vector move constructor.
+       *  @param  __x  A %vector of identical element and allocator types.
+       *
+       *  The newly-created %vector contains the exact contents of @a __x.
+       *  The contents of @a __x are a valid, but unspecified %vector.
+       */
+      vector(vector&& __x) noexcept
+      : _Base(std::move(__x)) { }
+
+      /// Copy constructor with alternative allocator
+      vector(const vector& __x, const allocator_type& __a)
+      : _Base(__x.size(), __a)
+      { this->_M_impl._M_finish =
+	  std::__uninitialized_copy_a(__x.begin(), __x.end(),
+				      this->_M_impl._M_start,
+				      _M_get_Tp_allocator());
+      }
+
+      /// Move constructor with alternative allocator
+      vector(vector&& __rv, const allocator_type& __m)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _Base(std::move(__rv), __m)
+      {
+	if (__rv.get_allocator() != __m)
+	  {
+	    this->_M_impl._M_finish =
+	      std::__uninitialized_move_a(__rv.begin(), __rv.end(),
+					  this->_M_impl._M_start,
+					  _M_get_Tp_allocator());
+	    __rv.clear();
+	  }
+      }
+
+      /**
+       *  @brief  Builds a %vector from an initializer list.
+       *  @param  __l  An initializer_list.
+       *  @param  __a  An allocator.
+       *
+       *  Create a %vector consisting of copies of the elements in the
+       *  initializer_list @a __l.
+       *
+       *  This will call the element type's copy constructor N times
+       *  (where N is @a __l.size()) and do no memory reallocation.
+       */
+      vector(initializer_list<value_type> __l,
+	     const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	_M_range_initialize(__l.begin(), __l.end(),
+			    random_access_iterator_tag());
+      }
+#endif
+
+      /**
+       *  @brief  Builds a %vector from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param  __a  An allocator.
+       *
+       *  Create a %vector consisting of copies of the elements from
+       *  [first,last).
+       *
+       *  If the iterators are forward, bidirectional, or
+       *  random-access, then this will call the elements' copy
+       *  constructor N times (where N is distance(first,last)) and do
+       *  no memory reallocation.  But if only input iterators are
+       *  used, then this will do at most 2N calls to the copy
+       *  constructor, and logN memory reallocations.
+       */
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        vector(_InputIterator __first, _InputIterator __last,
+	       const allocator_type& __a = allocator_type())
+	: _Base(__a)
+        { _M_initialize_dispatch(__first, __last, __false_type()); }
+#else
+      template<typename _InputIterator>
+        vector(_InputIterator __first, _InputIterator __last,
+	       const allocator_type& __a = allocator_type())
+	: _Base(__a)
+        {
+	  // Check whether it's an integral type.  If so, it's not an iterator.
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_initialize_dispatch(__first, __last, _Integral());
+	}
+#endif
+
+      /**
+       *  The dtor only erases the elements, and note that if the
+       *  elements themselves are pointers, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      ~vector() _GLIBCXX_NOEXCEPT
+      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+		      _M_get_Tp_allocator()); }
+
+      /**
+       *  @brief  %Vector assignment operator.
+       *  @param  __x  A %vector of identical element and allocator types.
+       *
+       *  All the elements of @a __x are copied, but any extra memory in
+       *  @a __x (for fast expansion) will not be copied.  Unlike the
+       *  copy constructor, the allocator object is not copied.
+       */
+      vector&
+      operator=(const vector& __x);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  %Vector move assignment operator.
+       *  @param  __x  A %vector of identical element and allocator types.
+       *
+       *  The contents of @a __x are moved into this %vector (without copying,
+       *  if the allocators permit it).
+       *  @a __x is a valid, but unspecified %vector.
+       */
+      vector&
+      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+        constexpr bool __move_storage =
+          _Alloc_traits::_S_propagate_on_move_assign()
+          || _Alloc_traits::_S_always_equal();
+        _M_move_assign(std::move(__x),
+                       integral_constant<bool, __move_storage>());
+	return *this;
+      }
+
+      /**
+       *  @brief  %Vector list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %vector with copies of the elements in the
+       *  initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %vector and
+       *  that the resulting %vector's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+	this->assign(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      /**
+       *  @brief  Assigns a given value to a %vector.
+       *  @param  __n  Number of elements to be assigned.
+       *  @param  __val  Value to be assigned.
+       *
+       *  This function fills a %vector with @a __n copies of the given
+       *  value.  Note that the assignment completely changes the
+       *  %vector and that the resulting %vector's size is the same as
+       *  the number of elements assigned.  Old data may be lost.
+       */
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+
+      /**
+       *  @brief  Assigns a range to a %vector.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *
+       *  This function fills a %vector with copies of the elements in the
+       *  range [__first,__last).
+       *
+       *  Note that the assignment completely changes the %vector and
+       *  that the resulting %vector's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _M_assign_dispatch(__first, __last, __false_type()); }
+#else
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  // Check whether it's an integral type.  If so, it's not an iterator.
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_assign_dispatch(__first, __last, _Integral());
+	}
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Assigns an initializer list to a %vector.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills a %vector with copies of the elements in the
+       *  initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %vector and
+       *  that the resulting %vector's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      void
+      assign(initializer_list<value_type> __l)
+      { this->assign(__l.begin(), __l.end()); }
+#endif
+
+      /// Get a copy of the memory allocation object.
+      using _Base::get_allocator;
+
+      // iterators
+      /**
+       *  Returns a read/write iterator that points to the first
+       *  element in the %vector.  Iteration is done in ordinary
+       *  element order.
+       */
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(this->_M_impl._M_start); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the
+       *  first element in the %vector.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(this->_M_impl._M_start); }
+
+      /**
+       *  Returns a read/write iterator that points one past the last
+       *  element in the %vector.  Iteration is done in ordinary
+       *  element order.
+       */
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(this->_M_impl._M_finish); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past
+       *  the last element in the %vector.  Iteration is done in
+       *  ordinary element order.
+       */
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(this->_M_impl._M_finish); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to the
+       *  last element in the %vector.  Iteration is done in reverse
+       *  element order.
+       */
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last element in the %vector.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to one
+       *  before the first element in the %vector.  Iteration is done
+       *  in reverse element order.
+       */
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first element in the %vector.  Iteration
+       *  is done in reverse element order.
+       */
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the
+       *  first element in the %vector.  Iteration is done in ordinary
+       *  element order.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_start); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past
+       *  the last element in the %vector.  Iteration is done in
+       *  ordinary element order.
+       */
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_impl._M_finish); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last element in the %vector.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first element in the %vector.  Iteration
+       *  is done in reverse element order.
+       */
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // [23.2.4.2] capacity
+      /**  Returns the number of elements in the %vector.  */
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
+
+      /**  Returns the size() of the largest possible %vector.  */
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Resizes the %vector to the specified number of elements.
+       *  @param  __new_size  Number of elements the %vector should contain.
+       *
+       *  This function will %resize the %vector to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %vector's current size the %vector is truncated, otherwise
+       *  default constructed elements are appended.
+       */
+      void
+      resize(size_type __new_size)
+      {
+	if (__new_size > size())
+	  _M_default_append(__new_size - size());
+	else if (__new_size < size())
+	  _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+
+      /**
+       *  @brief  Resizes the %vector to the specified number of elements.
+       *  @param  __new_size  Number of elements the %vector should contain.
+       *  @param  __x  Data with which new elements should be populated.
+       *
+       *  This function will %resize the %vector to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %vector's current size the %vector is truncated, otherwise
+       *  the %vector is extended and new elements are populated with
+       *  given data.
+       */
+      void
+      resize(size_type __new_size, const value_type& __x)
+      {
+	if (__new_size > size())
+	  insert(end(), __new_size - size(), __x);
+	else if (__new_size < size())
+	  _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+#else
+      /**
+       *  @brief  Resizes the %vector to the specified number of elements.
+       *  @param  __new_size  Number of elements the %vector should contain.
+       *  @param  __x  Data with which new elements should be populated.
+       *
+       *  This function will %resize the %vector to the specified
+       *  number of elements.  If the number is smaller than the
+       *  %vector's current size the %vector is truncated, otherwise
+       *  the %vector is extended and new elements are populated with
+       *  given data.
+       */
+      void
+      resize(size_type __new_size, value_type __x = value_type())
+      {
+	if (__new_size > size())
+	  insert(end(), __new_size - size(), __x);
+	else if (__new_size < size())
+	  _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      /**  A non-binding request to reduce capacity() to size().  */
+      void
+      shrink_to_fit()
+      { _M_shrink_to_fit(); }
+#endif
+
+      /**
+       *  Returns the total number of elements that the %vector can
+       *  hold before needing to allocate more memory.
+       */
+      size_type
+      capacity() const _GLIBCXX_NOEXCEPT
+      { return size_type(this->_M_impl._M_end_of_storage
+			 - this->_M_impl._M_start); }
+
+      /**
+       *  Returns true if the %vector is empty.  (Thus begin() would
+       *  equal end().)
+       */
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return begin() == end(); }
+
+      /**
+       *  @brief  Attempt to preallocate enough memory for specified number of
+       *          elements.
+       *  @param  __n  Number of elements required.
+       *  @throw  std::length_error  If @a n exceeds @c max_size().
+       *
+       *  This function attempts to reserve enough memory for the
+       *  %vector to hold the specified number of elements.  If the
+       *  number requested is more than max_size(), length_error is
+       *  thrown.
+       *
+       *  The advantage of this function is that if optimal code is a
+       *  necessity and the user can determine the number of elements
+       *  that will be required, the user can reserve the memory in
+       *  %advance, and thus prevent a possible reallocation of memory
+       *  and copying of %vector data.
+       */
+      void
+      reserve(size_type __n);
+
+      // element access
+      /**
+       *  @brief  Subscript access to the data contained in the %vector.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read/write reference to data.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)
+       */
+      reference
+      operator[](size_type __n) _GLIBCXX_NOEXCEPT
+      { return *(this->_M_impl._M_start + __n); }
+
+      /**
+       *  @brief  Subscript access to the data contained in the %vector.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read-only (constant) reference to data.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)
+       */
+      const_reference
+      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
+      { return *(this->_M_impl._M_start + __n); }
+
+    protected:
+      /// Safety check used only from at().
+      void
+      _M_range_check(size_type __n) const
+      {
+	if (__n >= this->size())
+	  __throw_out_of_range_fmt(__N("vector::_M_range_check: __n "
+				       "(which is %zu) >= this->size() "
+				       "(which is %zu)"),
+				   __n, this->size());
+      }
+
+    public:
+      /**
+       *  @brief  Provides access to the data contained in the %vector.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read/write reference to data.
+       *  @throw  std::out_of_range  If @a __n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter
+       *  is first checked that it is in the range of the vector.  The
+       *  function throws out_of_range if the check fails.
+       */
+      reference
+      at(size_type __n)
+      {
+	_M_range_check(__n);
+	return (*this)[__n]; 
+      }
+
+      /**
+       *  @brief  Provides access to the data contained in the %vector.
+       *  @param __n The index of the element for which data should be
+       *  accessed.
+       *  @return  Read-only (constant) reference to data.
+       *  @throw  std::out_of_range  If @a __n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter
+       *  is first checked that it is in the range of the vector.  The
+       *  function throws out_of_range if the check fails.
+       */
+      const_reference
+      at(size_type __n) const
+      {
+	_M_range_check(__n);
+	return (*this)[__n];
+      }
+
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %vector.
+       */
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      { return *begin(); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %vector.
+       */
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      { return *begin(); }
+
+      /**
+       *  Returns a read/write reference to the data at the last
+       *  element of the %vector.
+       */
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      { return *(end() - 1); }
+      
+      /**
+       *  Returns a read-only (constant) reference to the data at the
+       *  last element of the %vector.
+       */
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      { return *(end() - 1); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 464. Suggestion for new member functions in standard containers.
+      // data access
+      /**
+       *   Returns a pointer such that [data(), data() + size()) is a valid
+       *   range.  For a non-empty %vector, data() == &front().
+       */
+#if __cplusplus >= 201103L
+      _Tp*
+#else
+      pointer
+#endif
+      data() _GLIBCXX_NOEXCEPT
+      { return _M_data_ptr(this->_M_impl._M_start); }
+
+#if __cplusplus >= 201103L
+      const _Tp*
+#else
+      const_pointer
+#endif
+      data() const _GLIBCXX_NOEXCEPT
+      { return _M_data_ptr(this->_M_impl._M_start); }
+
+      // [23.2.4.3] modifiers
+      /**
+       *  @brief  Add data to the end of the %vector.
+       *  @param  __x  Data to be added.
+       *
+       *  This is a typical stack operation.  The function creates an
+       *  element at the end of the %vector and assigns the given data
+       *  to it.  Due to the nature of a %vector this operation can be
+       *  done in constant time if the %vector has preallocated space
+       *  available.
+       */
+      void
+      push_back(const value_type& __x)
+      {
+	if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+	  {
+	    _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+	                             __x);
+	    ++this->_M_impl._M_finish;
+	  }
+	else
+#if __cplusplus >= 201103L
+	  _M_emplace_back_aux(__x);
+#else
+	  _M_insert_aux(end(), __x);
+#endif
+      }
+
+#if __cplusplus >= 201103L
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args);
+#endif
+
+      /**
+       *  @brief  Removes last element.
+       *
+       *  This is a typical stack operation. It shrinks the %vector by one.
+       *
+       *  Note that no data is returned, and if the last element's
+       *  data is needed, it should be retrieved before pop_back() is
+       *  called.
+       */
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      {
+	--this->_M_impl._M_finish;
+	_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts an object in %vector before specified iterator.
+       *  @param  __position  A const_iterator into the %vector.
+       *  @param  __args  Arguments.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert an object of type T constructed
+       *  with T(std::forward<Args>(args)...) before the specified location.
+       *  Note that this kind of operation could be expensive for a %vector
+       *  and if it is frequently used the user should consider using
+       *  std::list.
+       */
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args);
+
+      /**
+       *  @brief  Inserts given value into %vector before specified iterator.
+       *  @param  __position  A const_iterator into the %vector.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given value before
+       *  the specified location.  Note that this kind of operation
+       *  could be expensive for a %vector and if it is frequently
+       *  used the user should consider using std::list.
+       */
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+#else
+      /**
+       *  @brief  Inserts given value into %vector before specified iterator.
+       *  @param  __position  An iterator into the %vector.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given value before
+       *  the specified location.  Note that this kind of operation
+       *  could be expensive for a %vector and if it is frequently
+       *  used the user should consider using std::list.
+       */
+      iterator
+      insert(iterator __position, const value_type& __x);
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts given rvalue into %vector before specified iterator.
+       *  @param  __position  A const_iterator into the %vector.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a copy of the given rvalue before
+       *  the specified location.  Note that this kind of operation
+       *  could be expensive for a %vector and if it is frequently
+       *  used the user should consider using std::list.
+       */
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+
+      /**
+       *  @brief  Inserts an initializer_list into the %vector.
+       *  @param  __position  An iterator into the %vector.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function will insert copies of the data in the 
+       *  initializer_list @a l into the %vector before the location
+       *  specified by @a position.
+       *
+       *  Note that this kind of operation could be expensive for a
+       *  %vector and if it is frequently used the user should
+       *  consider using std::list.
+       */
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      { return this->insert(__position, __l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts a number of copies of given data into the %vector.
+       *  @param  __position  A const_iterator into the %vector.
+       *  @param  __n  Number of elements to be inserted.
+       *  @param  __x  Data to be inserted.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert a specified number of copies of
+       *  the given data before the location specified by @a position.
+       *
+       *  Note that this kind of operation could be expensive for a
+       *  %vector and if it is frequently used the user should
+       *  consider using std::list.
+       */
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+	difference_type __offset = __position - cbegin();
+	_M_fill_insert(__position._M_const_cast(), __n, __x);
+	return begin() + __offset;
+      }
+#else
+      /**
+       *  @brief  Inserts a number of copies of given data into the %vector.
+       *  @param  __position  An iterator into the %vector.
+       *  @param  __n  Number of elements to be inserted.
+       *  @param  __x  Data to be inserted.
+       *
+       *  This function will insert a specified number of copies of
+       *  the given data before the location specified by @a position.
+       *
+       *  Note that this kind of operation could be expensive for a
+       *  %vector and if it is frequently used the user should
+       *  consider using std::list.
+       */
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      { _M_fill_insert(__position, __n, __x); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Inserts a range into the %vector.
+       *  @param  __position  A const_iterator into the %vector.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *  @return  An iterator that points to the inserted data.
+       *
+       *  This function will insert copies of the data in the range
+       *  [__first,__last) into the %vector before the location specified
+       *  by @a pos.
+       *
+       *  Note that this kind of operation could be expensive for a
+       *  %vector and if it is frequently used the user should
+       *  consider using std::list.
+       */
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert(const_iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+        {
+	  difference_type __offset = __position - cbegin();
+	  _M_insert_dispatch(__position._M_const_cast(),
+			     __first, __last, __false_type());
+	  return begin() + __offset;
+	}
+#else
+      /**
+       *  @brief  Inserts a range into the %vector.
+       *  @param  __position  An iterator into the %vector.
+       *  @param  __first  An input iterator.
+       *  @param  __last   An input iterator.
+       *
+       *  This function will insert copies of the data in the range
+       *  [__first,__last) into the %vector before the location specified
+       *  by @a pos.
+       *
+       *  Note that this kind of operation could be expensive for a
+       *  %vector and if it is frequently used the user should
+       *  consider using std::list.
+       */
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+        {
+	  // Check whether it's an integral type.  If so, it's not an iterator.
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_insert_dispatch(__position, __first, __last, _Integral());
+	}
+#endif
+
+      /**
+       *  @brief  Remove element at given position.
+       *  @param  __position  Iterator pointing to element to be erased.
+       *  @return  An iterator pointing to the next element (or end()).
+       *
+       *  This function will erase the element at the given position and thus
+       *  shorten the %vector by one.
+       *
+       *  Note This operation could be expensive and if it is
+       *  frequently used the user should consider using std::list.
+       *  The user is also cautioned that this function only erases
+       *  the element, and that if the element is itself a pointer,
+       *  the pointed-to memory is not touched in any way.  Managing
+       *  the pointer is the user's responsibility.
+       */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position)
+#else
+      erase(iterator __position)
+#endif
+      { return _M_erase(__position._M_const_cast()); }
+
+      /**
+       *  @brief  Remove a range of elements.
+       *  @param  __first  Iterator pointing to the first element to be erased.
+       *  @param  __last  Iterator pointing to one past the last element to be
+       *                  erased.
+       *  @return  An iterator pointing to the element pointed to by @a __last
+       *           prior to erasing (or end()).
+       *
+       *  This function will erase the elements in the range
+       *  [__first,__last) and shorten the %vector accordingly.
+       *
+       *  Note This operation could be expensive and if it is
+       *  frequently used the user should consider using std::list.
+       *  The user is also cautioned that this function only erases
+       *  the elements, and that if the elements themselves are
+       *  pointers, the pointed-to memory is not touched in any way.
+       *  Managing the pointer is the user's responsibility.
+       */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last)
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+
+      /**
+       *  @brief  Swaps data with another %vector.
+       *  @param  __x  A %vector of the same element and allocator types.
+       *
+       *  This exchanges the elements between two vectors in constant time.
+       *  (Three pointers, so it should be quite fast.)
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(v1,v2) will feed to this function.
+       */
+      void
+      swap(vector& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      {
+	this->_M_impl._M_swap_data(__x._M_impl);
+	_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
+	                          __x._M_get_Tp_allocator());
+      }
+
+      /**
+       *  Erases all the elements.  Note that this function only erases the
+       *  elements, and that if the elements themselves are pointers, the
+       *  pointed-to memory is not touched in any way.  Managing the pointer is
+       *  the user's responsibility.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { _M_erase_at_end(this->_M_impl._M_start); }
+
+    protected:
+      /**
+       *  Memory expansion handler.  Uses the member allocation function to
+       *  obtain @a n bytes of memory, and then copies [first,last) into it.
+       */
+      template<typename _ForwardIterator>
+        pointer
+        _M_allocate_and_copy(size_type __n,
+			     _ForwardIterator __first, _ForwardIterator __last)
+        {
+	  pointer __result = this->_M_allocate(__n);
+	  __try
+	    {
+	      std::__uninitialized_copy_a(__first, __last, __result,
+					  _M_get_Tp_allocator());
+	      return __result;
+	    }
+	  __catch(...)
+	    {
+	      _M_deallocate(__result, __n);
+	      __throw_exception_again;
+	    }
+	}
+
+
+      // Internal constructor functions follow.
+
+      // Called by the range constructor to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
+        {
+	  this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
+	  this->_M_impl._M_end_of_storage =
+	    this->_M_impl._M_start + static_cast<size_type>(__n);
+	  _M_fill_initialize(static_cast<size_type>(__n), __value);
+	}
+
+      // Called by the range constructor to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+			       __false_type)
+        {
+	  typedef typename std::iterator_traits<_InputIterator>::
+	    iterator_category _IterCategory;
+	  _M_range_initialize(__first, __last, _IterCategory());
+	}
+
+      // Called by the second initialize_dispatch above
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first,
+			    _InputIterator __last, std::input_iterator_tag)
+        {
+	  for (; __first != __last; ++__first)
+#if __cplusplus >= 201103L
+	    emplace_back(*__first);
+#else
+	    push_back(*__first);
+#endif
+	}
+
+      // Called by the second initialize_dispatch above
+      template<typename _ForwardIterator>
+        void
+        _M_range_initialize(_ForwardIterator __first,
+			    _ForwardIterator __last, std::forward_iterator_tag)
+        {
+	  const size_type __n = std::distance(__first, __last);
+	  this->_M_impl._M_start = this->_M_allocate(__n);
+	  this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+	  this->_M_impl._M_finish =
+	    std::__uninitialized_copy_a(__first, __last,
+					this->_M_impl._M_start,
+					_M_get_Tp_allocator());
+	}
+
+      // Called by the first initialize_dispatch above and by the
+      // vector(n,value,a) constructor.
+      void
+      _M_fill_initialize(size_type __n, const value_type& __value)
+      {
+	std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, 
+				      _M_get_Tp_allocator());
+	this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
+      }
+
+#if __cplusplus >= 201103L
+      // Called by the vector(n) constructor.
+      void
+      _M_default_initialize(size_type __n)
+      {
+	std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, 
+					 _M_get_Tp_allocator());
+	this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
+      }
+#endif
+
+      // Internal assign functions follow.  The *_aux functions do the actual
+      // assignment work for the range versions.
+
+      // Called by the range assign to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+
+      // Called by the range assign to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+			   __false_type)
+        {
+	  typedef typename std::iterator_traits<_InputIterator>::
+	    iterator_category _IterCategory;
+	  _M_assign_aux(__first, __last, _IterCategory());
+	}
+
+      // Called by the second assign_dispatch above
+      template<typename _InputIterator>
+        void
+        _M_assign_aux(_InputIterator __first, _InputIterator __last,
+		      std::input_iterator_tag);
+
+      // Called by the second assign_dispatch above
+      template<typename _ForwardIterator>
+        void
+        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+		      std::forward_iterator_tag);
+
+      // Called by assign(n,t), and the range assign when it turns out
+      // to be the same thing.
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+
+
+      // Internal insert functions follow.
+
+      // Called by the range insert to implement [23.1.1]/9
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+			   __true_type)
+        { _M_fill_insert(__pos, __n, __val); }
+
+      // Called by the range insert to implement [23.1.1]/9
+      template<typename _InputIterator>
+        void
+        _M_insert_dispatch(iterator __pos, _InputIterator __first,
+			   _InputIterator __last, __false_type)
+        {
+	  typedef typename std::iterator_traits<_InputIterator>::
+	    iterator_category _IterCategory;
+	  _M_range_insert(__pos, __first, __last, _IterCategory());
+	}
+
+      // Called by the second insert_dispatch above
+      template<typename _InputIterator>
+        void
+        _M_range_insert(iterator __pos, _InputIterator __first,
+			_InputIterator __last, std::input_iterator_tag);
+
+      // Called by the second insert_dispatch above
+      template<typename _ForwardIterator>
+        void
+        _M_range_insert(iterator __pos, _ForwardIterator __first,
+			_ForwardIterator __last, std::forward_iterator_tag);
+
+      // Called by insert(p,n,x), and the range insert when it turns out to be
+      // the same thing.
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+#if __cplusplus >= 201103L
+      // Called by resize(n).
+      void
+      _M_default_append(size_type __n);
+
+      bool
+      _M_shrink_to_fit();
+#endif
+
+      // Called by insert(p,x)
+#if __cplusplus < 201103L
+      void
+      _M_insert_aux(iterator __position, const value_type& __x);
+#else
+      template<typename... _Args>
+        void
+        _M_insert_aux(iterator __position, _Args&&... __args);
+
+      template<typename... _Args>
+        void
+        _M_emplace_back_aux(_Args&&... __args);
+#endif
+
+      // Called by the latter.
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+	if (max_size() - size() < __n)
+	  __throw_length_error(__N(__s));
+
+	const size_type __len = size() + std::max(size(), __n);
+	return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+
+      // Internal erase functions follow.
+
+      // Called by erase(q1,q2), clear(), resize(), _M_fill_assign,
+      // _M_assign_aux.
+      void
+      _M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
+      {
+	std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
+	this->_M_impl._M_finish = __pos;
+      }
+
+      iterator
+      _M_erase(iterator __position);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+
+#if __cplusplus >= 201103L
+    private:
+      // Constant-time move assignment when source object's memory can be
+      // moved, either because the source's allocator will move too
+      // or because the allocators are equal.
+      void
+      _M_move_assign(vector&& __x, std::true_type) noexcept
+      {
+	vector __tmp(get_allocator());
+	this->_M_impl._M_swap_data(__tmp._M_impl);
+	this->_M_impl._M_swap_data(__x._M_impl);
+	std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
+      }
+
+      // Do move assignment when it might not be possible to move source
+      // object's memory, resulting in a linear-time operation.
+      void
+      _M_move_assign(vector&& __x, std::false_type)
+      {
+	if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
+	  _M_move_assign(std::move(__x), std::true_type());
+	else
+	  {
+	    // The rvalue's allocator cannot be moved and is not equal,
+	    // so we need to individually move each element.
+	    this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
+			 std::__make_move_if_noexcept_iterator(__x.end()));
+	    __x.clear();
+	  }
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _Up>
+	_Up*
+	_M_data_ptr(_Up* __ptr) const
+	{ return __ptr; }
+
+      template<typename _Ptr>
+	typename std::pointer_traits<_Ptr>::element_type*
+	_M_data_ptr(_Ptr __ptr) const
+	{ return empty() ? nullptr : std::__addressof(*__ptr); }
+#else
+      template<typename _Ptr>
+	_Ptr
+	_M_data_ptr(_Ptr __ptr) const
+	{ return __ptr; }
+#endif
+    };
+
+
+  /**
+   *  @brief  Vector equality comparison.
+   *  @param  __x  A %vector.
+   *  @param  __y  A %vector of the same type as @a __x.
+   *  @return  True iff the size and elements of the vectors are equal.
+   *
+   *  This is an equivalence relation.  It is linear in the size of the
+   *  vectors.  Vectors are considered equivalent if their sizes are equal,
+   *  and if corresponding elements compare equal.
+  */
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return (__x.size() == __y.size()
+	      && std::equal(__x.begin(), __x.end(), __y.begin())); }
+
+  /**
+   *  @brief  Vector ordering relation.
+   *  @param  __x  A %vector.
+   *  @param  __y  A %vector of the same type as @a __x.
+   *  @return  True iff @a __x is lexicographically less than @a __y.
+   *
+   *  This is a total ordering relation.  It is linear in the size of the
+   *  vectors.  The elements must be comparable with @c <.
+   *
+   *  See std::lexicographical_compare() for how the determination is made.
+  */
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+					  __y.begin(), __y.end()); }
+
+  /// Based on operator==
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  /// See std::vector::swap().
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _STL_VECTOR_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stream_iterator.h b/gcc-4.9/libstdc++-v3/include/bits/stream_iterator.h
new file mode 100644
index 0000000..7db26df
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stream_iterator.h
@@ -0,0 +1,221 @@
+// Stream iterators
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/stream_iterator.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ */
+
+#ifndef _STREAM_ITERATOR_H
+#define _STREAM_ITERATOR_H 1
+
+#pragma GCC system_header
+
+#include <debug/debug.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup iterators
+   * @{
+   */
+
+  /// Provides input iterator semantics for streams.
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
+    class istream_iterator
+    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
+    {
+    public:
+      typedef _CharT                         char_type;
+      typedef _Traits                        traits_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+    private:
+      istream_type*	_M_stream;
+      _Tp		_M_value;
+      bool		_M_ok;
+
+    public:
+      ///  Construct end of input stream iterator.
+      _GLIBCXX_CONSTEXPR istream_iterator()
+      : _M_stream(0), _M_value(), _M_ok(false) {}
+
+      ///  Construct start of input stream iterator.
+      istream_iterator(istream_type& __s)
+      : _M_stream(&__s)
+      { _M_read(); }
+
+      istream_iterator(const istream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
+        _M_ok(__obj._M_ok)
+      { }
+
+      const _Tp&
+      operator*() const
+      {
+	__glibcxx_requires_cond(_M_ok,
+				_M_message(__gnu_debug::__msg_deref_istream)
+				._M_iterator(*this));
+	return _M_value;
+      }
+
+      const _Tp*
+      operator->() const { return &(operator*()); }
+
+      istream_iterator&
+      operator++()
+      {
+	__glibcxx_requires_cond(_M_ok,
+				_M_message(__gnu_debug::__msg_inc_istream)
+				._M_iterator(*this));
+	_M_read();
+	return *this;
+      }
+
+      istream_iterator
+      operator++(int)
+      {
+	__glibcxx_requires_cond(_M_ok,
+				_M_message(__gnu_debug::__msg_inc_istream)
+				._M_iterator(*this));
+	istream_iterator __tmp = *this;
+	_M_read();
+	return __tmp;
+      }
+
+      bool
+      _M_equal(const istream_iterator& __x) const
+      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
+
+    private:
+      void
+      _M_read()
+      {
+	_M_ok = (_M_stream && *_M_stream) ? true : false;
+	if (_M_ok)
+	  {
+	    *_M_stream >> _M_value;
+	    _M_ok = *_M_stream ? true : false;
+	  }
+      }
+    };
+
+  ///  Return true if x and y are both end or not end, or x and y are the same.
+  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
+    inline bool
+    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+	       const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return __x._M_equal(__y); }
+
+  ///  Return false if x and y are both end or not end, or x and y are the same.
+  template <class _Tp, class _CharT, class _Traits, class _Dist>
+    inline bool
+    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+	       const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return !__x._M_equal(__y); }
+
+  /**
+   *  @brief  Provides output iterator semantics for streams.
+   *
+   *  This class provides an iterator to write to an ostream.  The type Tp is
+   *  the only type written by this iterator and there must be an
+   *  operator<<(Tp) defined.
+   *
+   *  @tparam  _Tp  The type to write to the ostream.
+   *  @tparam  _CharT  The ostream char_type.
+   *  @tparam  _Traits  The ostream char_traits.
+  */
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT> >
+    class ostream_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      //@{
+      /// Public typedef
+      typedef _CharT                         char_type;
+      typedef _Traits                        traits_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+      //@}
+
+    private:
+      ostream_type*	_M_stream;
+      const _CharT*	_M_string;
+
+    public:
+      /// Construct from an ostream.
+      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
+
+      /**
+       *  Construct from an ostream.
+       *
+       *  The delimiter string @a c is written to the stream after every Tp
+       *  written to the stream.  The delimiter is not copied, and thus must
+       *  not be destroyed while this iterator is in use.
+       *
+       *  @param  __s  Underlying ostream to write to.
+       *  @param  __c  CharT delimiter string to insert.
+      */
+      ostream_iterator(ostream_type& __s, const _CharT* __c)
+      : _M_stream(&__s), _M_string(__c)  { }
+
+      /// Copy constructor.
+      ostream_iterator(const ostream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_string(__obj._M_string)  { }
+
+      /// Writes @a value to underlying ostream using operator<<.  If
+      /// constructed with delimiter string, writes delimiter to ostream.
+      ostream_iterator&
+      operator=(const _Tp& __value)
+      {
+	__glibcxx_requires_cond(_M_stream != 0,
+				_M_message(__gnu_debug::__msg_output_ostream)
+				._M_iterator(*this));
+	*_M_stream << __value;
+	if (_M_string) *_M_stream << _M_string;
+	return *this;
+      }
+
+      ostream_iterator&
+      operator*()
+      { return *this; }
+
+      ostream_iterator&
+      operator++()
+      { return *this; }
+
+      ostream_iterator&
+      operator++(int)
+      { return *this; }
+    };
+
+  // @} group iterators
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/streambuf.tcc b/gcc-4.9/libstdc++-v3/include/bits/streambuf.tcc
new file mode 100644
index 0000000..b22e100
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/streambuf.tcc
@@ -0,0 +1,175 @@
+// Stream buffer classes -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/streambuf.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{streambuf}
+ */
+
+//
+// ISO C++ 14882: 27.5  Stream buffers
+//
+
+#ifndef _STREAMBUF_TCC
+#define _STREAMBUF_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsgetn(char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+	{
+	  const streamsize __buf_len = this->egptr() - this->gptr();
+	  if (__buf_len)
+	    {
+	      const streamsize __remaining = __n - __ret;
+	      const streamsize __len = std::min(__buf_len, __remaining);
+	      traits_type::copy(__s, this->gptr(), __len);
+	      __ret += __len;
+	      __s += __len;
+	      this->__safe_gbump(__len);
+	    }
+
+	  if (__ret < __n)
+	    {
+	      const int_type __c = this->uflow();
+	      if (!traits_type::eq_int_type(__c, traits_type::eof()))
+		{
+		  traits_type::assign(*__s++, traits_type::to_char_type(__c));
+		  ++__ret;
+		}
+	      else
+		break;
+	    }
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsputn(const char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+	{
+	  const streamsize __buf_len = this->epptr() - this->pptr();
+	  if (__buf_len)
+	    {
+	      const streamsize __remaining = __n - __ret;
+	      const streamsize __len = std::min(__buf_len, __remaining);
+	      traits_type::copy(this->pptr(), __s, __len);
+	      __ret += __len;
+	      __s += __len;
+	      this->__safe_pbump(__len);
+	    }
+
+	  if (__ret < __n)
+	    {
+	      int_type __c = this->overflow(traits_type::to_int_type(*__s));
+	      if (!traits_type::eq_int_type(__c, traits_type::eof()))
+		{
+		  ++__ret;
+		  ++__s;
+		}
+	      else
+		break;
+	    }
+	}
+      return __ret;
+    }
+
+  // Conceivably, this could be used to implement buffer-to-buffer
+  // copies, if this was ever desired in an un-ambiguous way by the
+  // standard.
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
+			  basic_streambuf<_CharT, _Traits>* __sbout,
+			  bool& __ineof)
+    {
+      streamsize __ret = 0;
+      __ineof = true;
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+	{
+	  __c = __sbout->sputc(_Traits::to_char_type(__c));
+	  if (_Traits::eq_int_type(__c, _Traits::eof()))
+	    {
+	      __ineof = false;
+	      break;
+	    }
+	  ++__ret;
+	  __c = __sbin->snextc();
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline streamsize
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+		      basic_streambuf<_CharT, _Traits>* __sbout)
+    {
+      bool __ineof;
+      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
+    }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*,
+		      basic_streambuf<char>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>*,
+			  basic_streambuf<char>*, bool&);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*,
+		      basic_streambuf<wchar_t>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
+			  basic_streambuf<wchar_t>*, bool&);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/streambuf_iterator.h b/gcc-4.9/libstdc++-v3/include/bits/streambuf_iterator.h
new file mode 100644
index 0000000..74f6962
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/streambuf_iterator.h
@@ -0,0 +1,412 @@
+// Streambuf iterators
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/streambuf_iterator.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{iterator}
+ */
+
+#ifndef _STREAMBUF_ITERATOR_H
+#define _STREAMBUF_ITERATOR_H 1
+
+#pragma GCC system_header
+
+#include <streambuf>
+#include <debug/debug.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+     
+  /**
+   * @addtogroup iterators
+   * @{
+   */
+
+  // 24.5.3 Template class istreambuf_iterator
+  /// Provides input iterator semantics for streambufs.
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+                      _CharT*,
+#if __cplusplus >= 201103L
+    // LWG 445.
+		      _CharT>
+#else
+		      _CharT&>
+#endif
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT					char_type;
+      typedef _Traits					traits_type;
+      typedef typename _Traits::int_type		int_type;
+      typedef basic_streambuf<_CharT, _Traits>		streambuf_type;
+      typedef basic_istream<_CharT, _Traits>		istream_type;
+      //@}
+
+      template<typename _CharT2>
+	friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+		                    ostreambuf_iterator<_CharT2> >::__type
+	copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+	     ostreambuf_iterator<_CharT2>);
+
+      template<bool _IsMove, typename _CharT2>
+	friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, 
+					       _CharT2*>::__type
+	__copy_move_a2(istreambuf_iterator<_CharT2>,
+		       istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+	friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+			            istreambuf_iterator<_CharT2> >::__type
+	find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+	     const _CharT2&);
+
+    private:
+      // 24.5.3 istreambuf_iterator
+      // p 1
+      // If the end of stream is reached (streambuf_type::sgetc()
+      // returns traits_type::eof()), the iterator becomes equal to
+      // the "end of stream" iterator value.
+      // NB: This implementation assumes the "end of stream" value
+      // is EOF, or -1.
+      mutable streambuf_type*	_M_sbuf;
+      mutable int_type		_M_c;
+
+    public:
+      ///  Construct end of input stream iterator.
+      _GLIBCXX_CONSTEXPR istreambuf_iterator() _GLIBCXX_USE_NOEXCEPT
+      : _M_sbuf(0), _M_c(traits_type::eof()) { }
+
+#if __cplusplus >= 201103L
+      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
+
+      ~istreambuf_iterator() = default;
+#endif
+
+      ///  Construct start of input stream iterator.
+      istreambuf_iterator(istream_type& __s) _GLIBCXX_USE_NOEXCEPT
+      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
+
+      ///  Construct start of streambuf iterator.
+      istreambuf_iterator(streambuf_type* __s) _GLIBCXX_USE_NOEXCEPT
+      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
+
+      ///  Return the current character pointed to by iterator.  This returns
+      ///  streambuf.sgetc().  It cannot be assigned.  NB: The result of
+      ///  operator*() on an end of stream is undefined.
+      char_type
+      operator*() const
+      {
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+	// Dereferencing a past-the-end istreambuf_iterator is a
+	// libstdc++ extension
+	__glibcxx_requires_cond(!_M_at_eof(),
+				_M_message(__gnu_debug::__msg_deref_istreambuf)
+				._M_iterator(*this));
+#endif
+	return traits_type::to_char_type(_M_get());
+      }
+
+      /// Advance the iterator.  Calls streambuf.sbumpc().
+      istreambuf_iterator&
+      operator++()
+      {
+	__glibcxx_requires_cond(!_M_at_eof(),
+				_M_message(__gnu_debug::__msg_inc_istreambuf)
+				._M_iterator(*this));
+	if (_M_sbuf)
+	  {
+	    _M_sbuf->sbumpc();
+	    _M_c = traits_type::eof();
+	  }
+	return *this;
+      }
+
+      /// Advance the iterator.  Calls streambuf.sbumpc().
+      istreambuf_iterator
+      operator++(int)
+      {
+	__glibcxx_requires_cond(!_M_at_eof(),
+				_M_message(__gnu_debug::__msg_inc_istreambuf)
+				._M_iterator(*this));
+
+	istreambuf_iterator __old = *this;
+	if (_M_sbuf)
+	  {
+	    __old._M_c = _M_sbuf->sbumpc();
+	    _M_c = traits_type::eof();
+	  }
+	return __old;
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 110 istreambuf_iterator::equal not const
+      // NB: there is also number 111 (NAD, Future) pending on this function.
+      /// Return true both iterators are end or both are not end.
+      bool
+      equal(const istreambuf_iterator& __b) const
+      { return _M_at_eof() == __b._M_at_eof(); }
+
+    private:
+      int_type
+      _M_get() const
+      {
+	const int_type __eof = traits_type::eof();
+	int_type __ret = __eof;
+	if (_M_sbuf)
+	  {
+	    if (!traits_type::eq_int_type(_M_c, __eof))
+	      __ret = _M_c;
+	    else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
+					       __eof))
+	      _M_c = __ret;
+	    else
+	      _M_sbuf = 0;
+	  }
+	return __ret;
+      }
+
+      bool
+      _M_at_eof() const
+      {
+	const int_type __eof = traits_type::eof();
+	return traits_type::eq_int_type(_M_get(), __eof);
+      }
+    };
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
+	       const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return __a.equal(__b); }
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
+	       const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return !__a.equal(__b); }
+
+  /// Provides output iterator semantics for streambufs.
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      // Types:
+      //@{
+      /// Public typedefs
+      typedef _CharT                           char_type;
+      typedef _Traits                          traits_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_ostream<_CharT, _Traits>   ostream_type;
+      //@}
+
+      template<typename _CharT2>
+	friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+		                    ostreambuf_iterator<_CharT2> >::__type
+	copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+	     ostreambuf_iterator<_CharT2>);
+
+    private:
+      streambuf_type*	_M_sbuf;
+      bool		_M_failed;
+
+    public:
+      ///  Construct output iterator from ostream.
+      ostreambuf_iterator(ostream_type& __s) _GLIBCXX_USE_NOEXCEPT
+      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
+
+      ///  Construct output iterator from streambuf.
+      ostreambuf_iterator(streambuf_type* __s) _GLIBCXX_USE_NOEXCEPT
+      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
+
+      ///  Write character to streambuf.  Calls streambuf.sputc().
+      ostreambuf_iterator&
+      operator=(_CharT __c)
+      {
+	if (!_M_failed &&
+	    _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
+	  _M_failed = true;
+	return *this;
+      }
+
+      /// Return *this.
+      ostreambuf_iterator&
+      operator*()
+      { return *this; }
+
+      /// Return *this.
+      ostreambuf_iterator&
+      operator++(int)
+      { return *this; }
+
+      /// Return *this.
+      ostreambuf_iterator&
+      operator++()
+      { return *this; }
+
+      /// Return true if previous operator=() failed.
+      bool
+      failed() const _GLIBCXX_USE_NOEXCEPT
+      { return _M_failed; }
+
+      ostreambuf_iterator&
+      _M_put(const _CharT* __ws, streamsize __len)
+      {
+	if (__builtin_expect(!_M_failed, true)
+	    && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
+				false))
+	  _M_failed = true;
+	return *this;
+      }
+    };
+
+  // Overloads for streambuf iterators.
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+    	                 	    ostreambuf_iterator<_CharT> >::__type
+    copy(istreambuf_iterator<_CharT> __first,
+	 istreambuf_iterator<_CharT> __last,
+	 ostreambuf_iterator<_CharT> __result)
+    {
+      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
+	{
+	  bool __ineof;
+	  __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
+	  if (!__ineof)
+	    __result._M_failed = true;
+	}
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, 
+    				    ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(_CharT* __first, _CharT* __last,
+		   ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+	__result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+				    ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(const _CharT* __first, const _CharT* __last,
+		   ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+	__result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, 
+    				    _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT> __first,
+		   istreambuf_iterator<_CharT> __last, _CharT* __result)
+    {
+      typedef istreambuf_iterator<_CharT>                  __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type     traits_type;
+      typedef typename __is_iterator_type::streambuf_type  streambuf_type;
+      typedef typename traits_type::int_type               int_type;
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+	{
+	  streambuf_type* __sb = __first._M_sbuf;
+	  int_type __c = __sb->sgetc();
+	  while (!traits_type::eq_int_type(__c, traits_type::eof()))
+	    {
+	      const streamsize __n = __sb->egptr() - __sb->gptr();
+	      if (__n > 1)
+		{
+		  traits_type::copy(__result, __sb->gptr(), __n);
+		  __sb->__safe_gbump(__n);
+		  __result += __n;
+		  __c = __sb->underflow();
+		}
+	      else
+		{
+		  *__result++ = traits_type::to_char_type(__c);
+		  __c = __sb->snextc();
+		}
+	    }
+	}
+      return __result;
+    }
+
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+		  		    istreambuf_iterator<_CharT> >::__type
+    find(istreambuf_iterator<_CharT> __first,
+	 istreambuf_iterator<_CharT> __last, const _CharT& __val)
+    {
+      typedef istreambuf_iterator<_CharT>                  __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type     traits_type;
+      typedef typename __is_iterator_type::streambuf_type  streambuf_type;
+      typedef typename traits_type::int_type               int_type;
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+	{
+	  const int_type __ival = traits_type::to_int_type(__val);
+	  streambuf_type* __sb = __first._M_sbuf;
+	  int_type __c = __sb->sgetc();
+	  while (!traits_type::eq_int_type(__c, traits_type::eof())
+		 && !traits_type::eq_int_type(__c, __ival))
+	    {
+	      streamsize __n = __sb->egptr() - __sb->gptr();
+	      if (__n > 1)
+		{
+		  const _CharT* __p = traits_type::find(__sb->gptr(),
+							__n, __val);
+		  if (__p)
+		    __n = __p - __sb->gptr();
+		  __sb->__safe_gbump(__n);
+		  __c = __sb->sgetc();
+		}
+	      else
+		__c = __sb->snextc();
+	    }
+
+	  if (!traits_type::eq_int_type(__c, traits_type::eof()))
+	    __first._M_c = __c;
+	  else
+	    __first._M_sbuf = 0;
+	}
+      return __first;
+    }
+
+// @} group iterators
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/stringfwd.h b/gcc-4.9/libstdc++-v3/include/bits/stringfwd.h
new file mode 100644
index 0000000..132b88e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/stringfwd.h
@@ -0,0 +1,89 @@
+// <string> Forward declarations -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/stringfwd.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{string}
+ */
+
+//
+// ISO C++ 14882: 21 Strings library
+//
+
+#ifndef _STRINGFWD_H
+#define _STRINGFWD_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/memoryfwd.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @defgroup strings Strings
+   *
+   *  @{
+  */
+
+  template<class _CharT>
+    struct char_traits;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Alloc = allocator<_CharT> >
+    class basic_string;
+
+  template<> struct char_traits<char>;
+
+  /// A string of @c char
+  typedef basic_string<char>    string;   
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<> struct char_traits<wchar_t>;
+
+  /// A string of @c wchar_t
+  typedef basic_string<wchar_t> wstring;   
+#endif
+
+#if ((__cplusplus >= 201103L) \
+     && defined(_GLIBCXX_USE_C99_STDINT_TR1))
+
+  template<> struct char_traits<char16_t>;
+  template<> struct char_traits<char32_t>;
+
+  /// A string of @c char16_t
+  typedef basic_string<char16_t> u16string; 
+
+  /// A string of @c char32_t
+  typedef basic_string<char32_t> u32string; 
+
+#endif
+  /** @}  */
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif	// _STRINGFWD_H
diff --git a/gcc-4.9/libstdc++-v3/include/bits/unique_ptr.h b/gcc-4.9/libstdc++-v3/include/bits/unique_ptr.h
new file mode 100644
index 0000000..c72fbc7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/unique_ptr.h
@@ -0,0 +1,781 @@
+// unique_ptr implementation -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/unique_ptr.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _UNIQUE_PTR_H
+#define _UNIQUE_PTR_H 1
+
+#include <bits/c++config.h>
+#include <debug/debug.h>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup pointer_abstractions
+   * @{
+   */
+
+#if _GLIBCXX_USE_DEPRECATED
+  template<typename> class auto_ptr;
+#endif
+
+  /// Primary template of default_delete, used by unique_ptr
+  template<typename _Tp>
+    struct default_delete
+    {
+      /// Default constructor
+      constexpr default_delete() noexcept = default;
+
+      /** @brief Converting constructor.
+       *
+       * Allows conversion from a deleter for arrays of another type, @p _Up,
+       * only if @p _Up* is convertible to @p _Tp*.
+       */
+      template<typename _Up, typename = typename
+	       enable_if<is_convertible<_Up*, _Tp*>::value>::type>
+        default_delete(const default_delete<_Up>&) noexcept { }
+
+      /// Calls @c delete @p __ptr
+      void
+      operator()(_Tp* __ptr) const
+      {
+	static_assert(!is_void<_Tp>::value,
+		      "can't delete pointer to incomplete type");
+	static_assert(sizeof(_Tp)>0,
+		      "can't delete pointer to incomplete type");
+	delete __ptr;
+      }
+    };
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 740 - omit specialization for array objects with a compile time length
+  /// Specialization for arrays, default_delete.
+  template<typename _Tp>
+    struct default_delete<_Tp[]>
+    {
+    private:
+      template<typename _Up>
+	using __remove_cv = typename remove_cv<_Up>::type;
+
+      // Like is_base_of<_Tp, _Up> but false if unqualified types are the same
+      template<typename _Up>
+	using __is_derived_Tp
+	  = __and_< is_base_of<_Tp, _Up>,
+		    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+    public:
+      /// Default constructor
+      constexpr default_delete() noexcept = default;
+
+      /** @brief Converting constructor.
+       *
+       * Allows conversion from a deleter for arrays of another type, such as
+       * a const-qualified version of @p _Tp.
+       *
+       * Conversions from types derived from @c _Tp are not allowed because
+       * it is unsafe to @c delete[] an array of derived types through a
+       * pointer to the base type.
+       */
+      template<typename _Up, typename = typename
+	       enable_if<!__is_derived_Tp<_Up>::value>::type>
+        default_delete(const default_delete<_Up[]>&) noexcept { }
+
+      /// Calls @c delete[] @p __ptr
+      void
+      operator()(_Tp* __ptr) const
+      {
+	static_assert(sizeof(_Tp)>0,
+		      "can't delete pointer to incomplete type");
+	delete [] __ptr;
+      }
+
+      template<typename _Up>
+	typename enable_if<__is_derived_Tp<_Up>::value>::type
+	operator()(_Up*) const = delete;
+    };
+
+  /// 20.7.1.2 unique_ptr for single objects.
+  template <typename _Tp, typename _Dp = default_delete<_Tp> >
+    class unique_ptr
+    {
+      // use SFINAE to determine whether _Del::pointer exists
+      class _Pointer
+      {
+	template<typename _Up>
+	  static typename _Up::pointer __test(typename _Up::pointer*);
+
+	template<typename _Up>
+	  static _Tp* __test(...);
+
+	typedef typename remove_reference<_Dp>::type _Del;
+
+      public:
+	typedef decltype(__test<_Del>(0)) type;
+      };
+
+      typedef std::tuple<typename _Pointer::type, _Dp>  __tuple_type;
+      __tuple_type                                      _M_t;
+
+    public:
+      typedef typename _Pointer::type   pointer;
+      typedef _Tp                       element_type;
+      typedef _Dp                       deleter_type;
+
+      // Constructors.
+
+      /// Default constructor, creates a unique_ptr that owns nothing.
+      constexpr unique_ptr() noexcept
+      : _M_t()
+      { static_assert(!is_pointer<deleter_type>::value,
+		     "constructed with null function pointer deleter"); }
+
+      /** Takes ownership of a pointer.
+       *
+       * @param __p  A pointer to an object of @c element_type
+       *
+       * The deleter will be value-initialized.
+       */
+      explicit
+      unique_ptr(pointer __p) noexcept
+      : _M_t(__p, deleter_type())
+      { static_assert(!is_pointer<deleter_type>::value,
+		     "constructed with null function pointer deleter"); }
+
+      /** Takes ownership of a pointer.
+       *
+       * @param __p  A pointer to an object of @c element_type
+       * @param __d  A reference to a deleter.
+       *
+       * The deleter will be initialized with @p __d
+       */
+      unique_ptr(pointer __p,
+	  typename conditional<is_reference<deleter_type>::value,
+	    deleter_type, const deleter_type&>::type __d) noexcept
+      : _M_t(__p, __d) { }
+
+      /** Takes ownership of a pointer.
+       *
+       * @param __p  A pointer to an object of @c element_type
+       * @param __d  An rvalue reference to a deleter.
+       *
+       * The deleter will be initialized with @p std::move(__d)
+       */
+      unique_ptr(pointer __p,
+	  typename remove_reference<deleter_type>::type&& __d) noexcept
+      : _M_t(std::move(__p), std::move(__d))
+      { static_assert(!std::is_reference<deleter_type>::value,
+		      "rvalue deleter bound to reference"); }
+
+      /// Creates a unique_ptr that owns nothing.
+      constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
+
+      // Move constructors.
+
+      /// Move constructor.
+      unique_ptr(unique_ptr&& __u) noexcept
+      : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
+
+      /** @brief Converting constructor from another type
+       *
+       * Requires that the pointer owned by @p __u is convertible to the
+       * type of pointer owned by this object, @p __u does not own an array,
+       * and @p __u has a compatible deleter type.
+       */
+      template<typename _Up, typename _Ep, typename = _Require<
+	       is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+	       __not_<is_array<_Up>>,
+	       typename conditional<is_reference<_Dp>::value,
+				    is_same<_Ep, _Dp>,
+				    is_convertible<_Ep, _Dp>>::type>>
+	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+	: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
+	{ }
+
+#if _GLIBCXX_USE_DEPRECATED
+      /// Converting constructor from @c auto_ptr
+      template<typename _Up, typename = _Require<
+	       is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
+	unique_ptr(auto_ptr<_Up>&& __u) noexcept;
+#endif
+
+      /// Destructor, invokes the deleter if the stored pointer is not null.
+      ~unique_ptr() noexcept
+      {
+	auto& __ptr = std::get<0>(_M_t);
+	if (__ptr != nullptr)
+	  get_deleter()(__ptr);
+	__ptr = pointer();
+      }
+
+      // Assignment.
+
+      /** @brief Move assignment operator.
+       *
+       * @param __u  The object to transfer ownership from.
+       *
+       * Invokes the deleter first if this object owns a pointer.
+       */
+      unique_ptr&
+      operator=(unique_ptr&& __u) noexcept
+      {
+	reset(__u.release());
+	get_deleter() = std::forward<deleter_type>(__u.get_deleter());
+	return *this;
+      }
+
+      /** @brief Assignment from another type.
+       *
+       * @param __u  The object to transfer ownership from, which owns a
+       *             convertible pointer to a non-array object.
+       *
+       * Invokes the deleter first if this object owns a pointer.
+       */
+      template<typename _Up, typename _Ep>
+	typename enable_if< __and_<
+	  is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+	  __not_<is_array<_Up>>
+	  >::value,
+	  unique_ptr&>::type
+	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+	{
+	  reset(__u.release());
+	  get_deleter() = std::forward<_Ep>(__u.get_deleter());
+	  return *this;
+	}
+
+      /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
+      unique_ptr&
+      operator=(nullptr_t) noexcept
+      {
+	reset();
+	return *this;
+      }
+
+      // Observers.
+
+      /// Dereference the stored pointer.
+      typename add_lvalue_reference<element_type>::type
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(get() != pointer());
+	return *get();
+      }
+
+      /// Return the stored pointer.
+      pointer
+      operator->() const noexcept
+      {
+	_GLIBCXX_DEBUG_ASSERT(get() != pointer());
+	return get();
+      }
+
+      /// Return the stored pointer.
+      pointer
+      get() const noexcept
+      { return std::get<0>(_M_t); }
+
+      /// Return a reference to the stored deleter.
+      deleter_type&
+      get_deleter() noexcept
+      { return std::get<1>(_M_t); }
+
+      /// Return a reference to the stored deleter.
+      const deleter_type&
+      get_deleter() const noexcept
+      { return std::get<1>(_M_t); }
+
+      /// Return @c true if the stored pointer is not null.
+      explicit operator bool() const noexcept
+      { return get() == pointer() ? false : true; }
+
+      // Modifiers.
+
+      /// Release ownership of any stored pointer.
+      pointer
+      release() noexcept
+      {
+	pointer __p = get();
+	std::get<0>(_M_t) = pointer();
+	return __p;
+      }
+
+      /** @brief Replace the stored pointer.
+       *
+       * @param __p  The new pointer to store.
+       *
+       * The deleter will be invoked if a pointer is already owned.
+       */
+      void
+      reset(pointer __p = pointer()) noexcept
+      {
+	using std::swap;
+	swap(std::get<0>(_M_t), __p);
+	if (__p != pointer())
+	  get_deleter()(__p);
+      }
+
+      /// Exchange the pointer and deleter with another object.
+      void
+      swap(unique_ptr& __u) noexcept
+      {
+	using std::swap;
+	swap(_M_t, __u._M_t);
+      }
+
+      // Disable copy from lvalue.
+      unique_ptr(const unique_ptr&) = delete;
+      unique_ptr& operator=(const unique_ptr&) = delete;
+  };
+
+  /// 20.7.1.3 unique_ptr for array objects with a runtime length
+  // [unique.ptr.runtime]
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 740 - omit specialization for array objects with a compile time length
+  template<typename _Tp, typename _Dp>
+    class unique_ptr<_Tp[], _Dp>
+    {
+      // use SFINAE to determine whether _Del::pointer exists
+      class _Pointer
+      {
+	template<typename _Up>
+	  static typename _Up::pointer __test(typename _Up::pointer*);
+
+	template<typename _Up>
+	  static _Tp* __test(...);
+
+	typedef typename remove_reference<_Dp>::type _Del;
+
+      public:
+	typedef decltype(__test<_Del>(0)) type;
+      };
+
+      typedef std::tuple<typename _Pointer::type, _Dp>  __tuple_type;
+      __tuple_type                                      _M_t;
+
+      template<typename _Up>
+	using __remove_cv = typename remove_cv<_Up>::type;
+
+      // like is_base_of<_Tp, _Up> but false if unqualified types are the same
+      template<typename _Up>
+	using __is_derived_Tp
+	  = __and_< is_base_of<_Tp, _Up>,
+		    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+      template<typename _Up, typename _Ep,
+	       typename _Tp_pointer = typename _Pointer::type,
+	       typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
+	using __safe_conversion = __and_<
+	    is_convertible<_Up_pointer, _Tp_pointer>,
+	    is_array<_Up>,
+	    __or_<__not_<is_pointer<_Up_pointer>>,
+		  __not_<is_pointer<_Tp_pointer>>,
+		  __not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
+	    >
+	  >;
+
+    public:
+      typedef typename _Pointer::type	pointer;
+      typedef _Tp		 	element_type;
+      typedef _Dp                       deleter_type;
+
+      // Constructors.
+
+      /// Default constructor, creates a unique_ptr that owns nothing.
+      constexpr unique_ptr() noexcept
+      : _M_t()
+      { static_assert(!std::is_pointer<deleter_type>::value,
+		      "constructed with null function pointer deleter"); }
+
+      /** Takes ownership of a pointer.
+       *
+       * @param __p  A pointer to an array of @c element_type
+       *
+       * The deleter will be value-initialized.
+       */
+      explicit
+      unique_ptr(pointer __p) noexcept
+      : _M_t(__p, deleter_type())
+      { static_assert(!is_pointer<deleter_type>::value,
+		      "constructed with null function pointer deleter"); }
+
+      // Disable construction from convertible pointer types.
+      template<typename _Up, typename = _Require<is_pointer<pointer>,
+	       is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+	explicit
+	unique_ptr(_Up* __p) = delete;
+
+      /** Takes ownership of a pointer.
+       *
+       * @param __p  A pointer to an array of @c element_type
+       * @param __d  A reference to a deleter.
+       *
+       * The deleter will be initialized with @p __d
+       */
+      unique_ptr(pointer __p,
+	  typename conditional<is_reference<deleter_type>::value,
+	      deleter_type, const deleter_type&>::type __d) noexcept
+      : _M_t(__p, __d) { }
+
+      /** Takes ownership of a pointer.
+       *
+       * @param __p  A pointer to an array of @c element_type
+       * @param __d  A reference to a deleter.
+       *
+       * The deleter will be initialized with @p std::move(__d)
+       */
+      unique_ptr(pointer __p, typename
+		 remove_reference<deleter_type>::type&& __d) noexcept
+      : _M_t(std::move(__p), std::move(__d))
+      { static_assert(!is_reference<deleter_type>::value,
+		      "rvalue deleter bound to reference"); }
+
+      /// Move constructor.
+      unique_ptr(unique_ptr&& __u) noexcept
+      : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
+
+      /// Creates a unique_ptr that owns nothing.
+      constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
+
+      template<typename _Up, typename _Ep,
+	       typename = _Require<__safe_conversion<_Up, _Ep>,
+		 typename conditional<is_reference<_Dp>::value,
+				      is_same<_Ep, _Dp>,
+				      is_convertible<_Ep, _Dp>>::type
+	       >>
+	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+	: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
+	{ }
+
+      /// Destructor, invokes the deleter if the stored pointer is not null.
+      ~unique_ptr()
+      {
+	auto& __ptr = std::get<0>(_M_t);
+	if (__ptr != nullptr)
+	  get_deleter()(__ptr);
+	__ptr = pointer();
+      }
+
+      // Assignment.
+
+      /** @brief Move assignment operator.
+       *
+       * @param __u  The object to transfer ownership from.
+       *
+       * Invokes the deleter first if this object owns a pointer.
+       */
+      unique_ptr&
+      operator=(unique_ptr&& __u) noexcept
+      {
+	reset(__u.release());
+	get_deleter() = std::forward<deleter_type>(__u.get_deleter());
+	return *this;
+      }
+
+      /** @brief Assignment from another type.
+       *
+       * @param __u  The object to transfer ownership from, which owns a
+       *             convertible pointer to an array object.
+       *
+       * Invokes the deleter first if this object owns a pointer.
+       */
+      template<typename _Up, typename _Ep>
+	typename
+	enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
+	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+	{
+	  reset(__u.release());
+	  get_deleter() = std::forward<_Ep>(__u.get_deleter());
+	  return *this;
+	}
+
+      /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
+      unique_ptr&
+      operator=(nullptr_t) noexcept
+      {
+	reset();
+	return *this;
+      }
+
+      // Observers.
+
+      /// Access an element of owned array.
+      typename std::add_lvalue_reference<element_type>::type
+      operator[](size_t __i) const
+      {
+	_GLIBCXX_DEBUG_ASSERT(get() != pointer());
+	return get()[__i];
+      }
+
+      /// Return the stored pointer.
+      pointer
+      get() const noexcept
+      { return std::get<0>(_M_t); }
+
+      /// Return a reference to the stored deleter.
+      deleter_type&
+      get_deleter() noexcept
+      { return std::get<1>(_M_t); }
+
+      /// Return a reference to the stored deleter.
+      const deleter_type&
+      get_deleter() const noexcept
+      { return std::get<1>(_M_t); }
+
+      /// Return @c true if the stored pointer is not null.
+      explicit operator bool() const noexcept
+      { return get() == pointer() ? false : true; }
+
+      // Modifiers.
+
+      /// Release ownership of any stored pointer.
+      pointer
+      release() noexcept
+      {
+	pointer __p = get();
+	std::get<0>(_M_t) = pointer();
+	return __p;
+      }
+
+      /** @brief Replace the stored pointer.
+       *
+       * @param __p  The new pointer to store.
+       *
+       * The deleter will be invoked if a pointer is already owned.
+       */
+      void
+      reset(pointer __p = pointer()) noexcept
+      {
+	using std::swap;
+	swap(std::get<0>(_M_t), __p);
+	if (__p != nullptr)
+	  get_deleter()(__p);
+      }
+
+      // Disable resetting from convertible pointer types.
+      template<typename _Up, typename = _Require<is_pointer<pointer>,
+	       is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+	void reset(_Up*) = delete;
+
+      /// Exchange the pointer and deleter with another object.
+      void
+      swap(unique_ptr& __u) noexcept
+      {
+	using std::swap;
+	swap(_M_t, __u._M_t);
+      }
+
+      // Disable copy from lvalue.
+      unique_ptr(const unique_ptr&) = delete;
+      unique_ptr& operator=(const unique_ptr&) = delete;
+
+      // Disable construction from convertible pointer types.
+      template<typename _Up, typename = _Require<is_pointer<pointer>,
+	       is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+	unique_ptr(_Up*, typename
+		   conditional<is_reference<deleter_type>::value,
+		   deleter_type, const deleter_type&>::type) = delete;
+
+      // Disable construction from convertible pointer types.
+      template<typename _Up, typename = _Require<is_pointer<pointer>,
+	       is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+	unique_ptr(_Up*, typename
+		   remove_reference<deleter_type>::type&&) = delete;
+    };
+
+  template<typename _Tp, typename _Dp>
+    inline void
+    swap(unique_ptr<_Tp, _Dp>& __x,
+	 unique_ptr<_Tp, _Dp>& __y) noexcept
+    { __x.swap(__y); }
+
+  template<typename _Tp, typename _Dp,
+	   typename _Up, typename _Ep>
+    inline bool
+    operator==(const unique_ptr<_Tp, _Dp>& __x,
+	       const unique_ptr<_Up, _Ep>& __y)
+    { return __x.get() == __y.get(); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+    { return !__x; }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+    { return !__x; }
+
+  template<typename _Tp, typename _Dp,
+	   typename _Up, typename _Ep>
+    inline bool
+    operator!=(const unique_ptr<_Tp, _Dp>& __x,
+	       const unique_ptr<_Up, _Ep>& __y)
+    { return __x.get() != __y.get(); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+    { return (bool)__x; }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+    { return (bool)__x; }
+
+  template<typename _Tp, typename _Dp,
+	   typename _Up, typename _Ep>
+    inline bool
+    operator<(const unique_ptr<_Tp, _Dp>& __x,
+	      const unique_ptr<_Up, _Ep>& __y)
+    {
+      typedef typename
+	std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
+	                 typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
+      return std::less<_CT>()(__x.get(), __y.get());
+    }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+								 nullptr); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+								 __x.get()); }
+
+  template<typename _Tp, typename _Dp,
+	   typename _Up, typename _Ep>
+    inline bool
+    operator<=(const unique_ptr<_Tp, _Dp>& __x,
+	       const unique_ptr<_Up, _Ep>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return !(nullptr < __x); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return !(__x < nullptr); }
+
+  template<typename _Tp, typename _Dp,
+	   typename _Up, typename _Ep>
+    inline bool
+    operator>(const unique_ptr<_Tp, _Dp>& __x,
+	      const unique_ptr<_Up, _Ep>& __y)
+    { return (__y < __x); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+								 __x.get()); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+								 nullptr); }
+
+  template<typename _Tp, typename _Dp,
+	   typename _Up, typename _Ep>
+    inline bool
+    operator>=(const unique_ptr<_Tp, _Dp>& __x,
+	       const unique_ptr<_Up, _Ep>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return !(__x < nullptr); }
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return !(nullptr < __x); }
+
+  /// std::hash specialization for unique_ptr.
+  template<typename _Tp, typename _Dp>
+    struct hash<unique_ptr<_Tp, _Dp>>
+    : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
+    {
+      size_t
+      operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
+      {
+	typedef unique_ptr<_Tp, _Dp> _UP;
+	return std::hash<typename _UP::pointer>()(__u.get());
+      }
+    };
+
+#if __cplusplus > 201103L
+  template<typename _Tp>
+    struct _MakeUniq
+    { typedef unique_ptr<_Tp> __single_object; };
+
+  template<typename _Tp>
+    struct _MakeUniq<_Tp[]>
+    { typedef unique_ptr<_Tp[]> __array; };
+
+  template<typename _Tp, size_t _Bound>
+    struct _MakeUniq<_Tp[_Bound]>
+    { struct __invalid_type { }; };
+
+  /// std::make_unique for single objects
+  template<typename _Tp, typename... _Args>
+    inline typename _MakeUniq<_Tp>::__single_object
+    make_unique(_Args&&... __args)
+    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
+
+  /// std::make_unique for arrays of unknown bound
+  template<typename _Tp>
+    inline typename _MakeUniq<_Tp>::__array
+    make_unique(size_t __num)
+    { return unique_ptr<_Tp>(new typename remove_extent<_Tp>::type[__num]()); }
+
+  /// Disable std::make_unique for arrays of known bound
+  template<typename _Tp, typename... _Args>
+    inline typename _MakeUniq<_Tp>::__invalid_type
+    make_unique(_Args&&...) = delete;
+#endif
+
+  // @} group pointer_abstractions
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _UNIQUE_PTR_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/unordered_map.h b/gcc-4.9/libstdc++-v3/include/bits/unordered_map.h
new file mode 100644
index 0000000..e93663c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/unordered_map.h
@@ -0,0 +1,1475 @@
+// unordered_map implementation -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/unordered_map.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{unordered_map}
+ */
+
+#ifndef _UNORDERED_MAP_H
+#define _UNORDERED_MAP_H
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /// Base types for unordered_map.
+  template<bool _Cache>
+    using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;
+
+  template<typename _Key,
+	   typename _Tp,
+	   typename _Hash = hash<_Key>,
+	   typename _Pred = std::equal_to<_Key>,
+	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+	   typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
+    using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+                                        _Alloc, __detail::_Select1st,
+				        _Pred, _Hash,
+				        __detail::_Mod_range_hashing,
+				        __detail::_Default_ranged_hash,
+				        __detail::_Prime_rehash_policy, _Tr>;
+
+  /// Base types for unordered_multimap.
+  template<bool _Cache>
+    using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;
+
+  template<typename _Key,
+	   typename _Tp,
+	   typename _Hash = hash<_Key>,
+	   typename _Pred = std::equal_to<_Key>,
+	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+	   typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
+    using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+					 _Alloc, __detail::_Select1st,
+					 _Pred, _Hash,
+					 __detail::_Mod_range_hashing,
+					 __detail::_Default_ranged_hash,
+					 __detail::_Prime_rehash_policy, _Tr>;
+
+  /**
+   *  @brief A standard container composed of unique keys (containing
+   *  at most one of each key value) that associates values of another type
+   *  with the keys.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  @tparam  _Key    Type of key objects.
+   *  @tparam  _Tp     Type of mapped objects.
+   *  @tparam  _Hash   Hashing function object type, defaults to hash<_Value>.
+   *  @tparam  _Pred   Predicate function object type, defaults
+   *                   to equal_to<_Value>.
+   *  @tparam  _Alloc  Allocator type, defaults to 
+   *                   std::allocator<std::pair<const _Key, _Tp>>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   * The resulting value type of the container is std::pair<const _Key, _Tp>.
+   *
+   *  Base is _Hashtable, dispatched at compile time via template
+   *  alias __umap_hashtable.
+   */
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_map
+    {
+      typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc>  _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+      // typedefs:
+      //@{
+      /// Public typedefs.
+      typedef typename _Hashtable::key_type	key_type;
+      typedef typename _Hashtable::value_type	value_type;
+      typedef typename _Hashtable::mapped_type	mapped_type;
+      typedef typename _Hashtable::hasher	hasher;
+      typedef typename _Hashtable::key_equal	key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+      //@}
+
+      //@{
+      ///  Iterator-related typedefs.
+      typedef typename _Hashtable::pointer		pointer;
+      typedef typename _Hashtable::const_pointer	const_pointer;
+      typedef typename _Hashtable::reference		reference;
+      typedef typename _Hashtable::const_reference	const_reference;
+      typedef typename _Hashtable::iterator		iterator;
+      typedef typename _Hashtable::const_iterator	const_iterator;
+      typedef typename _Hashtable::local_iterator	local_iterator;
+      typedef typename _Hashtable::const_local_iterator	const_local_iterator;
+      typedef typename _Hashtable::size_type		size_type;
+      typedef typename _Hashtable::difference_type	difference_type;
+      //@}
+
+      //construct/destroy/copy
+
+      /**
+       *  @brief  Default constructor creates no elements.
+       *  @param __n  Initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       */
+      explicit
+      unordered_map(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+
+      /**
+       *  @brief  Builds an %unordered_map from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       *
+       *  Create an %unordered_map consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __f, _InputIterator __l,
+		      size_type __n = 0,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+	: _M_h(__f, __l, __n, __hf, __eql, __a)
+	{ }
+
+      /// Copy constructor.
+      unordered_map(const unordered_map&) = default;
+
+      /// Move constructor.
+      unordered_map(unordered_map&&) = default;
+
+      /**
+       *  @brief Creates an %unordered_map with no elements.
+       *  @param __a An allocator object.
+       */
+      explicit
+      unordered_map(const allocator_type& __a)
+	: _M_h(__a)
+      { }
+
+      /*
+       *  @brief Copy constructor with allocator argument.
+       * @param  __uset  Input %unordered_map to copy.
+       * @param  __a  An allocator object.
+       */
+      unordered_map(const unordered_map& __umap,
+		    const allocator_type& __a)
+	: _M_h(__umap._M_h, __a)
+      { }
+
+      /*
+       *  @brief  Move constructor with allocator argument.
+       *  @param  __uset Input %unordered_map to move.
+       *  @param  __a    An allocator object.
+       */
+      unordered_map(unordered_map&& __umap,
+		    const allocator_type& __a)
+	: _M_h(std::move(__umap._M_h), __a)
+      { }
+
+      /**
+       *  @brief  Builds an %unordered_map from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create an %unordered_map consisting of copies of the elements in the
+       *  list. This is linear in N (where N is @a __l.size()).
+       */
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n = 0,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+	: _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      /// Copy assignment operator.
+      unordered_map&
+      operator=(const unordered_map&) = default;
+
+      /// Move assignment operator.
+      unordered_map&
+      operator=(unordered_map&&) = default;
+
+      /**
+       *  @brief  %Unordered_map list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills an %unordered_map with copies of the elements in
+       *  the initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %unordered_map and
+       *  that the resulting %unordered_map's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      unordered_map&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_h = __l;
+	return *this;
+      }
+
+      ///  Returns the allocator object with which the %unordered_map was
+      ///  constructed.
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+      // size and capacity:
+
+      ///  Returns true if the %unordered_map is empty.
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+      ///  Returns the size of the %unordered_map.
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+      ///  Returns the maximum size of the %unordered_map.
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+      // iterators.
+
+      /**
+       *  Returns a read/write iterator that points to the first element in the
+       *  %unordered_map.
+       */
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %unordered_map.
+       */
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+      //@}
+
+      /**
+       *  Returns a read/write iterator that points one past the last element in
+       *  the %unordered_map.
+       */
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %unordered_map.
+       */
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+      //@}
+
+      // modifiers.
+
+      /**
+       *  @brief Attempts to build and insert a std::pair into the %unordered_map.
+       *
+       *  @param __args  Arguments used to generate a new pair instance (see
+       *	        std::piecewise_contruct for passing arguments to each
+       *	        part of the pair constructor).
+       *
+       *  @return  A pair, of which the first element is an iterator that points
+       *           to the possibly inserted pair, and the second is a bool that
+       *           is true if the pair was actually inserted.
+       *
+       *  This function attempts to build and insert a (key, value) %pair into
+       *  the %unordered_map.
+       *  An %unordered_map relies on unique keys and thus a %pair is only
+       *  inserted if its first element (the key) is not already present in the
+       *  %unordered_map.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{ return _M_h.emplace(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Attempts to build and insert a std::pair into the %unordered_map.
+       *
+       *  @param  __pos  An iterator that serves as a hint as to where the pair
+       *                should be inserted.
+       *  @param  __args  Arguments used to generate a new pair instance (see
+       *	         std::piecewise_contruct for passing arguments to each
+       *	         part of the pair constructor).
+       *  @return An iterator that points to the element with key of the
+       *          std::pair built from @a __args (may or may not be that
+       *          std::pair).
+       *
+       *  This function is not concerned about whether the insertion took place,
+       *  and thus does not return a boolean like the single-argument emplace()
+       *  does.
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process. A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  See
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{ return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+
+      //@{
+      /**
+       *  @brief Attempts to insert a std::pair into the %unordered_map.
+
+       *  @param __x Pair to be inserted (see std::make_pair for easy
+       *	     creation of pairs).
+       *
+       *  @return  A pair, of which the first element is an iterator that 
+       *           points to the possibly inserted pair, and the second is 
+       *           a bool that is true if the pair was actually inserted.
+       *
+       *  This function attempts to insert a (key, value) %pair into the
+       *  %unordered_map. An %unordered_map relies on unique keys and thus a
+       *  %pair is only inserted if its first element (the key) is not already
+       *  present in the %unordered_map.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	std::pair<iterator, bool>
+	insert(_Pair&& __x)
+        { return _M_h.insert(std::forward<_Pair>(__x)); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Attempts to insert a std::pair into the %unordered_map.
+       *  @param  __hint  An iterator that serves as a hint as to where the
+       *                 pair should be inserted.
+       *  @param  __x  Pair to be inserted (see std::make_pair for easy creation
+       *               of pairs).
+       *  @return An iterator that points to the element with key of
+       *           @a __x (may or may not be the %pair passed in).
+       *
+       *  This function is not concerned about whether the insertion took place,
+       *  and thus does not return a boolean like the single-argument insert()
+       *  does.  Note that the first parameter is only a hint and can
+       *  potentially improve the performance of the insertion process.  A bad
+       *  hint would cause no gains in efficiency.
+       *
+       *  See
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	iterator
+	insert(const_iterator __hint, _Pair&& __x)
+	{ return _M_h.insert(__hint, std::forward<_Pair>(__x)); }
+      //@}
+
+      /**
+       *  @brief A template function that attempts to insert a range of
+       *  elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{ _M_h.insert(__first, __last); }
+
+      /**
+       *  @brief Attempts to insert a list of elements into the %unordered_map.
+       *  @param  __l  A std::initializer_list<value_type> of elements
+       *               to be inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+
+      //@{
+      /**
+       *  @brief Erases an element from an %unordered_map.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a __position prior to the element being erased. If no such
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from an %unordered_map.
+       *  Note that this function only erases the element, and that if the
+       *  element is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+      // LWG 2059.
+      iterator
+      erase(iterator __it)
+      { return _M_h.erase(__it); }
+      //@}
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of element to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all the elements located by the given key from
+       *  an %unordered_map. For an %unordered_map the result of this function
+       *  can only be 0 (not present) or 1 (present).
+       *  Note that this function only erases the element, and that if the
+       *  element is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+
+      /**
+       *  @brief Erases a [__first,__last) range of elements from an
+       *  %unordered_map.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                  erased.
+       *  @param __last  Iterator pointing to the end of the range to
+       *                be erased.
+       *  @return The iterator @a __last.
+       *
+       *  This function erases a sequence of elements from an %unordered_map.
+       *  Note that this function only erases the elements, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+      /**
+       *  Erases all elements in an %unordered_map.
+       *  Note that this function only erases the elements, and that if the
+       *  elements themselves are pointers, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+
+      /**
+       *  @brief  Swaps data with another %unordered_map.
+       *  @param  __x  An %unordered_map of the same element and allocator
+       *  types.
+       *
+       *  This exchanges the elements between two %unordered_map in constant time.
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(m1,m2) will feed to this function.
+       */
+      void
+      swap(unordered_map& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+
+      // observers.
+
+      ///  Returns the hash functor object with which the %unordered_map was
+      ///  constructed.
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+      ///  Returns the key comparison object with which the %unordered_map was
+      ///  constructed.
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+
+      // lookup.
+
+      //@{
+      /**
+       *  @brief Tries to locate an element in an %unordered_map.
+       *  @param  __x  Key to be located.
+       *  @return  Iterator pointing to sought-after element, or end() if not
+       *           found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after element.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+      //@}
+
+      /**
+       *  @brief  Finds the number of elements.
+       *  @param  __x  Key to count.
+       *  @return  Number of elements with specified key.
+       *
+       *  This function only makes sense for %unordered_multimap; for
+       *  %unordered_map the result will either be 0 (not present) or 1
+       *  (present).
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+
+      //@{
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       *
+       *  This function probably only makes sense for %unordered_multimap.
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+      //@}
+
+      //@{
+      /**
+       *  @brief  Subscript ( @c [] ) access to %unordered_map data.
+       *  @param  __k  The key for which data should be retrieved.
+       *  @return  A reference to the data of the (key,data) %pair.
+       *
+       *  Allows for easy lookup with the subscript ( @c [] )operator.  Returns
+       *  data associated with the key specified in subscript.  If the key does
+       *  not exist, a pair with that key is created using default values, which
+       *  is then returned.
+       *
+       *  Lookup requires constant time.
+       */
+      mapped_type&
+      operator[](const key_type& __k)
+      { return _M_h[__k]; }
+
+      mapped_type&
+      operator[](key_type&& __k)
+      { return _M_h[std::move(__k)]; }
+      //@}
+
+      //@{
+      /**
+       *  @brief  Access to %unordered_map data.
+       *  @param  __k  The key for which data should be retrieved.
+       *  @return  A reference to the data whose key is equal to @a __k, if
+       *           such a data is present in the %unordered_map.
+       *  @throw  std::out_of_range  If no such data is present.
+       */
+      mapped_type&
+      at(const key_type& __k)
+      { return _M_h.at(__k); }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      { return _M_h.at(__k); }
+      //@}
+
+      // bucket interface.
+
+      /// Returns the number of buckets of the %unordered_map.
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+      /// Returns the maximum number of buckets of the %unordered_map.
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+      /*
+       * @brief  Returns the number of elements in a given bucket.
+       * @param  __n  A bucket index.
+       * @return  The number of elements in the bucket.
+       */
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+      /*
+       * @brief  Returns the bucket index of a given element.
+       * @param  __key  A key instance.
+       * @return  The key bucket index.
+       */
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+      
+      /**
+       *  @brief  Returns a read/write iterator pointing to the first bucket
+       *         element.
+       *  @param  __n The bucket index.
+       *  @return  A read/write local iterator.
+       */
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to the first
+       *         bucket element.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+      //@}
+
+      /**
+       *  @brief  Returns a read/write iterator pointing to one past the last
+       *         bucket elements.
+       *  @param  __n The bucket index.
+       *  @return  A read/write local iterator.
+       */
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to one past
+       *         the last bucket elements.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+      //@}
+
+      // hash policy.
+
+      /// Returns the average number of elements per bucket.
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+      /// Returns a positive number that the %unordered_map tries to keep the
+      /// load factor less than or equal to.
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+      /**
+       *  @brief  Change the %unordered_map maximum load factor.
+       *  @param  __z The new maximum load factor.
+       */
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+
+      /**
+       *  @brief  May rehash the %unordered_map.
+       *  @param  __n The new number of buckets.
+       *
+       *  Rehash will occur only if the new number of buckets respect the
+       *  %unordered_map maximum load factor.
+       */
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+
+      /**
+       *  @brief  Prepare the %unordered_map for a specified number of
+       *          elements.
+       *  @param  __n Number of elements required.
+       *
+       *  Same as rehash(ceil(n / max_load_factor())).
+       */
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+	       typename _Alloc1>
+        friend bool
+      operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&,
+		 const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&);
+    };
+
+  /**
+   *  @brief A standard container composed of equivalent keys
+   *  (possibly containing multiple of each key value) that associates
+   *  values of another type with the keys.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  @tparam  _Key    Type of key objects.
+   *  @tparam  _Tp     Type of mapped objects.
+   *  @tparam  _Hash   Hashing function object type, defaults to hash<_Value>.
+   *  @tparam  _Pred   Predicate function object type, defaults
+   *                   to equal_to<_Value>.
+   *  @tparam  _Alloc  Allocator type, defaults to
+   *                   std::allocator<std::pair<const _Key, _Tp>>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   * The resulting value type of the container is std::pair<const _Key, _Tp>.
+   *
+   *  Base is _Hashtable, dispatched at compile time via template
+   *  alias __ummap_hashtable.
+   */
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_multimap
+    {
+      typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc>  _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+      // typedefs:
+      //@{
+      /// Public typedefs.
+      typedef typename _Hashtable::key_type	key_type;
+      typedef typename _Hashtable::value_type	value_type;
+      typedef typename _Hashtable::mapped_type	mapped_type;
+      typedef typename _Hashtable::hasher	hasher;
+      typedef typename _Hashtable::key_equal	key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+      //@}
+
+      //@{
+      ///  Iterator-related typedefs.
+      typedef typename _Hashtable::pointer		pointer;
+      typedef typename _Hashtable::const_pointer	const_pointer;
+      typedef typename _Hashtable::reference		reference;
+      typedef typename _Hashtable::const_reference	const_reference;
+      typedef typename _Hashtable::iterator		iterator;
+      typedef typename _Hashtable::const_iterator	const_iterator;
+      typedef typename _Hashtable::local_iterator	local_iterator;
+      typedef typename _Hashtable::const_local_iterator	const_local_iterator;
+      typedef typename _Hashtable::size_type		size_type;
+      typedef typename _Hashtable::difference_type	difference_type;
+      //@}
+
+      //construct/destroy/copy
+
+      /**
+       *  @brief  Default constructor creates no elements.
+       *  @param __n  Initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       */
+      explicit
+      unordered_multimap(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+
+      /**
+       *  @brief  Builds an %unordered_multimap from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       *
+       *  Create an %unordered_multimap consisting of copies of the elements
+       *  from [__first,__last).  This is linear in N (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __f, _InputIterator __l,
+			   size_type __n = 0,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+	: _M_h(__f, __l, __n, __hf, __eql, __a)
+	{ }
+
+      /// Copy constructor.
+      unordered_multimap(const unordered_multimap&) = default;
+
+      /// Move constructor.
+      unordered_multimap(unordered_multimap&&) = default;
+
+      /**
+       *  @brief Creates an %unordered_multimap with no elements.
+       *  @param __a An allocator object.
+       */
+      explicit
+      unordered_multimap(const allocator_type& __a)
+	: _M_h(__a)
+      { }
+
+      /*
+       *  @brief Copy constructor with allocator argument.
+       * @param  __uset  Input %unordered_multimap to copy.
+       * @param  __a  An allocator object.
+       */
+      unordered_multimap(const unordered_multimap& __ummap,
+			 const allocator_type& __a)
+	: _M_h(__ummap._M_h, __a)
+      { }
+
+      /*
+       *  @brief  Move constructor with allocator argument.
+       *  @param  __uset Input %unordered_multimap to move.
+       *  @param  __a    An allocator object.
+       */
+      unordered_multimap(unordered_multimap&& __ummap,
+			 const allocator_type& __a)
+	: _M_h(std::move(__ummap._M_h), __a)
+      { }
+
+      /**
+       *  @brief  Builds an %unordered_multimap from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create an %unordered_multimap consisting of copies of the elements in
+       *  the list. This is linear in N (where N is @a __l.size()).
+       */
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n = 0,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+	: _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      /// Copy assignment operator.
+      unordered_multimap&
+      operator=(const unordered_multimap&) = default;
+
+      /// Move assignment operator.
+      unordered_multimap&
+      operator=(unordered_multimap&&) = default;
+
+      /**
+       *  @brief  %Unordered_multimap list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills an %unordered_multimap with copies of the elements
+       *  in the initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %unordered_multimap
+       *  and that the resulting %unordered_multimap's size is the same as the
+       *  number of elements assigned.  Old data may be lost.
+       */
+      unordered_multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_h = __l;
+	return *this;
+      }
+
+      ///  Returns the allocator object with which the %unordered_multimap was
+      ///  constructed.
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+      // size and capacity:
+
+      ///  Returns true if the %unordered_multimap is empty.
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+      ///  Returns the size of the %unordered_multimap.
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+      ///  Returns the maximum size of the %unordered_multimap.
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+      // iterators.
+
+      /**
+       *  Returns a read/write iterator that points to the first element in the
+       *  %unordered_multimap.
+       */
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %unordered_multimap.
+       */
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+      //@}
+
+      /**
+       *  Returns a read/write iterator that points one past the last element in
+       *  the %unordered_multimap.
+       */
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %unordered_multimap.
+       */
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+      //@}
+
+      // modifiers.
+
+      /**
+       *  @brief Attempts to build and insert a std::pair into the
+       *  %unordered_multimap.
+       *
+       *  @param __args  Arguments used to generate a new pair instance (see
+       *	        std::piecewise_contruct for passing arguments to each
+       *	        part of the pair constructor).
+       *
+       *  @return  An iterator that points to the inserted pair.
+       *
+       *  This function attempts to build and insert a (key, value) %pair into
+       *  the %unordered_multimap.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{ return _M_h.emplace(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Attempts to build and insert a std::pair into the %unordered_multimap.
+       *
+       *  @param  __pos  An iterator that serves as a hint as to where the pair
+       *                should be inserted.
+       *  @param  __args  Arguments used to generate a new pair instance (see
+       *	         std::piecewise_contruct for passing arguments to each
+       *	         part of the pair constructor).
+       *  @return An iterator that points to the element with key of the
+       *          std::pair built from @a __args.
+       *
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process. A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  See
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{ return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+
+      //@{
+      /**
+       *  @brief Inserts a std::pair into the %unordered_multimap.
+       *  @param __x Pair to be inserted (see std::make_pair for easy
+       *	     creation of pairs).
+       *
+       *  @return  An iterator that points to the inserted pair.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      iterator
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	iterator
+	insert(_Pair&& __x)
+        { return _M_h.insert(std::forward<_Pair>(__x)); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Inserts a std::pair into the %unordered_multimap.
+       *  @param  __hint  An iterator that serves as a hint as to where the
+       *                 pair should be inserted.
+       *  @param  __x  Pair to be inserted (see std::make_pair for easy creation
+       *               of pairs).
+       *  @return An iterator that points to the element with key of
+       *           @a __x (may or may not be the %pair passed in).
+       *
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  See
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *  for more on @a hinting.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	iterator
+	insert(const_iterator __hint, _Pair&& __x)
+        { return _M_h.insert(__hint, std::forward<_Pair>(__x)); }
+      //@}
+
+      /**
+       *  @brief A template function that attempts to insert a range of
+       *  elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{ _M_h.insert(__first, __last); }
+
+      /**
+       *  @brief Attempts to insert a list of elements into the
+       *  %unordered_multimap.
+       *  @param  __l  A std::initializer_list<value_type> of elements
+       *               to be inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+
+      //@{
+      /**
+       *  @brief Erases an element from an %unordered_multimap.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a __position prior to the element being erased. If no such
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from an %unordered_multimap.
+       *  Note that this function only erases the element, and that if the
+       *  element is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+      // LWG 2059.
+      iterator
+      erase(iterator __it)
+      { return _M_h.erase(__it); }
+      //@}
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of elements to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all the elements located by the given key from
+       *  an %unordered_multimap.
+       *  Note that this function only erases the element, and that if the
+       *  element is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+
+      /**
+       *  @brief Erases a [__first,__last) range of elements from an
+       *  %unordered_multimap.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                  erased.
+       *  @param __last  Iterator pointing to the end of the range to
+       *                be erased.
+       *  @return The iterator @a __last.
+       *
+       *  This function erases a sequence of elements from an
+       *  %unordered_multimap.
+       *  Note that this function only erases the elements, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+      /**
+       *  Erases all elements in an %unordered_multimap.
+       *  Note that this function only erases the elements, and that if the
+       *  elements themselves are pointers, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+
+      /**
+       *  @brief  Swaps data with another %unordered_multimap.
+       *  @param  __x  An %unordered_multimap of the same element and allocator
+       *  types.
+       *
+       *  This exchanges the elements between two %unordered_multimap in
+       *  constant time.
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(m1,m2) will feed to this function.
+       */
+      void
+      swap(unordered_multimap& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+
+      // observers.
+
+      ///  Returns the hash functor object with which the %unordered_multimap
+      ///  was constructed.
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+      ///  Returns the key comparison object with which the %unordered_multimap
+      ///  was constructed.
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+
+      // lookup.
+
+      //@{
+      /**
+       *  @brief Tries to locate an element in an %unordered_multimap.
+       *  @param  __x  Key to be located.
+       *  @return  Iterator pointing to sought-after element, or end() if not
+       *           found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after element.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+      //@}
+
+      /**
+       *  @brief  Finds the number of elements.
+       *  @param  __x  Key to count.
+       *  @return  Number of elements with specified key.
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+
+      //@{
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+      //@}
+
+      // bucket interface.
+
+      /// Returns the number of buckets of the %unordered_multimap.
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+      /// Returns the maximum number of buckets of the %unordered_multimap.
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+      /*
+       * @brief  Returns the number of elements in a given bucket.
+       * @param  __n  A bucket index.
+       * @return  The number of elements in the bucket.
+       */
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+      /*
+       * @brief  Returns the bucket index of a given element.
+       * @param  __key  A key instance.
+       * @return  The key bucket index.
+       */
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+      
+      /**
+       *  @brief  Returns a read/write iterator pointing to the first bucket
+       *         element.
+       *  @param  __n The bucket index.
+       *  @return  A read/write local iterator.
+       */
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to the first
+       *         bucket element.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+      //@}
+
+      /**
+       *  @brief  Returns a read/write iterator pointing to one past the last
+       *         bucket elements.
+       *  @param  __n The bucket index.
+       *  @return  A read/write local iterator.
+       */
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to one past
+       *         the last bucket elements.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+      //@}
+
+      // hash policy.
+
+      /// Returns the average number of elements per bucket.
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+      /// Returns a positive number that the %unordered_multimap tries to keep
+      /// the load factor less than or equal to.
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+      /**
+       *  @brief  Change the %unordered_multimap maximum load factor.
+       *  @param  __z The new maximum load factor.
+       */
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+
+      /**
+       *  @brief  May rehash the %unordered_multimap.
+       *  @param  __n The new number of buckets.
+       *
+       *  Rehash will occur only if the new number of buckets respect the
+       *  %unordered_multimap maximum load factor.
+       */
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+
+      /**
+       *  @brief  Prepare the %unordered_multimap for a specified number of
+       *          elements.
+       *  @param  __n Number of elements required.
+       *
+       *  Same as rehash(ceil(n / max_load_factor())).
+       */
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+	       typename _Alloc1>
+        friend bool
+	operator==(const unordered_multimap<_Key1, _Tp1,
+					    _Hash1, _Pred1, _Alloc1>&,
+		   const unordered_multimap<_Key1, _Tp1,
+					    _Hash1, _Pred1, _Alloc1>&);
+    };
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _UNORDERED_MAP_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/unordered_set.h b/gcc-4.9/libstdc++-v3/include/bits/unordered_set.h
new file mode 100644
index 0000000..e810f97
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/unordered_set.h
@@ -0,0 +1,1356 @@
+// unordered_set implementation -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/unordered_set.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{unordered_set}
+ */
+
+#ifndef _UNORDERED_SET_H
+#define _UNORDERED_SET_H
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /// Base types for unordered_set.
+  template<bool _Cache>
+    using __uset_traits = __detail::_Hashtable_traits<_Cache, true, true>;
+
+  template<typename _Value,
+	   typename _Hash = hash<_Value>,
+	   typename _Pred = std::equal_to<_Value>,
+  	   typename _Alloc = std::allocator<_Value>,
+	   typename _Tr = __uset_traits<__cache_default<_Value, _Hash>::value>>
+    using __uset_hashtable = _Hashtable<_Value, _Value, _Alloc,
+					__detail::_Identity, _Pred, _Hash,
+					__detail::_Mod_range_hashing,
+					__detail::_Default_ranged_hash,
+					__detail::_Prime_rehash_policy, _Tr>;
+
+  /// Base types for unordered_multiset.
+  template<bool _Cache>
+    using __umset_traits = __detail::_Hashtable_traits<_Cache, true, false>;
+
+  template<typename _Value,
+	   typename _Hash = hash<_Value>,
+	   typename _Pred = std::equal_to<_Value>,
+	   typename _Alloc = std::allocator<_Value>,
+	   typename _Tr = __umset_traits<__cache_default<_Value, _Hash>::value>>
+    using __umset_hashtable = _Hashtable<_Value, _Value, _Alloc,
+					 __detail::_Identity,
+					 _Pred, _Hash,
+					 __detail::_Mod_range_hashing,
+					 __detail::_Default_ranged_hash,
+					 __detail::_Prime_rehash_policy, _Tr>;
+
+  /**
+   *  @brief A standard container composed of unique keys (containing
+   *  at most one of each key value) in which the elements' keys are
+   *  the elements themselves.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  @tparam  _Value  Type of key objects.
+   *  @tparam  _Hash  Hashing function object type, defaults to hash<_Value>.
+
+   *  @tparam _Pred Predicate function object type, defaults to
+   *                equal_to<_Value>.
+   *
+   *  @tparam  _Alloc  Allocator type, defaults to allocator<_Key>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   *  Base is _Hashtable, dispatched at compile time via template
+   *  alias __uset_hashtable.
+   */
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value> >
+    class unordered_set
+    {
+      typedef __uset_hashtable<_Value, _Hash, _Pred, _Alloc>  _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+      // typedefs:
+      //@{
+      /// Public typedefs.
+      typedef typename _Hashtable::key_type	key_type;
+      typedef typename _Hashtable::value_type	value_type;
+      typedef typename _Hashtable::hasher	hasher;
+      typedef typename _Hashtable::key_equal	key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+      //@}
+
+      //@{
+      ///  Iterator-related typedefs.
+      typedef typename _Hashtable::pointer		pointer;
+      typedef typename _Hashtable::const_pointer	const_pointer;
+      typedef typename _Hashtable::reference		reference;
+      typedef typename _Hashtable::const_reference	const_reference;
+      typedef typename _Hashtable::iterator		iterator;
+      typedef typename _Hashtable::const_iterator	const_iterator;
+      typedef typename _Hashtable::local_iterator	local_iterator;
+      typedef typename _Hashtable::const_local_iterator	const_local_iterator;
+      typedef typename _Hashtable::size_type		size_type;
+      typedef typename _Hashtable::difference_type	difference_type;
+      //@}
+
+      // construct/destroy/copy
+      /**
+       *  @brief  Default constructor creates no elements.
+       *  @param __n  Initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       */
+      explicit
+      unordered_set(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+
+      /**
+       *  @brief  Builds an %unordered_set from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       *
+       *  Create an %unordered_set consisting of copies of the elements from
+       *  [__first,__last).  This is linear in N (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __f, _InputIterator __l,
+		      size_type __n = 0,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+	: _M_h(__f, __l, __n, __hf, __eql, __a)
+	{ }
+
+      /// Copy constructor.
+      unordered_set(const unordered_set&) = default;
+
+      /// Move constructor.
+      unordered_set(unordered_set&&) = default;
+
+      /**
+       *  @brief Creates an %unordered_set with no elements.
+       *  @param __a An allocator object.
+       */
+      explicit
+      unordered_set(const allocator_type& __a)
+	: _M_h(__a)
+      { }
+
+      /*
+       *  @brief Copy constructor with allocator argument.
+       * @param  __uset  Input %unordered_set to copy.
+       * @param  __a  An allocator object.
+       */
+      unordered_set(const unordered_set& __uset,
+		    const allocator_type& __a)
+	: _M_h(__uset._M_h, __a)
+      { }
+
+      /*
+       *  @brief  Move constructor with allocator argument.
+       *  @param  __uset Input %unordered_set to move.
+       *  @param  __a    An allocator object.
+       */
+      unordered_set(unordered_set&& __uset,
+		    const allocator_type& __a)
+	: _M_h(std::move(__uset._M_h), __a)
+      { }
+
+      /**
+       *  @brief  Builds an %unordered_set from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create an %unordered_set consisting of copies of the elements in the
+       *  list. This is linear in N (where N is @a __l.size()).
+       */
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n = 0,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+	: _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      /// Copy assignment operator.
+      unordered_set&
+      operator=(const unordered_set&) = default;
+
+      /// Move assignment operator.
+      unordered_set&
+      operator=(unordered_set&&) = default;
+
+      /**
+       *  @brief  %Unordered_set list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills an %unordered_set with copies of the elements in
+       *  the initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %unordered_set and
+       *  that the resulting %unordered_set's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      unordered_set&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_h = __l;
+	return *this;
+      }
+
+      ///  Returns the allocator object with which the %unordered_set was
+      ///  constructed.
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+      // size and capacity:
+
+      ///  Returns true if the %unordered_set is empty.
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+      ///  Returns the size of the %unordered_set.
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+      ///  Returns the maximum size of the %unordered_set.
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+      // iterators.
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %unordered_set.
+       */
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+      //@}
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %unordered_set.
+       */
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+      //@}
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %unordered_set.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %unordered_set.
+       */
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+
+      // modifiers.
+
+      /**
+       *  @brief Attempts to build and insert an element into the
+       *  %unordered_set.
+       *  @param __args  Arguments used to generate an element.
+       *  @return  A pair, of which the first element is an iterator that points
+       *           to the possibly inserted element, and the second is a bool
+       *           that is true if the element was actually inserted.
+       *
+       *  This function attempts to build and insert an element into the
+       *  %unordered_set. An %unordered_set relies on unique keys and thus an
+       *  element is only inserted if it is not already present in the
+       *  %unordered_set.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{ return _M_h.emplace(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Attempts to insert an element into the %unordered_set.
+       *  @param  __pos  An iterator that serves as a hint as to where the
+       *                element should be inserted.
+       *  @param  __args  Arguments used to generate the element to be
+       *                 inserted.
+       *  @return An iterator that points to the element with key equivalent to
+       *          the one generated from @a __args (may or may not be the
+       *          element itself).
+       *
+       *  This function is not concerned about whether the insertion took place,
+       *  and thus does not return a boolean like the single-argument emplace()
+       *  does.  Note that the first parameter is only a hint and can
+       *  potentially improve the performance of the insertion process.  A bad
+       *  hint would cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{ return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+
+      //@{
+      /**
+       *  @brief Attempts to insert an element into the %unordered_set.
+       *  @param  __x  Element to be inserted.
+       *  @return  A pair, of which the first element is an iterator that points
+       *           to the possibly inserted element, and the second is a bool
+       *           that is true if the element was actually inserted.
+       *
+       *  This function attempts to insert an element into the %unordered_set.
+       *  An %unordered_set relies on unique keys and thus an element is only
+       *  inserted if it is not already present in the %unordered_set.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Attempts to insert an element into the %unordered_set.
+       *  @param  __hint  An iterator that serves as a hint as to where the
+       *                 element should be inserted.
+       *  @param  __x  Element to be inserted.
+       *  @return An iterator that points to the element with key of
+       *           @a __x (may or may not be the element passed in).
+       *
+       *  This function is not concerned about whether the insertion took place,
+       *  and thus does not return a boolean like the single-argument insert()
+       *  does.  Note that the first parameter is only a hint and can
+       *  potentially improve the performance of the insertion process.  A bad
+       *  hint would cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires amortized constant.
+       */
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+      //@}
+
+      /**
+       *  @brief A template function that attempts to insert a range of
+       *  elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{ _M_h.insert(__first, __last); }
+
+      /**
+       *  @brief Attempts to insert a list of elements into the %unordered_set.
+       *  @param  __l  A std::initializer_list<value_type> of elements
+       *               to be inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+
+      //@{
+      /**
+       *  @brief Erases an element from an %unordered_set.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a __position prior to the element being erased. If no such
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from an %unordered_set.  Note that this function only erases the
+       *  element, and that if the element is itself a pointer, the pointed-to
+       *  memory is not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+      // LWG 2059.
+      iterator
+      erase(iterator __it)
+      { return _M_h.erase(__it); }
+      //@}
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of element to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all the elements located by the given key from
+       *  an %unordered_set. For an %unordered_set the result of this function
+       *  can only be 0 (not present) or 1 (present).
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+
+      /**
+       *  @brief Erases a [__first,__last) range of elements from an
+       *  %unordered_set.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                  erased.
+       *  @param __last  Iterator pointing to the end of the range to
+       *                be erased.
+       *  @return The iterator @a __last.
+       *
+       *  This function erases a sequence of elements from an %unordered_set.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+      /**
+       *  Erases all elements in an %unordered_set. Note that this function only
+       *  erases the elements, and that if the elements themselves are pointers,
+       *  the pointed-to memory is not touched in any way. Managing the pointer
+       *  is the user's responsibility.
+       */
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+
+      /**
+       *  @brief  Swaps data with another %unordered_set.
+       *  @param  __x  An %unordered_set of the same element and allocator
+       *  types.
+       *
+       *  This exchanges the elements between two sets in constant time.
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(s1,s2) will feed to this function.
+       */
+      void
+      swap(unordered_set& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+
+      // observers.
+
+      ///  Returns the hash functor object with which the %unordered_set was
+      ///  constructed.
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+      ///  Returns the key comparison object with which the %unordered_set was
+      ///  constructed.
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+
+      // lookup.
+
+      //@{
+      /**
+       *  @brief Tries to locate an element in an %unordered_set.
+       *  @param  __x  Element to be located.
+       *  @return  Iterator pointing to sought-after element, or end() if not
+       *           found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after element.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+      //@}
+
+      /**
+       *  @brief  Finds the number of elements.
+       *  @param  __x  Element to located.
+       *  @return  Number of elements with specified key.
+       *
+       *  This function only makes sense for unordered_multisets; for
+       *  unordered_set the result will either be 0 (not present) or 1
+       *  (present).
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+
+      //@{
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       *
+       *  This function probably only makes sense for multisets.
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+      //@}
+
+      // bucket interface.
+
+      /// Returns the number of buckets of the %unordered_set.
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+      /// Returns the maximum number of buckets of the %unordered_set.
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+      /*
+       * @brief  Returns the number of elements in a given bucket.
+       * @param  __n  A bucket index.
+       * @return  The number of elements in the bucket.
+       */
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+      /*
+       * @brief  Returns the bucket index of a given element.
+       * @param  __key  A key instance.
+       * @return  The key bucket index.
+       */
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to the first
+       *         bucket element.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+      //@}
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to one past
+       *         the last bucket elements.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+      //@}
+
+      // hash policy.
+
+      /// Returns the average number of elements per bucket.
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+      /// Returns a positive number that the %unordered_set tries to keep the
+      /// load factor less than or equal to.
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+      /**
+       *  @brief  Change the %unordered_set maximum load factor.
+       *  @param  __z The new maximum load factor.
+       */
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+
+      /**
+       *  @brief  May rehash the %unordered_set.
+       *  @param  __n The new number of buckets.
+       *
+       *  Rehash will occur only if the new number of buckets respect the
+       *  %unordered_set maximum load factor.
+       */
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+
+      /**
+       *  @brief  Prepare the %unordered_set for a specified number of
+       *          elements.
+       *  @param  __n Number of elements required.
+       *
+       *  Same as rehash(ceil(n / max_load_factor())).
+       */
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Value1, typename _Hash1, typename _Pred1,
+	       typename _Alloc1>
+        friend bool
+      operator==(const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&,
+		 const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&);
+    };
+
+  /**
+   *  @brief A standard container composed of equivalent keys
+   *  (possibly containing multiple of each key value) in which the
+   *  elements' keys are the elements themselves.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  @tparam  _Value  Type of key objects.
+   *  @tparam  _Hash  Hashing function object type, defaults to hash<_Value>.
+   *  @tparam  _Pred  Predicate function object type, defaults
+   *                  to equal_to<_Value>.
+   *  @tparam  _Alloc  Allocator type, defaults to allocator<_Key>.
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   *  Base is _Hashtable, dispatched at compile time via template
+   *  alias __umset_hashtable.
+   */
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value> >
+    class unordered_multiset
+    {
+      typedef __umset_hashtable<_Value, _Hash, _Pred, _Alloc>  _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+      // typedefs:
+      //@{
+      /// Public typedefs.
+      typedef typename _Hashtable::key_type	key_type;
+      typedef typename _Hashtable::value_type	value_type;
+      typedef typename _Hashtable::hasher	hasher;
+      typedef typename _Hashtable::key_equal	key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+      //@}
+
+      //@{
+      ///  Iterator-related typedefs.
+      typedef typename _Hashtable::pointer		pointer;
+      typedef typename _Hashtable::const_pointer	const_pointer;
+      typedef typename _Hashtable::reference		reference;
+      typedef typename _Hashtable::const_reference	const_reference;
+      typedef typename _Hashtable::iterator		iterator;
+      typedef typename _Hashtable::const_iterator	const_iterator;
+      typedef typename _Hashtable::local_iterator	local_iterator;
+      typedef typename _Hashtable::const_local_iterator	const_local_iterator;
+      typedef typename _Hashtable::size_type		size_type;
+      typedef typename _Hashtable::difference_type	difference_type;
+      //@}
+
+      // construct/destroy/copy
+      /**
+       *  @brief  Default constructor creates no elements.
+       *  @param __n  Initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       */
+      explicit
+      unordered_multiset(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+
+      /**
+       *  @brief  Builds an %unordered_multiset from a range.
+       *  @param  __first  An input iterator.
+       *  @param  __last  An input iterator.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param __a  An allocator object.
+       *
+       *  Create an %unordered_multiset consisting of copies of the elements
+       *  from [__first,__last).  This is linear in N (where N is
+       *  distance(__first,__last)).
+       */
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __f, _InputIterator __l,
+			   size_type __n = 0,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+	: _M_h(__f, __l, __n, __hf, __eql, __a)
+	{ }
+
+      /// Copy constructor.
+      unordered_multiset(const unordered_multiset&) = default;
+
+      /// Move constructor.
+      unordered_multiset(unordered_multiset&&) = default;
+
+      /**
+       *  @brief  Builds an %unordered_multiset from an initializer_list.
+       *  @param  __l  An initializer_list.
+       *  @param __n  Minimal initial number of buckets.
+       *  @param __hf  A hash functor.
+       *  @param __eql  A key equality functor.
+       *  @param  __a  An allocator object.
+       *
+       *  Create an %unordered_multiset consisting of copies of the elements in
+       *  the list. This is linear in N (where N is @a __l.size()).
+       */
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n = 0,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+	: _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      /// Copy assignment operator.
+      unordered_multiset&
+      operator=(const unordered_multiset&) = default;
+
+      /// Move assignment operator.
+      unordered_multiset&
+      operator=(unordered_multiset&&) = default;
+
+      /**
+       *  @brief Creates an %unordered_multiset with no elements.
+       *  @param __a An allocator object.
+       */
+      explicit
+      unordered_multiset(const allocator_type& __a)
+	: _M_h(__a)
+      { }
+
+      /*
+       *  @brief Copy constructor with allocator argument.
+       * @param  __uset  Input %unordered_multiset to copy.
+       * @param  __a  An allocator object.
+       */
+      unordered_multiset(const unordered_multiset& __umset,
+			 const allocator_type& __a)
+	: _M_h(__umset._M_h, __a)
+      { }
+
+      /*
+       *  @brief  Move constructor with allocator argument.
+       *  @param  __umset  Input %unordered_multiset to move.
+       *  @param  __a  An allocator object.
+       */
+      unordered_multiset(unordered_multiset&& __umset,
+			 const allocator_type& __a)
+	: _M_h(std::move(__umset._M_h), __a)
+      { }
+
+      /**
+       *  @brief  %Unordered_multiset list assignment operator.
+       *  @param  __l  An initializer_list.
+       *
+       *  This function fills an %unordered_multiset with copies of the elements
+       *  in the initializer list @a __l.
+       *
+       *  Note that the assignment completely changes the %unordered_multiset
+       *  and that the resulting %unordered_set's size is the same as the number
+       *  of elements assigned.  Old data may be lost.
+       */
+      unordered_multiset&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_h = __l;
+	return *this;
+      }
+
+      ///  Returns the allocator object with which the %unordered_multiset was
+      ///  constructed.
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+      // size and capacity:
+
+      ///  Returns true if the %unordered_multiset is empty.
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+      ///  Returns the size of the %unordered_multiset.
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+      ///  Returns the maximum size of the %unordered_multiset.
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+      // iterators.
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %unordered_multiset.
+       */
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+      //@}
+
+      //@{
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %unordered_multiset.
+       */
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+      //@}
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  element in the %unordered_multiset.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the last
+       *  element in the %unordered_multiset.
+       */
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+
+      // modifiers.
+
+      /**
+       *  @brief Builds and insert an element into the %unordered_multiset.
+       *  @param __args  Arguments used to generate an element.
+       *  @return  An iterator that points to the inserted element.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{ return _M_h.emplace(std::forward<_Args>(__args)...); }
+
+      /**
+       *  @brief Inserts an element into the %unordered_multiset.
+       *  @param  __pos  An iterator that serves as a hint as to where the
+       *                element should be inserted.
+       *  @param  __args  Arguments used to generate the element to be
+       *                 inserted.
+       *  @return An iterator that points to the inserted element.
+       *
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires amortized constant time.
+       */
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{ return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+
+      //@{
+      /**
+       *  @brief Inserts an element into the %unordered_multiset.
+       *  @param  __x  Element to be inserted.
+       *  @return  An iterator that points to the inserted element.
+       *
+       *  Insertion requires amortized constant time.
+       */
+      iterator
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+      iterator
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+      //@}
+
+      //@{
+      /**
+       *  @brief Inserts an element into the %unordered_multiset.
+       *  @param  __hint  An iterator that serves as a hint as to where the
+       *                 element should be inserted.
+       *  @param  __x  Element to be inserted.
+       *  @return An iterator that points to the inserted element.
+       *
+       *  Note that the first parameter is only a hint and can potentially
+       *  improve the performance of the insertion process.  A bad hint would
+       *  cause no gains in efficiency.
+       *
+       *  For more on @a hinting, see:
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
+       *
+       *  Insertion requires amortized constant.
+       */
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+      //@}
+
+      /**
+       *  @brief A template function that inserts a range of elements.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                   inserted.
+       *  @param  __last  Iterator pointing to the end of the range.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{ _M_h.insert(__first, __last); }
+
+      /**
+       *  @brief Inserts a list of elements into the %unordered_multiset.
+       *  @param  __l  A std::initializer_list<value_type> of elements to be
+       *              inserted.
+       *
+       *  Complexity similar to that of the range constructor.
+       */
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+
+      //@{
+      /**
+       *  @brief Erases an element from an %unordered_multiset.
+       *  @param  __position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a __position prior to the element being erased. If no such
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from an %unordered_multiset.
+       *
+       *  Note that this function only erases the element, and that if the
+       *  element is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+      // LWG 2059.
+      iterator
+      erase(iterator __it)
+      { return _M_h.erase(__it); }
+      //@}
+
+
+      /**
+       *  @brief Erases elements according to the provided key.
+       *  @param  __x  Key of element to be erased.
+       *  @return  The number of elements erased.
+       *
+       *  This function erases all the elements located by the given key from
+       *  an %unordered_multiset.
+       *
+       *  Note that this function only erases the element, and that if the
+       *  element is itself a pointer, the pointed-to memory is not touched in
+       *  any way.  Managing the pointer is the user's responsibility.
+       */
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+
+      /**
+       *  @brief Erases a [__first,__last) range of elements from an
+       *  %unordered_multiset.
+       *  @param  __first  Iterator pointing to the start of the range to be
+       *                  erased.
+       *  @param __last  Iterator pointing to the end of the range to
+       *                be erased.
+       *  @return The iterator @a __last.
+       *
+       *  This function erases a sequence of elements from an
+       *  %unordered_multiset.
+       *
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+      /**
+       *  Erases all elements in an %unordered_multiset.
+       *
+       *  Note that this function only erases the elements, and that if the
+       *  elements themselves are pointers, the pointed-to memory is not touched
+       *  in any way. Managing the pointer is the user's responsibility.
+       */
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+
+      /**
+       *  @brief  Swaps data with another %unordered_multiset.
+       *  @param  __x  An %unordered_multiset of the same element and allocator
+       *  types.
+       *
+       *  This exchanges the elements between two sets in constant time.
+       *  Note that the global std::swap() function is specialized such that
+       *  std::swap(s1,s2) will feed to this function.
+       */
+      void
+      swap(unordered_multiset& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+
+      // observers.
+
+      ///  Returns the hash functor object with which the %unordered_multiset
+      ///  was constructed.
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+      ///  Returns the key comparison object with which the %unordered_multiset
+      ///  was constructed.
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+
+      // lookup.
+
+      //@{
+      /**
+       *  @brief Tries to locate an element in an %unordered_multiset.
+       *  @param  __x  Element to be located.
+       *  @return  Iterator pointing to sought-after element, or end() if not
+       *           found.
+       *
+       *  This function takes a key and tries to locate the element with which
+       *  the key matches.  If successful the function returns an iterator
+       *  pointing to the sought after element.  If unsuccessful it returns the
+       *  past-the-end ( @c end() ) iterator.
+       */
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+      //@}
+
+      /**
+       *  @brief  Finds the number of elements.
+       *  @param  __x  Element to located.
+       *  @return  Number of elements with specified key.
+       */
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+
+      //@{
+      /**
+       *  @brief Finds a subsequence matching given key.
+       *  @param  __x  Key to be located.
+       *  @return  Pair of iterators that possibly points to the subsequence
+       *           matching given key.
+       */
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+      //@}
+
+      // bucket interface.
+
+      /// Returns the number of buckets of the %unordered_multiset.
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+      /// Returns the maximum number of buckets of the %unordered_multiset.
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+      /*
+       * @brief  Returns the number of elements in a given bucket.
+       * @param  __n  A bucket index.
+       * @return  The number of elements in the bucket.
+       */
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+      /*
+       * @brief  Returns the bucket index of a given element.
+       * @param  __key  A key instance.
+       * @return  The key bucket index.
+       */
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to the first
+       *         bucket element.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+      //@}
+
+      //@{
+      /**
+       *  @brief  Returns a read-only (constant) iterator pointing to one past
+       *         the last bucket elements.
+       *  @param  __n The bucket index.
+       *  @return  A read-only local iterator.
+       */
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+      //@}
+
+      // hash policy.
+
+      /// Returns the average number of elements per bucket.
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+      /// Returns a positive number that the %unordered_multiset tries to keep the
+      /// load factor less than or equal to.
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+      /**
+       *  @brief  Change the %unordered_multiset maximum load factor.
+       *  @param  __z The new maximum load factor.
+       */
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+
+      /**
+       *  @brief  May rehash the %unordered_multiset.
+       *  @param  __n The new number of buckets.
+       *
+       *  Rehash will occur only if the new number of buckets respect the
+       *  %unordered_multiset maximum load factor.
+       */
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+
+      /**
+       *  @brief  Prepare the %unordered_multiset for a specified number of
+       *          elements.
+       *  @param  __n Number of elements required.
+       *
+       *  Same as rehash(ceil(n / max_load_factor())).
+       */
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Value1, typename _Hash1, typename _Pred1,
+	       typename _Alloc1>
+        friend bool
+      operator==(const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&,
+		 const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&);
+    };
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+	 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#endif /* _UNORDERED_SET_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/uses_allocator.h b/gcc-4.9/libstdc++-v3/include/bits/uses_allocator.h
new file mode 100644
index 0000000..10131c0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/uses_allocator.h
@@ -0,0 +1,109 @@
+// Uses-allocator Construction -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef _USES_ALLOCATOR_H
+#define _USES_ALLOCATOR_H 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <type_traits>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// [allocator.tag]
+  struct allocator_arg_t { };
+
+  constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+
+_GLIBCXX_HAS_NESTED_TYPE(allocator_type)
+
+  template<typename _Tp, typename _Alloc,
+	   bool = __has_allocator_type<_Tp>::value>
+    struct __uses_allocator_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Alloc>
+    struct __uses_allocator_helper<_Tp, _Alloc, true>
+    : public integral_constant<bool, is_convertible<_Alloc,
+				     typename _Tp::allocator_type>::value>
+    { };
+
+  /// [allocator.uses.trait]
+  template<typename _Tp, typename _Alloc>
+    struct uses_allocator
+    : public integral_constant<bool,
+			       __uses_allocator_helper<_Tp, _Alloc>::value>
+    { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_allocator_arg
+    : is_constructible<_Tp, _Alloc, _Args...>
+    { static_assert( uses_allocator<_Tp, _Alloc>::value, "uses allocator" ); };
+
+  struct __uses_alloc_base { };
+  struct __uses_alloc0 : __uses_alloc_base
+  { struct _Anything { _Anything(...) { } } _M_a; };
+  template<typename _Alloc>
+    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
+  template<typename _Alloc>
+    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
+
+  template<bool, typename _Alloc, typename... _Args>
+    struct __uses_alloc;
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
+    : conditional<
+        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
+        __uses_alloc1<_Alloc>,
+       	__uses_alloc2<_Alloc>>::type
+    { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
+    : __uses_alloc0 { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc_impl
+    : __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp,  _Alloc, _Args...>
+    { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    __uses_alloc_impl<_Tp, _Alloc, _Args...>
+    __use_alloc(const _Alloc& __a)
+    {
+      __uses_alloc_impl<_Tp, _Alloc, _Args...> __ret;
+      __ret._M_a = &__a;
+      return __ret;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/bits/valarray_after.h b/gcc-4.9/libstdc++-v3/include/bits/valarray_after.h
new file mode 100644
index 0000000..2391dc5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/valarray_after.h
@@ -0,0 +1,551 @@
+// The template and inlines for the -*- C++ -*- internal _Meta class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/valarray_after.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
+
+#ifndef _VALARRAY_AFTER_H
+#define _VALARRAY_AFTER_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  //
+  // gslice_array closure.
+  //
+  template<class _Dom>
+    class _GBase
+    {
+    public:
+      typedef typename _Dom::value_type value_type;
+      
+      _GBase (const _Dom& __e, const valarray<size_t>& __i)
+      : _M_expr (__e), _M_index(__i) {}
+      
+      value_type
+      operator[] (size_t __i) const
+      { return _M_expr[_M_index[__i]]; }
+      
+      size_t
+      size () const
+      { return _M_index.size(); }
+
+    private:
+      const _Dom&	      _M_expr;
+      const valarray<size_t>& _M_index;
+    };
+
+  template<typename _Tp>
+    class _GBase<_Array<_Tp> >
+    {
+    public:
+      typedef _Tp value_type;
+      
+      _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
+      : _M_array (__a), _M_index(__i) {}
+      
+      value_type
+      operator[] (size_t __i) const
+      { return _M_array._M_data[_M_index[__i]]; }
+      
+      size_t
+      size () const
+      { return _M_index.size(); }
+
+    private:
+      const _Array<_Tp>       _M_array;
+      const valarray<size_t>& _M_index;
+    };
+
+  template<class _Dom>
+    struct _GClos<_Expr, _Dom>
+    : _GBase<_Dom>
+    {
+      typedef _GBase<_Dom> _Base;
+      typedef typename _Base::value_type value_type;
+      
+      _GClos (const _Dom& __e, const valarray<size_t>& __i)
+      : _Base (__e, __i) {}
+    };
+
+  template<typename _Tp>
+    struct _GClos<_ValArray, _Tp>
+    : _GBase<_Array<_Tp> >
+    {
+      typedef _GBase<_Array<_Tp> > _Base;
+      typedef typename _Base::value_type value_type;
+      
+      _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
+      : _Base (__a, __i) {}
+    };
+
+  //
+  // indirect_array closure
+  //
+  template<class _Dom>
+    class _IBase
+    {
+    public:
+      typedef typename _Dom::value_type value_type;
+
+      _IBase (const _Dom& __e, const valarray<size_t>& __i)
+      : _M_expr (__e), _M_index (__i) {}
+      
+      value_type
+      operator[] (size_t __i) const
+      { return _M_expr[_M_index[__i]]; }
+      
+      size_t
+      size() const
+      { return _M_index.size(); }
+
+    private:
+      const _Dom&	      _M_expr;
+      const valarray<size_t>& _M_index;
+    };
+
+  template<class _Dom>
+    struct _IClos<_Expr, _Dom>
+    : _IBase<_Dom>
+    {
+      typedef _IBase<_Dom> _Base;
+      typedef typename _Base::value_type value_type;
+      
+      _IClos (const _Dom& __e, const valarray<size_t>& __i)
+      : _Base (__e, __i) {}
+    };
+
+  template<typename _Tp>
+    struct _IClos<_ValArray, _Tp>
+    : _IBase<valarray<_Tp> >
+    {
+      typedef _IBase<valarray<_Tp> > _Base;
+      typedef _Tp value_type;
+      
+      _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
+      : _Base (__a, __i) {}
+    };
+  
+  //
+  // class _Expr
+  //
+  template<class _Clos, typename _Tp>
+    class _Expr
+    {
+    public:
+      typedef _Tp value_type;
+
+      _Expr(const _Clos&);
+
+      const _Clos& operator()() const;
+
+      value_type operator[](size_t) const;
+      valarray<value_type> operator[](slice) const;
+      valarray<value_type> operator[](const gslice&) const;
+      valarray<value_type> operator[](const valarray<bool>&) const;
+      valarray<value_type> operator[](const valarray<size_t>&) const;
+
+      _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
+      operator+() const;
+
+      _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
+      operator-() const;
+
+      _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
+      operator~() const;
+
+      _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
+      operator!() const;
+
+      size_t size() const;
+      value_type sum() const;
+
+      valarray<value_type> shift(int) const;
+      valarray<value_type> cshift(int) const;
+
+      value_type min() const;
+      value_type max() const;
+
+      valarray<value_type> apply(value_type (*)(const value_type&)) const;
+      valarray<value_type> apply(value_type (*)(value_type)) const;
+
+    private:
+      const _Clos _M_closure;
+    };
+
+  template<class _Clos, typename _Tp>
+    inline
+    _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
+
+  template<class _Clos, typename _Tp>
+    inline const _Clos&
+    _Expr<_Clos, _Tp>::operator()() const
+    { return _M_closure; }
+
+  template<class _Clos, typename _Tp>
+    inline _Tp
+    _Expr<_Clos, _Tp>::operator[](size_t __i) const
+    { return _M_closure[__i]; }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::operator[](slice __s) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
+      return __v;
+    }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
+      return __v;
+    }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
+      return __v;
+    }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
+      return __v;
+    }
+
+  template<class _Clos, typename _Tp>
+    inline size_t
+    _Expr<_Clos, _Tp>::size() const
+    { return _M_closure.size(); }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::shift(int __n) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
+      return __v;
+    }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::cshift(int __n) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
+      return __v;
+    }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
+      return __v;
+    }
+
+  template<class _Clos, typename _Tp>
+    inline valarray<_Tp>
+    _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
+    {
+      valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
+      return __v;
+    }
+
+  // XXX: replace this with a more robust summation algorithm.
+  template<class _Clos, typename _Tp>
+    inline _Tp
+    _Expr<_Clos, _Tp>::sum() const
+    {
+      size_t __n = _M_closure.size();
+      if (__n == 0)
+	return _Tp();
+      else
+	{
+	  _Tp __s = _M_closure[--__n];
+	  while (__n != 0)
+	    __s += _M_closure[--__n];
+	  return __s;
+        }
+    }
+
+  template<class _Clos, typename _Tp>
+    inline _Tp
+    _Expr<_Clos, _Tp>::min() const
+    { return __valarray_min(_M_closure); }
+
+  template<class _Clos, typename _Tp>
+    inline _Tp
+    _Expr<_Clos, _Tp>::max() const
+    { return __valarray_max(_M_closure); }
+
+  template<class _Dom, typename _Tp>
+    inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
+    _Expr<_Dom, _Tp>::operator!() const
+    {
+      typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
+      return _Expr<_Closure, bool>(_Closure(this->_M_closure));
+    }
+
+#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name)                           \
+  template<class _Dom, typename _Tp>                                      \
+    inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp>                   \
+    _Expr<_Dom, _Tp>::operator _Op() const                                \
+    {                                                                     \
+      typedef _UnClos<_Name, std::_Expr, _Dom> _Closure;                  \
+      return _Expr<_Closure, _Tp>(_Closure(this->_M_closure));            \
+    }
+
+    _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
+    _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
+    _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)
+
+#undef _DEFINE_EXPR_UNARY_OPERATOR
+
+#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name)                        \
+  template<class _Dom1, class _Dom2>					\
+    inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>,           \
+           typename __fun<_Name, typename _Dom1::value_type>::result_type> \
+    operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v,   \
+	         const _Expr<_Dom2, typename _Dom2::value_type>& __w)   \
+    {                                                                   \
+      typedef typename _Dom1::value_type _Arg;                          \
+      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
+      typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure;     \
+      return _Expr<_Closure, _Value>(_Closure(__v(), __w()));           \
+    }                                                                   \
+                                                                        \
+  template<class _Dom>                                                  \
+    inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom,                \
+                          typename _Dom::value_type>,                   \
+             typename __fun<_Name, typename _Dom::value_type>::result_type> \
+    operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v,     \
+                 const typename _Dom::value_type& __t)                  \
+    {                                                                   \
+      typedef typename _Dom::value_type _Arg;                           \
+      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
+      typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure;   \
+      return _Expr<_Closure, _Value>(_Closure(__v(), __t));             \
+    }                                                                   \
+                                                                        \
+  template<class _Dom>                                                  \
+    inline _Expr<_BinClos<_Name, _Constant, _Expr,                      \
+                          typename _Dom::value_type, _Dom>,             \
+             typename __fun<_Name, typename _Dom::value_type>::result_type> \
+    operator _Op(const typename _Dom::value_type& __t,                  \
+                 const _Expr<_Dom, typename _Dom::value_type>& __v)     \
+    {                                                                   \
+      typedef typename _Dom::value_type _Arg;                           \
+      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
+      typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure;   \
+      return _Expr<_Closure, _Value>(_Closure(__t, __v()));             \
+    }                                                                   \
+                                                                        \
+  template<class _Dom>                                                  \
+    inline _Expr<_BinClos<_Name, _Expr, _ValArray,                      \
+                          _Dom, typename _Dom::value_type>,             \
+             typename __fun<_Name, typename _Dom::value_type>::result_type> \
+    operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e,      \
+                 const valarray<typename _Dom::value_type>& __v)        \
+    {                                                                   \
+      typedef typename _Dom::value_type _Arg;                           \
+      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
+      typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure;   \
+      return _Expr<_Closure, _Value>(_Closure(__e(), __v));             \
+    }                                                                   \
+                                                                        \
+  template<class _Dom>                                                  \
+    inline _Expr<_BinClos<_Name, _ValArray, _Expr,                      \
+                 typename _Dom::value_type, _Dom>,                      \
+             typename __fun<_Name, typename _Dom::value_type>::result_type> \
+    operator _Op(const valarray<typename _Dom::value_type>& __v,        \
+                 const _Expr<_Dom, typename _Dom::value_type>& __e)     \
+    {                                                                   \
+      typedef typename _Dom::value_type _Tp;                            \
+      typedef typename __fun<_Name, _Tp>::result_type _Value;           \
+      typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure;    \
+      return _Expr<_Closure, _Value>(_Closure(__v, __e ()));            \
+    }
+
+    _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
+    _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
+    _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
+    _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)
+    _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)
+    _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)
+    _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)
+    _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)
+    _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)
+    _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)
+    _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)
+    _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)
+    _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)
+    _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)
+    _DEFINE_EXPR_BINARY_OPERATOR(<, __less)
+    _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)
+    _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)
+    _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)
+
+#undef _DEFINE_EXPR_BINARY_OPERATOR
+
+#define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName)                       \
+  template<class _Dom>                                                   \
+    inline _Expr<_UnClos<_UName, _Expr, _Dom>,                           \
+                 typename _Dom::value_type>                              \
+    _Name(const _Expr<_Dom, typename _Dom::value_type>& __e)             \
+    {                                                                    \
+      typedef typename _Dom::value_type _Tp;                             \
+      typedef _UnClos<_UName, _Expr, _Dom> _Closure;                     \
+      return _Expr<_Closure, _Tp>(_Closure(__e()));                      \
+    }                                                                    \
+                                                                         \
+  template<typename _Tp>                                                 \
+    inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp>                   \
+    _Name(const valarray<_Tp>& __v)                                      \
+    {                                                                    \
+      typedef _UnClos<_UName, _ValArray, _Tp> _Closure;                  \
+      return _Expr<_Closure, _Tp>(_Closure(__v));                        \
+    }
+
+    _DEFINE_EXPR_UNARY_FUNCTION(abs, _Abs)
+    _DEFINE_EXPR_UNARY_FUNCTION(cos, _Cos)
+    _DEFINE_EXPR_UNARY_FUNCTION(acos, _Acos)
+    _DEFINE_EXPR_UNARY_FUNCTION(cosh, _Cosh)
+    _DEFINE_EXPR_UNARY_FUNCTION(sin, _Sin)
+    _DEFINE_EXPR_UNARY_FUNCTION(asin, _Asin)
+    _DEFINE_EXPR_UNARY_FUNCTION(sinh, _Sinh)
+    _DEFINE_EXPR_UNARY_FUNCTION(tan, _Tan)
+    _DEFINE_EXPR_UNARY_FUNCTION(tanh, _Tanh)
+    _DEFINE_EXPR_UNARY_FUNCTION(atan, _Atan)
+    _DEFINE_EXPR_UNARY_FUNCTION(exp, _Exp)
+    _DEFINE_EXPR_UNARY_FUNCTION(log, _Log)
+    _DEFINE_EXPR_UNARY_FUNCTION(log10, _Log10)
+    _DEFINE_EXPR_UNARY_FUNCTION(sqrt, _Sqrt)
+
+#undef _DEFINE_EXPR_UNARY_FUNCTION
+
+#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun)		       \
+  template<class _Dom1, class _Dom2>                                   \
+    inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>,          \
+		 typename _Dom1::value_type>                           \
+    _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1,         \
+	 const _Expr<_Dom2, typename _Dom2::value_type>& __e2)	       \
+    {                                                                  \
+      typedef typename _Dom1::value_type _Tp;                          \
+      typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure;    \
+      return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2()));           \
+    }                                                                  \
+                                                                       \
+  template<class _Dom>                                                 \
+    inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom,               \
+			  typename _Dom::value_type>,                  \
+		 typename _Dom::value_type>                            \
+    _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
+	 const valarray<typename _Dom::value_type>& __v)               \
+    {                                                                  \
+      typedef typename _Dom::value_type _Tp;                           \
+      typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure;   \
+      return _Expr<_Closure, _Tp>(_Closure(__e(), __v));               \
+    }                                                                  \
+                                                                       \
+  template<class _Dom>                                                 \
+    inline _Expr<_BinClos<_UFun, _ValArray, _Expr,                     \
+			  typename _Dom::value_type, _Dom>,            \
+		 typename _Dom::value_type>                            \
+    _Fun(const valarray<typename _Dom::valarray>& __v,                 \
+	 const _Expr<_Dom, typename _Dom::value_type>& __e)            \
+    {                                                                  \
+      typedef typename _Dom::value_type _Tp;                           \
+      typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure;   \
+      return _Expr<_Closure, _Tp>(_Closure(__v, __e()));               \
+    }                                                                  \
+                                                                       \
+  template<class _Dom>                                                 \
+    inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom,               \
+			  typename _Dom::value_type>,                  \
+		 typename _Dom::value_type>                            \
+    _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
+	 const typename _Dom::value_type& __t)                         \
+    {                                                                  \
+      typedef typename _Dom::value_type _Tp;                           \
+      typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure;   \
+      return _Expr<_Closure, _Tp>(_Closure(__e(), __t));               \
+    }                                                                  \
+                                                                       \
+  template<class _Dom>                                                 \
+    inline _Expr<_BinClos<_UFun, _Constant, _Expr,                     \
+			  typename _Dom::value_type, _Dom>,            \
+		 typename _Dom::value_type>                            \
+    _Fun(const typename _Dom::value_type& __t,                         \
+	 const _Expr<_Dom, typename _Dom::value_type>& __e)            \
+    {                                                                  \
+      typedef typename _Dom::value_type _Tp;                           \
+      typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure;   \
+      return _Expr<_Closure, _Tp>(_Closure(__t, __e()));               \
+    }                                                                  \
+                                                                       \
+  template<typename _Tp>                                               \
+    inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
+    _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w)           \
+    {                                                                  \
+      typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\
+      return _Expr<_Closure, _Tp>(_Closure(__v, __w));                 \
+    }                                                                  \
+                                                                       \
+  template<typename _Tp>                                               \
+    inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
+    _Fun(const valarray<_Tp>& __v, const _Tp& __t)                     \
+    {                                                                  \
+      typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\
+      return _Expr<_Closure, _Tp>(_Closure(__v, __t));                 \
+    }                                                                  \
+								       \
+  template<typename _Tp>                                               \
+    inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
+    _Fun(const _Tp& __t, const valarray<_Tp>& __v)                     \
+    {                                                                  \
+      typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\
+      return _Expr<_Closure, _Tp>(_Closure(__t, __v));                 \
+    }
+
+_DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2)
+_DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow)
+
+#undef _DEFINE_EXPR_BINARY_FUNCTION
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _CPP_VALARRAY_AFTER_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/valarray_array.h b/gcc-4.9/libstdc++-v3/include/bits/valarray_array.h
new file mode 100644
index 0000000..8f5e047
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/valarray_array.h
@@ -0,0 +1,693 @@
+// The template and inlines for the -*- C++ -*- internal _Array helper class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/valarray_array.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _VALARRAY_ARRAY_H
+#define _VALARRAY_ARRAY_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/cpp_type_traits.h>
+#include <cstdlib>
+#include <new>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  //
+  // Helper functions on raw pointers
+  //
+
+  // We get memory by the old fashion way
+  inline void*
+  __valarray_get_memory(size_t __n)
+  { return operator new(__n); }
+
+  template<typename _Tp>
+    inline _Tp*__restrict__
+    __valarray_get_storage(size_t __n)
+    {
+      return static_cast<_Tp*__restrict__>
+	(std::__valarray_get_memory(__n * sizeof(_Tp)));
+    }
+
+  // Return memory to the system
+  inline void
+  __valarray_release_memory(void* __p)
+  { operator delete(__p); }
+
+  // Turn a raw-memory into an array of _Tp filled with _Tp()
+  // This is required in 'valarray<T> v(n);'
+  template<typename _Tp, bool>
+    struct _Array_default_ctor
+    {
+      // Please note that this isn't exception safe.  But
+      // valarrays aren't required to be exception safe.
+      inline static void
+      _S_do_it(_Tp* __b, _Tp* __e)
+      {
+	while (__b != __e)
+	  new(__b++) _Tp();
+      }
+    };
+
+  template<typename _Tp>
+    struct _Array_default_ctor<_Tp, true>
+    {
+      // For fundamental types, it suffices to say 'memset()'
+      inline static void
+      _S_do_it(_Tp* __b, _Tp* __e)
+      { __builtin_memset(__b, 0, (__e - __b) * sizeof(_Tp)); }
+    };
+
+  template<typename _Tp>
+    inline void
+    __valarray_default_construct(_Tp* __b, _Tp* __e)
+    {
+      _Array_default_ctor<_Tp, __is_scalar<_Tp>::__value>::_S_do_it(__b, __e);
+    }
+
+  // Turn a raw-memory into an array of _Tp filled with __t
+  // This is the required in valarray<T> v(n, t).  Also
+  // used in valarray<>::resize().
+  template<typename _Tp, bool>
+    struct _Array_init_ctor
+    {
+      // Please note that this isn't exception safe.  But
+      // valarrays aren't required to be exception safe.
+      inline static void
+      _S_do_it(_Tp* __b, _Tp* __e, const _Tp __t)
+      {
+	while (__b != __e)
+	  new(__b++) _Tp(__t);
+      }
+    };
+
+  template<typename _Tp>
+    struct _Array_init_ctor<_Tp, true>
+    {
+      inline static void
+      _S_do_it(_Tp* __b, _Tp* __e, const _Tp __t)
+      {
+	while (__b != __e)
+	  *__b++ = __t;
+      }
+    };
+
+  template<typename _Tp>
+    inline void
+    __valarray_fill_construct(_Tp* __b, _Tp* __e, const _Tp __t)
+    {
+      _Array_init_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __t);
+    }
+
+  //
+  // copy-construct raw array [__o, *) from plain array [__b, __e)
+  // We can't just say 'memcpy()'
+  //
+  template<typename _Tp, bool>
+    struct _Array_copy_ctor
+    {
+      // Please note that this isn't exception safe.  But
+      // valarrays aren't required to be exception safe.
+      inline static void
+      _S_do_it(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o)
+      {
+	while (__b != __e)
+	  new(__o++) _Tp(*__b++);
+      }
+    };
+
+  template<typename _Tp>
+    struct _Array_copy_ctor<_Tp, true>
+    {
+      inline static void
+      _S_do_it(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o)
+      { __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp)); }
+    };
+
+  template<typename _Tp>
+    inline void
+    __valarray_copy_construct(const _Tp* __b, const _Tp* __e,
+			      _Tp* __restrict__ __o)
+    {
+      _Array_copy_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __o);
+    }
+
+  // copy-construct raw array [__o, *) from strided array __a[<__n : __s>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
+			       size_t __s, _Tp* __restrict__ __o)
+    {
+      if (__is_trivial(_Tp))
+	while (__n--)
+	  {
+	    *__o++ = *__a;
+	    __a += __s;
+	  }
+      else
+	while (__n--)
+	  {
+	    new(__o++) _Tp(*__a);
+	    __a += __s;
+	  }
+    }
+
+  // copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]]
+  template<typename _Tp>
+    inline void
+    __valarray_copy_construct (const _Tp* __restrict__ __a,
+			       const size_t* __restrict__ __i,
+			       _Tp* __restrict__ __o, size_t __n)
+    {
+      if (__is_trivial(_Tp))
+	while (__n--)
+	  *__o++ = __a[*__i++];
+      else
+	while (__n--)
+	  new (__o++) _Tp(__a[*__i++]);
+    }
+
+  // Do the necessary cleanup when we're done with arrays.
+  template<typename _Tp>
+    inline void
+    __valarray_destroy_elements(_Tp* __b, _Tp* __e)
+    {
+      if (!__is_trivial(_Tp))
+	while (__b != __e)
+	  {
+	    __b->~_Tp();
+	    ++__b;
+	  }
+    }
+
+  // Fill a plain array __a[<__n>] with __t
+  template<typename _Tp>
+    inline void
+    __valarray_fill(_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
+    {
+      while (__n--)
+	*__a++ = __t;
+    }
+  
+  // fill strided array __a[<__n-1 : __s>] with __t
+  template<typename _Tp>
+    inline void
+    __valarray_fill(_Tp* __restrict__ __a, size_t __n,
+		    size_t __s, const _Tp& __t)
+    { 
+      for (size_t __i = 0; __i < __n; ++__i, __a += __s)
+	*__a = __t;
+    }
+
+  // fill indirect array __a[__i[<__n>]] with __i
+  template<typename _Tp>
+    inline void
+    __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
+		    size_t __n, const _Tp& __t)
+    {
+      for (size_t __j = 0; __j < __n; ++__j, ++__i)
+	__a[*__i] = __t;
+    }
+  
+  // copy plain array __a[<__n>] in __b[<__n>]
+  // For non-fundamental types, it is wrong to say 'memcpy()'
+  template<typename _Tp, bool>
+    struct _Array_copier
+    {
+      inline static void
+      _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
+      {
+	while(__n--)
+	  *__b++ = *__a++;
+      }
+    };
+
+  template<typename _Tp>
+    struct _Array_copier<_Tp, true>
+    {
+      inline static void
+      _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
+      { __builtin_memcpy(__b, __a, __n * sizeof (_Tp)); }
+    };
+
+  // Copy a plain array __a[<__n>] into a play array __b[<>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
+		    _Tp* __restrict__ __b)
+    {
+      _Array_copier<_Tp, __is_trivial(_Tp)>::_S_do_it(__a, __n, __b);
+    }
+
+  // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s,
+		    _Tp* __restrict__ __b)
+    {
+      for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s)
+	*__b = *__a;
+    }
+
+  // Copy a plain array  __a[<__n>] into a strided array __b[<__n : __s>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
+		    size_t __n, size_t __s)
+    {
+      for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s)
+	*__b = *__a;
+    }
+
+  // Copy strided array __src[<__n : __s1>] into another
+  // strided array __dst[< : __s2>].  Their sizes must match.
+  template<typename _Tp>
+    inline void
+    __valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
+		    _Tp* __restrict__ __dst, size_t __s2)
+    {
+      for (size_t __i = 0; __i < __n; ++__i)
+	__dst[__i * __s2] = __src[__i * __s1];
+    }
+
+  // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(const _Tp* __restrict__ __a,
+		    const size_t* __restrict__ __i,
+		    _Tp* __restrict__ __b, size_t __n)
+    {
+      for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i)
+	*__b = __a[*__i];
+    }
+
+  // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
+		    _Tp* __restrict__ __b, const size_t* __restrict__ __i)
+    {
+      for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i)
+	__b[*__i] = *__a;
+    }
+
+  // Copy the __n first elements of an indexed array __src[<__i>] into
+  // another indexed array __dst[<__j>].
+  template<typename _Tp>
+    inline void
+    __valarray_copy(const _Tp* __restrict__ __src, size_t __n,
+		    const size_t* __restrict__ __i,
+		    _Tp* __restrict__ __dst, const size_t* __restrict__ __j)
+    {
+      for (size_t __k = 0; __k < __n; ++__k)
+	__dst[*__j++] = __src[*__i++];
+    }
+
+  //
+  // Compute the sum of elements in range [__f, __l)
+  // This is a naive algorithm.  It suffers from cancelling.
+  // In the future try to specialize
+  // for _Tp = float, double, long double using a more accurate
+  // algorithm.
+  //
+  template<typename _Tp>
+    inline _Tp
+    __valarray_sum(const _Tp* __f, const _Tp* __l)
+    {
+      _Tp __r = _Tp();
+      while (__f != __l)
+	__r += *__f++;
+      return __r;
+    }
+
+  // Compute the product of all elements in range [__f, __l)
+  template<typename _Tp>
+    inline _Tp
+    __valarray_product(const _Tp* __f, const _Tp* __l)
+    {
+      _Tp __r = _Tp(1);
+      while (__f != __l)
+	__r = __r * *__f++;
+      return __r;
+    }
+
+  // Compute the min/max of an array-expression
+  template<typename _Ta>
+    inline typename _Ta::value_type
+    __valarray_min(const _Ta& __a)
+    {
+      size_t __s = __a.size();
+      typedef typename _Ta::value_type _Value_type;
+      _Value_type __r = __s == 0 ? _Value_type() : __a[0];
+      for (size_t __i = 1; __i < __s; ++__i)
+	{
+	  _Value_type __t = __a[__i];
+	  if (__t < __r)
+	    __r = __t;
+	}
+      return __r;
+    }
+
+  template<typename _Ta>
+    inline typename _Ta::value_type
+    __valarray_max(const _Ta& __a)
+    {
+      size_t __s = __a.size();
+      typedef typename _Ta::value_type _Value_type;
+      _Value_type __r = __s == 0 ? _Value_type() : __a[0];
+      for (size_t __i = 1; __i < __s; ++__i)
+	{
+	  _Value_type __t = __a[__i];
+	  if (__t > __r)
+	    __r = __t;
+	}
+      return __r;
+    }
+
+  //
+  // Helper class _Array, first layer of valarray abstraction.
+  // All operations on valarray should be forwarded to this class
+  // whenever possible. -- gdr
+  //
+
+  template<typename _Tp>
+    struct _Array
+    {
+      explicit _Array(size_t);
+      explicit _Array(_Tp* const __restrict__);
+      explicit _Array(const valarray<_Tp>&);
+      _Array(const _Tp* __restrict__, size_t);
+      
+      _Tp* begin() const;
+      
+      _Tp* const __restrict__ _M_data;
+    };
+
+
+  // Copy-construct plain array __b[<__n>] from indexed array __a[__i[<__n>]]
+  template<typename _Tp>
+    inline void
+    __valarray_copy_construct(_Array<_Tp> __a, _Array<size_t> __i,
+			      _Array<_Tp> __b, size_t __n)
+    { std::__valarray_copy_construct(__a._M_data, __i._M_data,
+				     __b._M_data, __n); }
+
+  // Copy-construct plain array __b[<__n>] from strided array __a[<__n : __s>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy_construct(_Array<_Tp> __a, size_t __n, size_t __s,
+			      _Array<_Tp> __b)
+    { std::__valarray_copy_construct(__a._M_data, __n, __s, __b._M_data); }
+
+  template<typename _Tp>
+    inline void
+    __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
+    { std::__valarray_fill(__a._M_data, __n, __t); }
+
+  template<typename _Tp>
+    inline void
+    __valarray_fill(_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
+    { std::__valarray_fill(__a._M_data, __n, __s, __t); }
+
+  template<typename _Tp>
+    inline void
+    __valarray_fill(_Array<_Tp> __a, _Array<size_t> __i,
+		    size_t __n, const _Tp& __t)
+    { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); }
+
+  // Copy a plain array __a[<__n>] into a play array __b[<>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
+    { std::__valarray_copy(__a._M_data, __n, __b._M_data); }
+
+  // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
+    { std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); }
+
+  // Copy a plain array  __a[<__n>] into a strided array __b[<__n : __s>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
+    { __valarray_copy(__a._M_data, __b._M_data, __n, __s); }
+
+  // Copy strided array __src[<__n : __s1>] into another
+  // strided array __dst[< : __s2>].  Their sizes must match.
+  template<typename _Tp>
+    inline void
+    __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
+                    _Array<_Tp> __b, size_t __s2)
+    { std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
+
+  // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
+		    _Array<_Tp> __b, size_t __n)
+    { std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }
+
+  // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
+  template<typename _Tp>
+    inline void
+    __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
+		    _Array<size_t> __i)
+    { std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
+
+  // Copy the __n first elements of an indexed array __src[<__i>] into
+  // another indexed array __dst[<__j>].
+  template<typename _Tp>
+    inline void
+    __valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
+                    _Array<_Tp> __dst, _Array<size_t> __j)
+    {
+      std::__valarray_copy(__src._M_data, __n, __i._M_data,
+		    __dst._M_data, __j._M_data);
+    }
+
+  template<typename _Tp>
+    inline
+    _Array<_Tp>::_Array(size_t __n)
+    : _M_data(__valarray_get_storage<_Tp>(__n))
+    { std::__valarray_default_construct(_M_data, _M_data + __n); }
+
+  template<typename _Tp>
+    inline
+    _Array<_Tp>::_Array(_Tp* const __restrict__ __p)
+    : _M_data (__p) {}
+
+  template<typename _Tp>
+    inline
+    _Array<_Tp>::_Array(const valarray<_Tp>& __v)
+    : _M_data (__v._M_data) {}
+
+  template<typename _Tp>
+    inline
+    _Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s)
+    : _M_data(__valarray_get_storage<_Tp>(__s))
+    { std::__valarray_copy_construct(__b, __s, _M_data); }
+
+  template<typename _Tp>
+    inline _Tp*
+    _Array<_Tp>::begin () const
+    { return _M_data; }
+
+#define _DEFINE_ARRAY_FUNCTION(_Op, _Name)				\
+  template<typename _Tp>		        			\
+    inline void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, const _Tp& __t) \
+    {									\
+      for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p)	\
+        *__p _Op##= __t;						\
+    }									\
+									\
+  template<typename _Tp>						\
+    inline void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \
+    {									\
+      _Tp* __p = __a._M_data;						\
+      for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) \
+        *__p _Op##= *__q;						\
+    }									\
+									\
+  template<typename _Tp, class _Dom>					\
+    void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a,	        		\
+                             const _Expr<_Dom, _Tp>& __e, size_t __n)	\
+    {									\
+      _Tp* __p(__a._M_data);						\
+      for (size_t __i = 0; __i < __n; ++__i, ++__p)                     \
+        *__p _Op##= __e[__i];                                          	\
+    }									\
+									\
+  template<typename _Tp>						\
+    inline void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, size_t __s,	\
+	                     _Array<_Tp> __b)				\
+    {									\
+      _Tp* __q(__b._M_data);						\
+      for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n;       \
+	   __p += __s, ++__q)                                           \
+        *__p _Op##= *__q;						\
+    }									\
+									\
+  template<typename _Tp>						\
+    inline void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, _Array<_Tp> __b,		\
+		             size_t __n, size_t __s)			\
+    {									\
+      _Tp* __q(__b._M_data);						\
+      for (_Tp* __p = __a._M_data; __p < __a._M_data + __n;             \
+	   ++__p, __q += __s)                                           \
+        *__p _Op##= *__q;						\
+    }									\
+									\
+  template<typename _Tp, class _Dom>					\
+    void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, size_t __s,		\
+                             const _Expr<_Dom, _Tp>& __e, size_t __n)	\
+    {									\
+      _Tp* __p(__a._M_data);						\
+      for (size_t __i = 0; __i < __n; ++__i, __p += __s)                \
+        *__p _Op##= __e[__i];                                          	\
+    }									\
+									\
+  template<typename _Tp>						\
+    inline void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __i,	\
+                             _Array<_Tp> __b, size_t __n)		\
+    {									\
+      _Tp* __q(__b._M_data);						\
+      for (size_t* __j = __i._M_data; __j < __i._M_data + __n;          \
+           ++__j, ++__q)                                                \
+        __a._M_data[*__j] _Op##= *__q;					\
+    }									\
+									\
+  template<typename _Tp>						\
+    inline void					        		\
+    _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n,		\
+                             _Array<_Tp> __b, _Array<size_t> __i)	\
+    {									\
+      _Tp* __p(__a._M_data);						\
+      for (size_t* __j = __i._M_data; __j<__i._M_data + __n;            \
+	   ++__j, ++__p)                                                \
+        *__p _Op##= __b._M_data[*__j];					\
+    }									\
+									\
+  template<typename _Tp, class _Dom>					\
+    void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __i,	\
+                             const _Expr<_Dom, _Tp>& __e, size_t __n)	\
+    {									\
+      size_t* __j(__i._M_data);	        				\
+      for (size_t __k = 0; __k<__n; ++__k, ++__j)			\
+        __a._M_data[*__j] _Op##= __e[__k];				\
+    }									\
+									\
+  template<typename _Tp>						\
+    void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __m,         \
+                             _Array<_Tp> __b, size_t __n)		\
+    {									\
+      bool* __ok(__m._M_data);						\
+      _Tp* __p(__a._M_data);						\
+      for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;             \
+	   ++__q, ++__ok, ++__p)                                        \
+        {                                                               \
+          while (! *__ok)                                               \
+            {						        	\
+              ++__ok;							\
+              ++__p;							\
+            }								\
+          *__p _Op##= *__q;						\
+        }								\
+    }									\
+									\
+  template<typename _Tp>						\
+    void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n,		\
+                             _Array<_Tp> __b, _Array<bool> __m)   	\
+    {									\
+      bool* __ok(__m._M_data);						\
+      _Tp* __q(__b._M_data);						\
+      for (_Tp* __p = __a._M_data; __p < __a._M_data + __n;             \
+	   ++__p, ++__ok, ++__q)                                        \
+        {                                                               \
+          while (! *__ok)                                               \
+            {					        		\
+              ++__ok;							\
+              ++__q;							\
+            }								\
+          *__p _Op##= *__q;						\
+        }								\
+    }									\
+									\
+  template<typename _Tp, class _Dom>					\
+    void								\
+    _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __m,  	\
+                             const _Expr<_Dom, _Tp>& __e, size_t __n)	\
+    {									\
+      bool* __ok(__m._M_data);						\
+      _Tp* __p(__a._M_data);						\
+      for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)             \
+        {	                                           		\
+          while (! *__ok)                                               \
+            {		         					\
+	      ++__ok;							\
+              ++__p;							\
+            }								\
+          *__p _Op##= __e[__i];						\
+        }								\
+    }
+
+   _DEFINE_ARRAY_FUNCTION(+, __plus)
+   _DEFINE_ARRAY_FUNCTION(-, __minus)
+   _DEFINE_ARRAY_FUNCTION(*, __multiplies)
+   _DEFINE_ARRAY_FUNCTION(/, __divides)
+   _DEFINE_ARRAY_FUNCTION(%, __modulus)
+   _DEFINE_ARRAY_FUNCTION(^, __bitwise_xor)
+   _DEFINE_ARRAY_FUNCTION(|, __bitwise_or)
+   _DEFINE_ARRAY_FUNCTION(&, __bitwise_and)
+   _DEFINE_ARRAY_FUNCTION(<<, __shift_left)
+   _DEFINE_ARRAY_FUNCTION(>>, __shift_right)
+
+#undef _DEFINE_ARRAY_FUNCTION
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+# include <bits/valarray_array.tcc>
+
+#endif /* _ARRAY_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/valarray_array.tcc b/gcc-4.9/libstdc++-v3/include/bits/valarray_array.tcc
new file mode 100644
index 0000000..6f2f6e2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/valarray_array.tcc
@@ -0,0 +1,244 @@
+// The template and inlines for the -*- C++ -*- internal _Array helper class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/valarray_array.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _VALARRAY_ARRAY_TCC
+#define _VALARRAY_ARRAY_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Tp>
+    void
+    __valarray_fill(_Array<_Tp> __a, size_t __n, _Array<bool> __m,
+		    const _Tp& __t)
+    {
+      _Tp* __p = __a._M_data;
+      bool* __ok (__m._M_data);
+      for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p)
+	{
+	  while (!*__ok)
+	  {
+	    ++__ok;
+	    ++__p;
+	  }
+	  *__p = __t;
+	}
+    }
+
+  // Copy n elements of a into consecutive elements of b.  When m is
+  // false, the corresponding element of a is skipped.  m must contain
+  // at least n true elements.  a must contain at least n elements and
+  // enough elements to match up with m through the nth true element
+  // of m.  I.e.  if n is 10, m has 15 elements with 5 false followed
+  // by 10 true, a must have 15 elements.
+  template<typename _Tp>
+    void
+    __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b,
+		    size_t __n)
+    {
+      _Tp* __p (__a._M_data);
+      bool* __ok (__m._M_data);
+      for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;
+	   ++__q, ++__ok, ++__p)
+	{
+	  while (! *__ok)
+	    {
+	      ++__ok;
+	      ++__p;
+	    }
+	  *__q = *__p;
+	}
+    }
+
+  // Copy n consecutive elements from a into elements of b.  Elements
+  // of b are skipped if the corresponding element of m is false.  m
+  // must contain at least n true elements.  b must have at least as
+  // many elements as the index of the nth true element of m.  I.e. if
+  // m has 15 elements with 5 false followed by 10 true, b must have
+  // at least 15 elements.
+  template<typename _Tp>
+    void
+    __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
+		    _Array<bool> __m)
+    {
+      _Tp* __q (__b._M_data);
+      bool* __ok (__m._M_data);
+      for (_Tp* __p = __a._M_data; __p < __a._M_data+__n;
+	   ++__p, ++__ok, ++__q)
+	{
+	  while (! *__ok)
+	    {
+	      ++__ok;
+	      ++__q;
+	    }
+	  *__q = *__p;
+	}
+    }
+
+  // Copy n elements from a into elements of b.  Elements of a are
+  // skipped if the corresponding element of m is false.  Elements of
+  // b are skipped if the corresponding element of k is false.  m and
+  // k must contain at least n true elements.  a and b must have at
+  // least as many elements as the index of the nth true element of m.
+  template<typename _Tp>
+    void
+    __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, size_t __n,
+		    _Array<_Tp> __b, _Array<bool> __k)
+    {
+      _Tp* __p (__a._M_data);
+      _Tp* __q (__b._M_data);
+      bool* __srcok (__m._M_data);
+      bool* __dstok (__k._M_data);
+      for (size_t __i = 0; __i < __n;
+	   ++__srcok, ++__p, ++__dstok, ++__q, ++__i)
+	{
+	  while (! *__srcok)
+	    {
+	      ++__srcok;
+	      ++__p;
+	    }
+	  while (! *__dstok) 
+	    {
+	      ++__dstok;
+	      ++__q;
+	    }
+	  *__q = *__p;
+	}
+    }
+
+  // Copy n consecutive elements of e into consecutive elements of a.
+  // I.e. a[i] = e[i].
+  template<typename _Tp, class _Dom>
+    void
+    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
+    {
+      _Tp* __p (__a._M_data);
+      for (size_t __i = 0; __i < __n; ++__i, ++__p)
+	*__p = __e[__i];
+    }
+
+  // Copy n consecutive elements of e into elements of a using stride
+  // s.  I.e., a[0] = e[0], a[s] = e[1], a[2*s] = e[2].
+  template<typename _Tp, class _Dom>
+    void
+    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
+		     _Array<_Tp> __a, size_t __s)
+    {
+      _Tp* __p (__a._M_data);
+      for (size_t __i = 0; __i < __n; ++__i, __p += __s)
+	*__p = __e[__i];
+    }
+
+  // Copy n consecutive elements of e into elements of a indexed by
+  // contents of i.  I.e., a[i[0]] = e[0].
+  template<typename _Tp, class _Dom>
+    void
+    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
+		    _Array<_Tp> __a, _Array<size_t> __i)
+    {
+      size_t* __j (__i._M_data);
+      for (size_t __k = 0; __k < __n; ++__k, ++__j)
+	__a._M_data[*__j] = __e[__k];
+    }
+
+  // Copy n elements of e indexed by contents of f into elements of a
+  // indexed by contents of i.  I.e., a[i[0]] = e[f[0]].
+  template<typename _Tp>
+    void
+    __valarray_copy(_Array<_Tp> __e, _Array<size_t> __f,
+		    size_t __n, 
+		    _Array<_Tp> __a, _Array<size_t> __i)
+    {
+      size_t* __g (__f._M_data);
+      size_t* __j (__i._M_data);
+      for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g) 
+	__a._M_data[*__j] = __e._M_data[*__g];
+    }
+
+  // Copy n consecutive elements of e into elements of a.  Elements of
+  // a are skipped if the corresponding element of m is false.  m must
+  // have at least n true elements and a must have at least as many
+  // elements as the index of the nth true element of m.  I.e. if m
+  // has 5 false followed by 10 true elements and n == 10, a must have
+  // at least 15 elements.
+  template<typename _Tp, class _Dom>
+    void
+    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
+		    _Array<_Tp> __a, _Array<bool> __m)
+    {
+      bool* __ok (__m._M_data);
+      _Tp* __p (__a._M_data);
+      for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)
+	{
+	  while (! *__ok)
+	    {
+	      ++__ok;
+	      ++__p;
+	    }
+	  *__p = __e[__i];
+	}
+    }
+
+
+  template<typename _Tp, class _Dom>
+    void
+    __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n,
+			      _Array<_Tp> __a)
+    {
+      _Tp* __p (__a._M_data);
+      for (size_t __i = 0; __i < __n; ++__i, ++__p)
+	new (__p) _Tp(__e[__i]);
+    }
+
+
+  template<typename _Tp>
+    void
+    __valarray_copy_construct(_Array<_Tp> __a, _Array<bool> __m,
+			      _Array<_Tp> __b, size_t __n)
+    {
+      _Tp* __p (__a._M_data);
+      bool* __ok (__m._M_data);
+      for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p)
+	{
+	  while (! *__ok)
+	    {
+	      ++__ok;
+	      ++__p;
+	    }
+	  new (__q) _Tp(*__p);
+	}
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _VALARRAY_ARRAY_TCC */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/valarray_before.h b/gcc-4.9/libstdc++-v3/include/bits/valarray_before.h
new file mode 100644
index 0000000..fb5ec74
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/valarray_before.h
@@ -0,0 +1,733 @@
+// The template and inlines for the -*- C++ -*- internal _Meta class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/valarray_before.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{valarray}
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
+
+#ifndef _VALARRAY_BEFORE_H
+#define _VALARRAY_BEFORE_H 1
+
+#pragma GCC system_header
+
+#include <bits/slice_array.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  //
+  // Implementing a loosened valarray return value is tricky.
+  // First we need to meet 26.3.1/3: we should not add more than
+  // two levels of template nesting. Therefore we resort to template
+  // template to "flatten" loosened return value types.
+  // At some point we use partial specialization to remove one level
+  // template nesting due to _Expr<>
+  //
+
+  // This class is NOT defined. It doesn't need to.
+  template<typename _Tp1, typename _Tp2> class _Constant;
+
+  // Implementations of unary functions applied to valarray<>s.
+  // I use hard-coded object functions here instead of a generic
+  // approach like pointers to function:
+  //    1) correctness: some functions take references, others values.
+  //       we can't deduce the correct type afterwards.
+  //    2) efficiency -- object functions can be easily inlined
+  //    3) be Koenig-lookup-friendly
+
+  struct _Abs
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return abs(__t); }
+  };
+
+  struct _Cos
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return cos(__t); }
+  };
+
+  struct _Acos
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return acos(__t); }
+  };
+
+  struct _Cosh
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return cosh(__t); }
+  };
+
+  struct _Sin
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return sin(__t); }
+  };
+
+  struct _Asin
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return asin(__t); }
+  };
+
+  struct _Sinh
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return sinh(__t); }
+  };
+
+  struct _Tan
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return tan(__t); }
+  };
+
+  struct _Atan
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return atan(__t); }
+  };
+
+  struct _Tanh
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return tanh(__t); }
+  };
+
+  struct _Exp
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return exp(__t); }
+  };
+
+  struct _Log
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return log(__t); }
+  };
+
+  struct _Log10
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return log10(__t); }
+  };
+
+  struct _Sqrt
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return sqrt(__t); }
+  };
+
+  // In the past, we used to tailor operator applications semantics
+  // to the specialization of standard function objects (i.e. plus<>, etc.)
+  // That is incorrect.  Therefore we provide our own surrogates.
+
+  struct __unary_plus
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return +__t; }
+  };
+
+  struct __negate
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return -__t; }
+  };
+
+  struct __bitwise_not
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __t) const
+      { return ~__t; }
+  };
+
+  struct __plus
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x + __y; }
+  };
+
+  struct __minus
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x - __y; }
+  };
+
+  struct __multiplies
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x * __y; }
+  };
+
+  struct __divides
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x / __y; }
+  };
+
+  struct __modulus
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x % __y; }
+  };
+
+  struct __bitwise_xor
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x ^ __y; }
+  };
+
+  struct __bitwise_and
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x & __y; }
+  };
+
+  struct __bitwise_or
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x | __y; }
+  };
+
+  struct __shift_left
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x << __y; }
+  };
+
+  struct __shift_right
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >> __y; }
+  };
+
+  struct __logical_and
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x && __y; }
+  };
+
+  struct __logical_or
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x || __y; }
+  };
+
+  struct __logical_not
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x) const
+      { return !__x; }
+  };
+
+  struct __equal_to
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x == __y; }
+  };
+
+  struct __not_equal_to
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x != __y; }
+  };
+
+  struct __less
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x < __y; }
+  };
+
+  struct __greater
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x > __y; }
+  };
+
+  struct __less_equal
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x <= __y; }
+  };
+
+  struct __greater_equal
+  {
+    template<typename _Tp>
+      bool operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >= __y; }
+  };
+
+  // The few binary functions we miss.
+  struct _Atan2
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return atan2(__x, __y); }
+  };
+
+  struct _Pow
+  {
+    template<typename _Tp>
+      _Tp operator()(const _Tp& __x, const _Tp& __y) const
+      { return pow(__x, __y); }
+  };
+
+
+  // We need these bits in order to recover the return type of
+  // some functions/operators now that we're no longer using
+  // function templates.
+  template<typename, typename _Tp>
+    struct __fun
+    {
+      typedef _Tp result_type;
+    };
+
+  // several specializations for relational operators.
+  template<typename _Tp>
+    struct __fun<__logical_not, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__logical_and, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__logical_or, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__less, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__greater, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__less_equal, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__greater_equal, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__equal_to, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  template<typename _Tp>
+    struct __fun<__not_equal_to, _Tp>
+    {
+      typedef bool result_type;
+    };
+
+  //
+  // Apply function taking a value/const reference closure
+  //
+
+  template<typename _Dom, typename _Arg>
+    class _FunBase
+    {
+    public:
+      typedef typename _Dom::value_type value_type;
+
+      _FunBase(const _Dom& __e, value_type __f(_Arg))
+      : _M_expr(__e), _M_func(__f) {}
+
+      value_type operator[](size_t __i) const
+      { return _M_func (_M_expr[__i]); }
+
+      size_t size() const { return _M_expr.size ();}
+
+    private:
+      const _Dom& _M_expr;
+      value_type (*_M_func)(_Arg);
+    };
+
+  template<class _Dom>
+    struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
+    {
+      typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
+      typedef typename _Base::value_type value_type;
+      typedef value_type _Tp;
+
+      _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
+    };
+
+  template<typename _Tp>
+    struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
+    {
+      typedef _FunBase<valarray<_Tp>, _Tp> _Base;
+      typedef _Tp value_type;
+
+      _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
+    };
+
+  template<class _Dom>
+    struct _RefFunClos<_Expr, _Dom>
+    : _FunBase<_Dom, const typename _Dom::value_type&>
+    {
+      typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
+      typedef typename _Base::value_type value_type;
+      typedef value_type _Tp;
+
+      _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&))
+      : _Base(__e, __f) {}
+    };
+
+  template<typename _Tp>
+    struct _RefFunClos<_ValArray, _Tp>
+    : _FunBase<valarray<_Tp>, const _Tp&>
+    {
+      typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
+      typedef _Tp value_type;
+
+      _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
+      : _Base(__v, __f) {}
+    };
+
+  //
+  // Unary expression closure.
+  //
+
+  template<class _Oper, class _Arg>
+    class _UnBase
+    {
+    public:
+      typedef typename _Arg::value_type _Vt;
+      typedef typename __fun<_Oper, _Vt>::result_type value_type;
+
+      _UnBase(const _Arg& __e) : _M_expr(__e) {}
+
+      value_type operator[](size_t __i) const
+      { return _Oper()(_M_expr[__i]); }
+
+      size_t size() const { return _M_expr.size(); }
+      
+    private:
+      const _Arg& _M_expr;
+    };
+
+  template<class _Oper, class _Dom>
+    struct _UnClos<_Oper, _Expr, _Dom>
+    : _UnBase<_Oper, _Dom>
+    {
+      typedef _Dom _Arg;
+      typedef _UnBase<_Oper, _Dom> _Base;
+      typedef typename _Base::value_type value_type;
+
+      _UnClos(const _Arg& __e) : _Base(__e) {}
+    };
+
+  template<class _Oper, typename _Tp>
+    struct _UnClos<_Oper, _ValArray, _Tp>
+    : _UnBase<_Oper, valarray<_Tp> >
+    {
+      typedef valarray<_Tp> _Arg;
+      typedef _UnBase<_Oper, valarray<_Tp> > _Base;
+      typedef typename _Base::value_type value_type;
+
+      _UnClos(const _Arg& __e) : _Base(__e) {}
+    };
+
+
+  //
+  // Binary expression closure.
+  //
+
+  template<class _Oper, class _FirstArg, class _SecondArg>
+    class _BinBase
+    {
+    public:
+      typedef typename _FirstArg::value_type _Vt;
+      typedef typename __fun<_Oper, _Vt>::result_type value_type;
+
+      _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
+      : _M_expr1(__e1), _M_expr2(__e2) {}
+
+      value_type operator[](size_t __i) const
+      { return _Oper()(_M_expr1[__i], _M_expr2[__i]); }
+
+      size_t size() const { return _M_expr1.size(); }
+
+    private:
+      const _FirstArg& _M_expr1;
+      const _SecondArg& _M_expr2;
+    };
+
+
+  template<class _Oper, class _Clos>
+    class _BinBase2
+    {
+    public:
+      typedef typename _Clos::value_type _Vt;
+      typedef typename __fun<_Oper, _Vt>::result_type value_type;
+
+      _BinBase2(const _Clos& __e, const _Vt& __t)
+      : _M_expr1(__e), _M_expr2(__t) {}
+
+      value_type operator[](size_t __i) const
+      { return _Oper()(_M_expr1[__i], _M_expr2); }
+
+      size_t size() const { return _M_expr1.size(); }
+
+    private:
+      const _Clos& _M_expr1;
+      const _Vt& _M_expr2;
+    };
+
+  template<class _Oper, class _Clos>
+    class _BinBase1
+    {
+    public:
+      typedef typename _Clos::value_type _Vt;
+      typedef typename __fun<_Oper, _Vt>::result_type value_type;
+
+      _BinBase1(const _Vt& __t, const _Clos& __e)
+      : _M_expr1(__t), _M_expr2(__e) {}
+
+      value_type operator[](size_t __i) const
+      { return _Oper()(_M_expr1, _M_expr2[__i]); }
+
+      size_t size() const { return _M_expr2.size(); }
+
+    private:
+      const _Vt& _M_expr1;
+      const _Clos& _M_expr2;
+    };
+
+  template<class _Oper, class _Dom1, class _Dom2>
+    struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
+    : _BinBase<_Oper, _Dom1, _Dom2>
+    {
+      typedef _BinBase<_Oper, _Dom1, _Dom2> _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
+    };
+
+  template<class _Oper, typename _Tp>
+    struct _BinClos<_Oper,_ValArray, _ValArray, _Tp, _Tp>
+    : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> >
+    {
+      typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w)
+      : _Base(__v, __w) {}
+    };
+
+  template<class _Oper, class _Dom>
+    struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type>
+    : _BinBase<_Oper, _Dom, valarray<typename _Dom::value_type> >
+    {
+      typedef typename _Dom::value_type _Tp;
+      typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
+      : _Base(__e1, __e2) {}
+    };
+
+  template<class _Oper, class _Dom>
+    struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom>
+    : _BinBase<_Oper, valarray<typename _Dom::value_type>,_Dom>
+    {
+      typedef typename _Dom::value_type _Tp;
+      typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2)
+      : _Base(__e1, __e2) {}
+    };
+
+  template<class _Oper, class _Dom>
+    struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type>
+    : _BinBase2<_Oper, _Dom>
+    {
+      typedef typename _Dom::value_type _Tp;
+      typedef _BinBase2<_Oper,_Dom> _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {}
+    };
+
+  template<class _Oper, class _Dom>
+    struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom>
+    : _BinBase1<_Oper, _Dom>
+    {
+      typedef typename _Dom::value_type _Tp;
+      typedef _BinBase1<_Oper, _Dom> _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {}
+    };
+
+  template<class _Oper, typename _Tp>
+    struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp>
+    : _BinBase2<_Oper, valarray<_Tp> >
+    {
+      typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {}
+    };
+
+  template<class _Oper, typename _Tp>
+    struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp>
+    : _BinBase1<_Oper, valarray<_Tp> >
+    {
+      typedef _BinBase1<_Oper, valarray<_Tp> > _Base;
+      typedef typename _Base::value_type value_type;
+
+      _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {}
+    };
+
+    //
+    // slice_array closure.
+    //
+  template<typename _Dom> 
+    class _SBase
+    {
+    public:
+      typedef typename _Dom::value_type value_type;
+      
+      _SBase (const _Dom& __e, const slice& __s)
+      : _M_expr (__e), _M_slice (__s) {}
+        
+      value_type
+      operator[] (size_t __i) const
+      { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
+        
+      size_t
+      size() const
+      { return _M_slice.size (); }
+
+    private:
+      const _Dom& _M_expr;
+      const slice& _M_slice;
+    };
+
+  template<typename _Tp>
+    class _SBase<_Array<_Tp> >
+    {
+    public:
+      typedef _Tp value_type;
+      
+      _SBase (_Array<_Tp> __a, const slice& __s)
+      : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
+	_M_stride (__s.stride()) {}
+        
+      value_type
+      operator[] (size_t __i) const
+      { return _M_array._M_data[__i * _M_stride]; }
+      
+      size_t
+      size() const
+      { return _M_size; }
+
+    private:
+      const _Array<_Tp> _M_array;
+      const size_t _M_size;
+      const size_t _M_stride;
+    };
+
+  template<class _Dom>
+    struct _SClos<_Expr, _Dom>
+    : _SBase<_Dom>
+    {
+      typedef _SBase<_Dom> _Base;
+      typedef typename _Base::value_type value_type;
+      
+      _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
+    };
+
+  template<typename _Tp>
+    struct _SClos<_ValArray, _Tp>
+    : _SBase<_Array<_Tp> >
+    {
+      typedef  _SBase<_Array<_Tp> > _Base;
+      typedef _Tp value_type;
+      
+      _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _CPP_VALARRAY_BEFORE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/bits/vector.tcc b/gcc-4.9/libstdc++-v3/include/bits/vector.tcc
new file mode 100644
index 0000000..1eff514
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/bits/vector.tcc
@@ -0,0 +1,884 @@
+// Vector implementation (out of line) -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this  software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file bits/vector.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{vector}
+ */
+
+#ifndef _VECTOR_TCC
+#define _VECTOR_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+	__throw_length_error(__N("vector::reserve"));
+      if (this->capacity() < __n)
+	{
+	  const size_type __old_size = size();
+	  pointer __tmp = _M_allocate_and_copy(__n,
+	    _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(this->_M_impl._M_start),
+	    _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(this->_M_impl._M_finish));
+	  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+			_M_get_Tp_allocator());
+	  _M_deallocate(this->_M_impl._M_start,
+			this->_M_impl._M_end_of_storage
+			- this->_M_impl._M_start);
+	  this->_M_impl._M_start = __tmp;
+	  this->_M_impl._M_finish = __tmp + __old_size;
+	  this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+	}
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      emplace_back(_Args&&... __args)
+      {
+	if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+	  {
+	    _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+				     std::forward<_Args>(__args)...);
+	    ++this->_M_impl._M_finish;
+	  }
+	else
+	  _M_emplace_back_aux(std::forward<_Args>(__args)...);
+      }
+#endif
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+#if __cplusplus >= 201103L
+    insert(const_iterator __position, const value_type& __x)
+#else
+    insert(iterator __position, const value_type& __x)
+#endif
+    {
+      const size_type __n = __position - begin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
+	  && __position == end())
+	{
+	  _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
+	  ++this->_M_impl._M_finish;
+	}
+      else
+	{
+#if __cplusplus >= 201103L
+	  if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+	    {
+	      _Tp __x_copy = __x;
+	      _M_insert_aux(__position._M_const_cast(), std::move(__x_copy));
+	    }
+	  else
+#endif
+	    _M_insert_aux(__position._M_const_cast(), __x);
+	}
+      return iterator(this->_M_impl._M_start + __n);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+	_GLIBCXX_MOVE3(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+      return __position;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+	{
+	  if (__last != end())
+	    _GLIBCXX_MOVE3(__last, end(), __first);
+	  _M_erase_at_end(__first.base() + (end() - __last));
+	}
+      return __first;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    vector<_Tp, _Alloc>&
+    vector<_Tp, _Alloc>::
+    operator=(const vector<_Tp, _Alloc>& __x)
+    {
+      if (&__x != this)
+	{
+#if __cplusplus >= 201103L
+	  if (_Alloc_traits::_S_propagate_on_copy_assign())
+	    {
+	      if (!_Alloc_traits::_S_always_equal()
+	          && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
+	        {
+		  // replacement allocator cannot free existing storage
+		  this->clear();
+		  _M_deallocate(this->_M_impl._M_start,
+				this->_M_impl._M_end_of_storage
+				- this->_M_impl._M_start);
+		  this->_M_impl._M_start = nullptr;
+		  this->_M_impl._M_finish = nullptr;
+		  this->_M_impl._M_end_of_storage = nullptr;
+		}
+	      std::__alloc_on_copy(_M_get_Tp_allocator(),
+				   __x._M_get_Tp_allocator());
+	    }
+#endif
+	  const size_type __xlen = __x.size();
+	  if (__xlen > capacity())
+	    {
+	      pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
+						   __x.end());
+	      std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+			    _M_get_Tp_allocator());
+	      _M_deallocate(this->_M_impl._M_start,
+			    this->_M_impl._M_end_of_storage
+			    - this->_M_impl._M_start);
+	      this->_M_impl._M_start = __tmp;
+	      this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
+	    }
+	  else if (size() >= __xlen)
+	    {
+	      std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
+			    end(), _M_get_Tp_allocator());
+	    }
+	  else
+	    {
+	      std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
+			this->_M_impl._M_start);
+	      std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
+					  __x._M_impl._M_finish,
+					  this->_M_impl._M_finish,
+					  _M_get_Tp_allocator());
+	    }
+	  this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
+	}
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_assign(size_t __n, const value_type& __val)
+    {
+      if (__n > capacity())
+	{
+	  vector __tmp(__n, __val, _M_get_Tp_allocator());
+	  __tmp.swap(*this);
+	}
+      else if (__n > size())
+	{
+	  std::fill(begin(), end(), __val);
+	  std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+					__n - size(), __val,
+					_M_get_Tp_allocator());
+	  this->_M_impl._M_finish += __n - size();
+	}
+      else
+        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+		    std::input_iterator_tag)
+      {
+	pointer __cur(this->_M_impl._M_start);
+	for (; __first != __last && __cur != this->_M_impl._M_finish;
+	     ++__cur, ++__first)
+	  *__cur = *__first;
+	if (__first == __last)
+	  _M_erase_at_end(__cur);
+	else
+	  insert(end(), __first, __last);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+		    std::forward_iterator_tag)
+      {
+	const size_type __len = std::distance(__first, __last);
+
+	if (__len > capacity())
+	  {
+	    pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
+	    std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+			  _M_get_Tp_allocator());
+	    _M_deallocate(this->_M_impl._M_start,
+			  this->_M_impl._M_end_of_storage
+			  - this->_M_impl._M_start);
+	    this->_M_impl._M_start = __tmp;
+	    this->_M_impl._M_finish = this->_M_impl._M_start + __len;
+	    this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
+	  }
+	else if (size() >= __len)
+	  _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
+	else
+	  {
+	    _ForwardIterator __mid = __first;
+	    std::advance(__mid, size());
+	    std::copy(__first, __mid, this->_M_impl._M_start);
+	    this->_M_impl._M_finish =
+	      std::__uninitialized_copy_a(__mid, __last,
+					  this->_M_impl._M_finish,
+					  _M_get_Tp_allocator());
+	  }
+      }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename vector<_Tp, _Alloc>::iterator
+      vector<_Tp, _Alloc>::
+      emplace(const_iterator __position, _Args&&... __args)
+      {
+	const size_type __n = __position - begin();
+	if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
+	    && __position == end())
+	  {
+	    _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+				     std::forward<_Args>(__args)...);
+	    ++this->_M_impl._M_finish;
+	  }
+	else
+	  _M_insert_aux(__position._M_const_cast(),
+			std::forward<_Args>(__args)...);
+	return iterator(this->_M_impl._M_start + __n);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_insert_aux(iterator __position, _Args&&... __args)
+#else
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_insert_aux(iterator __position, const _Tp& __x)
+#endif
+    {
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+	{
+	  _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+			           _GLIBCXX_MOVE(*(this->_M_impl._M_finish
+				                   - 1)));
+	  ++this->_M_impl._M_finish;
+#if __cplusplus < 201103L
+	  _Tp __x_copy = __x;
+#endif
+	  _GLIBCXX_MOVE_BACKWARD3(__position.base(),
+				  this->_M_impl._M_finish - 2,
+				  this->_M_impl._M_finish - 1);
+#if __cplusplus < 201103L
+	  *__position = __x_copy;
+#else
+	  *__position = _Tp(std::forward<_Args>(__args)...);
+#endif
+	}
+      else
+	{
+	  const size_type __len =
+	    _M_check_len(size_type(1), "vector::_M_insert_aux");
+	  const size_type __elems_before = __position - begin();
+	  pointer __new_start(this->_M_allocate(__len));
+	  pointer __new_finish(__new_start);
+	  __try
+	    {
+	      // The order of the three operations is dictated by the C++0x
+	      // case, where the moves could alter a new element belonging
+	      // to the existing vector.  This is an issue only for callers
+	      // taking the element by const lvalue ref (see 23.1/13).
+	      _Alloc_traits::construct(this->_M_impl,
+		                       __new_start + __elems_before,
+#if __cplusplus >= 201103L
+				       std::forward<_Args>(__args)...);
+#else
+	                               __x);
+#endif
+	      __new_finish = 0;
+
+	      __new_finish
+		= std::__uninitialized_move_if_noexcept_a
+		(this->_M_impl._M_start, __position.base(),
+		 __new_start, _M_get_Tp_allocator());
+
+	      ++__new_finish;
+
+	      __new_finish
+		= std::__uninitialized_move_if_noexcept_a
+		(__position.base(), this->_M_impl._M_finish,
+		 __new_finish, _M_get_Tp_allocator());
+	    }
+          __catch(...)
+	    {
+	      if (!__new_finish)
+		_Alloc_traits::destroy(this->_M_impl,
+		                       __new_start + __elems_before);
+	      else
+		std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+	      _M_deallocate(__new_start, __len);
+	      __throw_exception_again;
+	    }
+	  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+			_M_get_Tp_allocator());
+	  _M_deallocate(this->_M_impl._M_start,
+			this->_M_impl._M_end_of_storage
+			- this->_M_impl._M_start);
+	  this->_M_impl._M_start = __new_start;
+	  this->_M_impl._M_finish = __new_finish;
+	  this->_M_impl._M_end_of_storage = __new_start + __len;
+	}
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_emplace_back_aux(_Args&&... __args)
+      {
+	const size_type __len =
+	  _M_check_len(size_type(1), "vector::_M_emplace_back_aux");
+	pointer __new_start(this->_M_allocate(__len));
+	pointer __new_finish(__new_start);
+	__try
+	  {
+	    _Alloc_traits::construct(this->_M_impl, __new_start + size(),
+				     std::forward<_Args>(__args)...);
+	    __new_finish = 0;
+
+	    __new_finish
+	      = std::__uninitialized_move_if_noexcept_a
+	      (this->_M_impl._M_start, this->_M_impl._M_finish,
+	       __new_start, _M_get_Tp_allocator());
+
+	    ++__new_finish;
+	  }
+	__catch(...)
+	  {
+	    if (!__new_finish)
+	      _Alloc_traits::destroy(this->_M_impl, __new_start + size());
+	    else
+	      std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+	    _M_deallocate(__new_start, __len);
+	    __throw_exception_again;
+	  }
+	std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+		      _M_get_Tp_allocator());
+	_M_deallocate(this->_M_impl._M_start,
+		      this->_M_impl._M_end_of_storage
+		      - this->_M_impl._M_start);
+	this->_M_impl._M_start = __new_start;
+	this->_M_impl._M_finish = __new_finish;
+	this->_M_impl._M_end_of_storage = __new_start + __len;
+      }
+#endif
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n != 0)
+	{
+	  if (size_type(this->_M_impl._M_end_of_storage
+			- this->_M_impl._M_finish) >= __n)
+	    {
+	      value_type __x_copy = __x;
+	      const size_type __elems_after = end() - __position;
+	      pointer __old_finish(this->_M_impl._M_finish);
+	      if (__elems_after > __n)
+		{
+		  std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+					      this->_M_impl._M_finish,
+					      this->_M_impl._M_finish,
+					      _M_get_Tp_allocator());
+		  this->_M_impl._M_finish += __n;
+		  _GLIBCXX_MOVE_BACKWARD3(__position.base(),
+					  __old_finish - __n, __old_finish);
+		  std::fill(__position.base(), __position.base() + __n,
+			    __x_copy);
+		}
+	      else
+		{
+		  std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+						__n - __elems_after,
+						__x_copy,
+						_M_get_Tp_allocator());
+		  this->_M_impl._M_finish += __n - __elems_after;
+		  std::__uninitialized_move_a(__position.base(), __old_finish,
+					      this->_M_impl._M_finish,
+					      _M_get_Tp_allocator());
+		  this->_M_impl._M_finish += __elems_after;
+		  std::fill(__position.base(), __old_finish, __x_copy);
+		}
+	    }
+	  else
+	    {
+	      const size_type __len =
+		_M_check_len(__n, "vector::_M_fill_insert");
+	      const size_type __elems_before = __position - begin();
+	      pointer __new_start(this->_M_allocate(__len));
+	      pointer __new_finish(__new_start);
+	      __try
+		{
+		  // See _M_insert_aux above.
+		  std::__uninitialized_fill_n_a(__new_start + __elems_before,
+						__n, __x,
+						_M_get_Tp_allocator());
+		  __new_finish = 0;
+
+		  __new_finish
+		    = std::__uninitialized_move_if_noexcept_a
+		    (this->_M_impl._M_start, __position.base(),
+		     __new_start, _M_get_Tp_allocator());
+
+		  __new_finish += __n;
+
+		  __new_finish
+		    = std::__uninitialized_move_if_noexcept_a
+		    (__position.base(), this->_M_impl._M_finish,
+		     __new_finish, _M_get_Tp_allocator());
+		}
+	      __catch(...)
+		{
+		  if (!__new_finish)
+		    std::_Destroy(__new_start + __elems_before,
+				  __new_start + __elems_before + __n,
+				  _M_get_Tp_allocator());
+		  else
+		    std::_Destroy(__new_start, __new_finish,
+				  _M_get_Tp_allocator());
+		  _M_deallocate(__new_start, __len);
+		  __throw_exception_again;
+		}
+	      std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+			    _M_get_Tp_allocator());
+	      _M_deallocate(this->_M_impl._M_start,
+			    this->_M_impl._M_end_of_storage
+			    - this->_M_impl._M_start);
+	      this->_M_impl._M_start = __new_start;
+	      this->_M_impl._M_finish = __new_finish;
+	      this->_M_impl._M_end_of_storage = __new_start + __len;
+	    }
+	}
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      if (__n != 0)
+	{
+	  if (size_type(this->_M_impl._M_end_of_storage
+			- this->_M_impl._M_finish) >= __n)
+	    {
+	      std::__uninitialized_default_n_a(this->_M_impl._M_finish,
+					       __n, _M_get_Tp_allocator());
+	      this->_M_impl._M_finish += __n;
+	    }
+	  else
+	    {
+	      const size_type __len =
+		_M_check_len(__n, "vector::_M_default_append");
+	      const size_type __old_size = this->size();
+	      pointer __new_start(this->_M_allocate(__len));
+	      pointer __new_finish(__new_start);
+	      __try
+		{
+		  __new_finish
+		    = std::__uninitialized_move_if_noexcept_a
+		    (this->_M_impl._M_start, this->_M_impl._M_finish,
+		     __new_start, _M_get_Tp_allocator());
+		  std::__uninitialized_default_n_a(__new_finish, __n,
+						   _M_get_Tp_allocator());
+		  __new_finish += __n;
+		}
+	      __catch(...)
+		{
+		  std::_Destroy(__new_start, __new_finish,
+				_M_get_Tp_allocator());
+		  _M_deallocate(__new_start, __len);
+		  __throw_exception_again;
+		}
+	      std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+			    _M_get_Tp_allocator());
+	      _M_deallocate(this->_M_impl._M_start,
+			    this->_M_impl._M_end_of_storage
+			    - this->_M_impl._M_start);
+	      this->_M_impl._M_start = __new_start;
+	      this->_M_impl._M_finish = __new_finish;
+	      this->_M_impl._M_end_of_storage = __new_start + __len;
+	    }
+	}
+    }
+
+  template<typename _Tp, typename _Alloc>
+    bool
+    vector<_Tp, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() == size())
+	return false;
+      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
+    }
+#endif
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __pos, _InputIterator __first,
+		      _InputIterator __last, std::input_iterator_tag)
+      {
+	for (; __first != __last; ++__first)
+	  {
+	    __pos = insert(__pos, *__first);
+	    ++__pos;
+	  }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __position, _ForwardIterator __first,
+		      _ForwardIterator __last, std::forward_iterator_tag)
+      {
+	if (__first != __last)
+	  {
+	    const size_type __n = std::distance(__first, __last);
+	    if (size_type(this->_M_impl._M_end_of_storage
+			  - this->_M_impl._M_finish) >= __n)
+	      {
+		const size_type __elems_after = end() - __position;
+		pointer __old_finish(this->_M_impl._M_finish);
+		if (__elems_after > __n)
+		  {
+		    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+						this->_M_impl._M_finish,
+						this->_M_impl._M_finish,
+						_M_get_Tp_allocator());
+		    this->_M_impl._M_finish += __n;
+		    _GLIBCXX_MOVE_BACKWARD3(__position.base(),
+					    __old_finish - __n, __old_finish);
+		    std::copy(__first, __last, __position);
+		  }
+		else
+		  {
+		    _ForwardIterator __mid = __first;
+		    std::advance(__mid, __elems_after);
+		    std::__uninitialized_copy_a(__mid, __last,
+						this->_M_impl._M_finish,
+						_M_get_Tp_allocator());
+		    this->_M_impl._M_finish += __n - __elems_after;
+		    std::__uninitialized_move_a(__position.base(),
+						__old_finish,
+						this->_M_impl._M_finish,
+						_M_get_Tp_allocator());
+		    this->_M_impl._M_finish += __elems_after;
+		    std::copy(__first, __mid, __position);
+		  }
+	      }
+	    else
+	      {
+		const size_type __len =
+		  _M_check_len(__n, "vector::_M_range_insert");
+		pointer __new_start(this->_M_allocate(__len));
+		pointer __new_finish(__new_start);
+		__try
+		  {
+		    __new_finish
+		      = std::__uninitialized_move_if_noexcept_a
+		      (this->_M_impl._M_start, __position.base(),
+		       __new_start, _M_get_Tp_allocator());
+		    __new_finish
+		      = std::__uninitialized_copy_a(__first, __last,
+						    __new_finish,
+						    _M_get_Tp_allocator());
+		    __new_finish
+		      = std::__uninitialized_move_if_noexcept_a
+		      (__position.base(), this->_M_impl._M_finish,
+		       __new_finish, _M_get_Tp_allocator());
+		  }
+		__catch(...)
+		  {
+		    std::_Destroy(__new_start, __new_finish,
+				  _M_get_Tp_allocator());
+		    _M_deallocate(__new_start, __len);
+		    __throw_exception_again;
+		  }
+		std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+			      _M_get_Tp_allocator());
+		_M_deallocate(this->_M_impl._M_start,
+			      this->_M_impl._M_end_of_storage
+			      - this->_M_impl._M_start);
+		this->_M_impl._M_start = __new_start;
+		this->_M_impl._M_finish = __new_finish;
+		this->_M_impl._M_end_of_storage = __new_start + __len;
+	      }
+	  }
+      }
+
+
+  // vector<bool>
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_reallocate(size_type __n)
+    {
+      _Bit_type* __q = this->_M_allocate(__n);
+      this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
+						iterator(__q, 0));
+      this->_M_deallocate();
+      this->_M_impl._M_start = iterator(__q, 0);
+      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+    }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, bool __x)
+    {
+      if (__n == 0)
+	return;
+      if (capacity() - size() >= __n)
+	{
+	  std::copy_backward(__position, end(),
+			     this->_M_impl._M_finish + difference_type(__n));
+	  std::fill(__position, __position + difference_type(__n), __x);
+	  this->_M_impl._M_finish += difference_type(__n);
+	}
+      else
+	{
+	  const size_type __len = 
+	    _M_check_len(__n, "vector<bool>::_M_fill_insert");
+	  _Bit_type * __q = this->_M_allocate(__len);
+	  iterator __i = _M_copy_aligned(begin(), __position,
+					 iterator(__q, 0));
+	  std::fill(__i, __i + difference_type(__n), __x);
+	  this->_M_impl._M_finish = std::copy(__position, end(),
+					      __i + difference_type(__n));
+	  this->_M_deallocate();
+	  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+	  this->_M_impl._M_start = iterator(__q, 0);
+	}
+    }
+
+  template<typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<bool, _Alloc>::
+      _M_insert_range(iterator __position, _ForwardIterator __first, 
+		      _ForwardIterator __last, std::forward_iterator_tag)
+      {
+	if (__first != __last)
+	  {
+	    size_type __n = std::distance(__first, __last);
+	    if (capacity() - size() >= __n)
+	      {
+		std::copy_backward(__position, end(),
+				   this->_M_impl._M_finish
+				   + difference_type(__n));
+		std::copy(__first, __last, __position);
+		this->_M_impl._M_finish += difference_type(__n);
+	      }
+	    else
+	      {
+		const size_type __len =
+		  _M_check_len(__n, "vector<bool>::_M_insert_range");
+		_Bit_type * __q = this->_M_allocate(__len);
+		iterator __i = _M_copy_aligned(begin(), __position,
+					       iterator(__q, 0));
+		__i = std::copy(__first, __last, __i);
+		this->_M_impl._M_finish = std::copy(__position, end(), __i);
+		this->_M_deallocate();
+		this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+		this->_M_impl._M_start = iterator(__q, 0);
+	      }
+	  }
+      }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_insert_aux(iterator __position, bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+	{
+	  std::copy_backward(__position, this->_M_impl._M_finish, 
+			     this->_M_impl._M_finish + 1);
+	  *__position = __x;
+	  ++this->_M_impl._M_finish;
+	}
+      else
+	{
+	  const size_type __len =
+	    _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
+	  _Bit_type * __q = this->_M_allocate(__len);
+	  iterator __i = _M_copy_aligned(begin(), __position,
+					 iterator(__q, 0));
+	  *__i++ = __x;
+	  this->_M_impl._M_finish = std::copy(__position, end(), __i);
+	  this->_M_deallocate();
+	  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+	  this->_M_impl._M_start = iterator(__q, 0);
+	}
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+	_M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Alloc>
+    bool
+    vector<bool, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() - size() < int(_S_word_bit))
+	return false;
+      __try
+	{
+	  _M_reallocate(size());
+	  return true;
+	}
+      __catch(...)
+	{ return false; }
+    }
+#endif
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#if __cplusplus >= 201103L
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Alloc>
+    size_t
+    hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>::
+    operator()(const _GLIBCXX_STD_C::vector<bool, _Alloc>& __b) const noexcept
+    {
+      size_t __hash = 0;
+      using _GLIBCXX_STD_C::_S_word_bit;
+      using _GLIBCXX_STD_C::_Bit_type;
+
+      const size_t __words = __b.size() / _S_word_bit;
+      if (__words)
+	{
+	  const size_t __clength = __words * sizeof(_Bit_type);
+	  __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
+	}
+
+      const size_t __extrabits = __b.size() % _S_word_bit;
+      if (__extrabits)
+	{
+	  _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
+	  __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
+
+	  const size_t __clength
+	    = (__extrabits + __CHAR_BIT__ - 1) / __CHAR_BIT__;
+	  if (__words)
+	    __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
+	  else
+	    __hash = std::_Hash_impl::hash(&__hiword, __clength);
+	}
+
+      return __hash;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++11
+
+#endif /* _VECTOR_TCC */
diff --git a/gcc-4.9/libstdc++-v3/include/c/cassert b/gcc-4.9/libstdc++-v3/include/c/cassert
new file mode 100644
index 0000000..01f4473
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cassert
@@ -0,0 +1,33 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 19.2  Assertions
+//
+
+// No include guards on this header...
+
+#pragma GCC system_header
+
+#include_next <assert.h>
diff --git a/gcc-4.9/libstdc++-v3/include/c/cctype b/gcc-4.9/libstdc++-v3/include/c/cctype
new file mode 100644
index 0000000..68d2e7a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cctype
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: <ccytpe>
+//
+
+#ifndef _GLIBCXX_CCTYPE
+#define _GLIBCXX_CCTYPE 1
+
+#pragma GCC system_header
+
+#include_next <ctype.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cerrno b/gcc-4.9/libstdc++-v3/include/c/cerrno
new file mode 100644
index 0000000..9b2dde3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cerrno
@@ -0,0 +1,50 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cerrno
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the "*.h" implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c errno.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std.
+ */
+
+//
+// ISO C++ 14882: 19.3  Error numbers
+//
+
+#ifndef _GLIBCXX_CERRNO
+#define _GLIBCXX_CERRNO 1
+
+#pragma GCC system_header
+
+#include_next <errno.h>
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef errno
+#define errno errno
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cfloat b/gcc-4.9/libstdc++-v3/include/c/cfloat
new file mode 100644
index 0000000..05b3ce9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cfloat
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#ifndef _GLIBCXX_CFLOAT
+#define _GLIBCXX_CFLOAT 1
+
+#pragma GCC system_header
+
+#include_next <float.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/ciso646 b/gcc-4.9/libstdc++-v3/include/c/ciso646
new file mode 100644
index 0000000..cc28665
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/ciso646
@@ -0,0 +1,32 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ciso646
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the "*.h" implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c iso646.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std.
+ */
diff --git a/gcc-4.9/libstdc++-v3/include/c/climits b/gcc-4.9/libstdc++-v3/include/c/climits
new file mode 100644
index 0000000..61e3400
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/climits
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#ifndef _GLIBCXX_CLIMITS
+#define _GLIBCXX_CLIMITS 1
+
+#pragma GCC system_header
+
+#include_next <limits.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/clocale b/gcc-4.9/libstdc++-v3/include/c/clocale
new file mode 100644
index 0000000..4d3d5c7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/clocale
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#ifndef _GLIBCXX_CLOCALE
+#define _GLIBCXX_CLOCALE 1
+
+#pragma GCC system_header
+
+#include_next <locale.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cmath b/gcc-4.9/libstdc++-v3/include/c/cmath
new file mode 100644
index 0000000..2447aa6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cmath
@@ -0,0 +1,119 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 26.5  C library
+//
+
+#ifndef _GLIBCXX_CMATH
+#define _GLIBCXX_CMATH 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#include_next <math.h>
+
+// Get rid of those macros defined in <math.h> in lieu of real functions.
+#undef abs
+#undef div
+#undef acos
+#undef asin
+#undef atan
+#undef atan2
+#undef ceil
+#undef cos
+#undef cosh
+#undef exp
+#undef fabs
+#undef floor
+#undef fmod
+#undef frexp
+#undef ldexp
+#undef log
+#undef log10
+#undef modf
+#undef pow
+#undef sin
+#undef sinh
+#undef sqrt
+#undef tan
+#undef tanh
+
+#undef fpclassify
+#undef isfinite
+#undef isinf
+#undef isnan
+#undef isnormal
+#undef signbit
+#undef isgreater
+#undef isgreaterequal
+#undef isless
+#undef islessequal
+#undef islessgreater
+#undef isunordered
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  inline double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+
+  inline float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+#if _GLIBCXX_HAVE_MODFF
+  inline float
+  modf(float __x, float* __iptr) { return modff(__x, __iptr); }
+#else
+  inline float
+  modf(float __x, float* __iptr)
+  {
+    double __tmp;
+    double __res = modf(static_cast<double>(__x), &__tmp);
+    *__iptr = static_cast<float>(__tmp);
+    return __res;
+  }
+#endif
+
+#if _GLIBCXX_HAVE_MODFL
+  inline long double
+  modf(long double __x, long double* __iptr) { return modfl(__x, __iptr); }
+#else
+  inline long double
+  modf(long double __x, long double* __iptr)
+  {
+    double __tmp;
+    double __res = modf(static_cast<double>(__x), &__tmp);
+    * __iptr = static_cast<long double>(__tmp);
+    return __res;
+  }
+#endif
+}
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/csetjmp b/gcc-4.9/libstdc++-v3/include/c/csetjmp
new file mode 100644
index 0000000..0ee5672
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/csetjmp
@@ -0,0 +1,44 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSETJMP
+#define _GLIBCXX_CSETJMP 1
+
+#pragma GCC system_header
+
+#include_next <setjmp.h>
+
+// Get rid of those macros defined in <setjmp.h> in lieu of real functions.
+#undef longjmp
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef setjmp
+#define setjmp(env) std::setjmp (env)
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/csignal b/gcc-4.9/libstdc++-v3/include/c/csignal
new file mode 100644
index 0000000..06ec6c8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/csignal
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSIGNAL
+#define _GLIBCXX_CSIGNAL 1
+
+#pragma GCC system_header
+
+#include_next <signal.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cstdarg b/gcc-4.9/libstdc++-v3/include/c/cstdarg
new file mode 100644
index 0000000..b9cfe21
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cstdarg
@@ -0,0 +1,37 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSTDARG
+#define _GLIBCXX_CSTDARG 1
+
+#pragma GCC system_header
+
+#undef __need___va_list
+#include_next <stdarg.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cstddef b/gcc-4.9/libstdc++-v3/include/c/cstddef
new file mode 100644
index 0000000..a63f194
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cstddef
@@ -0,0 +1,40 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 18.1  Types
+//
+
+#ifndef _GLIBCXX_CSTDDEF
+#define _GLIBCXX_CSTDDEF 1
+
+#pragma GCC system_header
+
+#define __need_size_t
+#define __need_ptrdiff_t
+#define __need_NULL
+#define __need_offsetof
+#include_next <stddef.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cstdio b/gcc-4.9/libstdc++-v3/include/c/cstdio
new file mode 100644
index 0000000..f047cb2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cstdio
@@ -0,0 +1,79 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 27.8.2  C Library files
+//
+
+#ifndef _GLIBCXX_CSTDIO
+#define _GLIBCXX_CSTDIO 1
+
+#pragma GCC system_header
+
+#include_next <stdio.h>
+
+// Get rid of those macros defined in <stdio.h> in lieu of real functions.
+#undef clearerr
+#undef fclose
+#undef feof
+#undef ferror
+#undef fflush
+#undef fgetc
+#undef fgetpos
+#undef fgets
+#undef fopen
+#undef fprintf
+#undef fputc
+#undef fputs
+#undef fread
+#undef freopen
+#undef fscanf
+#undef fseek
+#undef fsetpos
+#undef ftell
+#undef fwrite
+#undef getc
+#undef getchar
+#undef gets
+#undef perror
+#undef printf
+#undef putc
+#undef putchar
+#undef puts
+#undef remove
+#undef rename
+#undef rewind
+#undef scanf
+#undef setbuf
+#undef setvbuf
+#undef sprintf
+#undef sscanf
+#undef tmpfile
+#undef tmpnam
+#undef ungetc
+#undef vfprintf
+#undef vprintf
+#undef vsprintf
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cstdlib b/gcc-4.9/libstdc++-v3/include/c/cstdlib
new file mode 100644
index 0000000..a43907e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cstdlib
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSTDLIB
+#define _GLIBCXX_CSTDLIB 1
+
+#pragma GCC system_header
+
+#include_next <stdlib.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cstring b/gcc-4.9/libstdc++-v3/include/c/cstring
new file mode 100644
index 0000000..328e197
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cstring
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSTRING
+#define _GLIBCXX_CSTRING 1
+
+#pragma GCC system_header
+
+#include_next <string.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/ctime b/gcc-4.9/libstdc++-v3/include/c/ctime
new file mode 100644
index 0000000..ed41033
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/ctime
@@ -0,0 +1,36 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 20.5  Date and time
+//
+
+#ifndef _GLIBCXX_CTIME
+#define _GLIBCXX_CTIME 1
+
+#pragma GCC system_header
+
+#include_next <time.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cwchar b/gcc-4.9/libstdc++-v3/include/c/cwchar
new file mode 100644
index 0000000..77b7454
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cwchar
@@ -0,0 +1,57 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 21.4
+//
+
+#ifndef _GLIBCXX_CWCHAR
+#define _GLIBCXX_CWCHAR 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <cstddef>
+#include <ctime>
+
+#if _GLIBCXX_HAVE_WCHAR_H
+#include_next <wchar.h>
+#endif
+
+// Need to do a bit of trickery here with mbstate_t as char_traits
+// assumes it is in wchar.h, regardless of wchar_t specializations.
+#ifndef _GLIBCXX_HAVE_MBSTATE_T
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  extern "C"
+  {
+    typedef struct
+    {
+      int __fill[6];
+    } mbstate_t;
+  }
+}
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c/cwctype b/gcc-4.9/libstdc++-v3/include/c/cwctype
new file mode 100644
index 0000000..dc8c542
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c/cwctype
@@ -0,0 +1,40 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: <cwctype>
+//
+
+#ifndef _GLIBCXX_CWCTYPE
+#define _GLIBCXX_CWCTYPE 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_WCTYPE_H
+#include_next <wctype.h>
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/assert.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/assert.h
new file mode 100644
index 0000000..d140b4d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/assert.h
@@ -0,0 +1,29 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file assert.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cassert>
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/complex.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/complex.h
new file mode 100644
index 0000000..d072b68
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/complex.h
@@ -0,0 +1,46 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file complex.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <bits/c++config.h>
+
+#if __cplusplus >= 201103L
+# include <ccomplex>
+#endif
+
+#if _GLIBCXX_HAVE_COMPLEX_H
+# include_next <complex.h>
+# ifdef _GLIBCXX_COMPLEX
+// See PR56111, keep the macro in C++03 if possible.
+#  undef complex
+# endif
+#endif
+
+#ifndef _GLIBCXX_COMPLEX_H
+#define _GLIBCXX_COMPLEX_H 1
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/ctype.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/ctype.h
new file mode 100644
index 0000000..ffcbfb7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/ctype.h
@@ -0,0 +1,50 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ctype.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cctype>
+
+#ifndef _GLIBCXX_CTYPE_H
+#define _GLIBCXX_CTYPE_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::isalnum;
+using std::isalpha;
+using std::iscntrl;
+using std::isdigit;
+using std::isgraph;
+using std::islower;
+using std::isprint;
+using std::ispunct;
+using std::isspace;
+using std::isupper;
+using std::isxdigit;
+using std::tolower;
+using std::toupper;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/errno.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/errno.h
new file mode 100644
index 0000000..fd51e77
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/errno.h
@@ -0,0 +1,34 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file errno.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cerrno>
+
+#ifndef _GLIBCXX_ERRNO_H
+#define _GLIBCXX_ERRNO_H 1
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/fenv.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/fenv.h
new file mode 100644
index 0000000..869a907
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/fenv.h
@@ -0,0 +1,81 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file fenv.h
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_FENV_H
+#define _GLIBCXX_FENV_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#if _GLIBCXX_HAVE_FENV_H
+# include_next <fenv.h>
+#endif
+
+#if __cplusplus >= 201103L
+
+#if _GLIBCXX_USE_C99_FENV_TR1
+
+#undef feclearexcept
+#undef fegetexceptflag
+#undef feraiseexcept
+#undef fesetexceptflag
+#undef fetestexcept
+#undef fegetround
+#undef fesetround
+#undef fegetenv
+#undef feholdexcept
+#undef fesetenv
+#undef feupdateenv
+
+namespace std
+{
+  // types
+  using ::fenv_t;
+  using ::fexcept_t;
+
+  // functions
+  using ::feclearexcept;
+  using ::fegetexceptflag;
+  using ::feraiseexcept;
+  using ::fesetexceptflag;
+  using ::fetestexcept;
+
+  using ::fegetround;
+  using ::fesetround;
+
+  using ::fegetenv;
+  using ::feholdexcept;
+  using ::fesetenv;
+  using ::feupdateenv;
+} // namespace
+
+#endif // _GLIBCXX_USE_C99_FENV_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_FENV_H
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/float.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/float.h
new file mode 100644
index 0000000..9e6e3be
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/float.h
@@ -0,0 +1,34 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file float.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cfloat>
+
+#ifndef _GLIBCXX_FLOAT_H
+#define _GLIBCXX_FLOAT_H 1
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/inttypes.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/inttypes.h
new file mode 100644
index 0000000..971c3c4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/inttypes.h
@@ -0,0 +1,91 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file inttypes.h
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_INTTYPES_H
+#define _GLIBCXX_INTTYPES_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if __cplusplus >= 201103L
+
+// For 8.11.1/1 (see C99, Note 184)
+# if _GLIBCXX_HAVE_INTTYPES_H
+#  ifndef __STDC_FORMAT_MACROS
+#   define _UNDEF__STDC_FORMAT_MACROS
+#   define __STDC_FORMAT_MACROS
+#  endif
+#  include_next <inttypes.h>
+#  ifdef _UNDEF__STDC_FORMAT_MACROS
+#   undef __STDC_FORMAT_MACROS
+#   undef _UNDEF__STDC_FORMAT_MACROS
+#  endif
+# endif
+
+#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1
+
+namespace std
+{
+  // types
+  using ::imaxdiv_t;
+
+  // functions
+  using ::imaxabs;
+
+  // May collide with _Longlong abs(_Longlong), and is not described
+  // anywhere outside the synopsis.  Likely, a defect.
+  //
+  // intmax_t abs(intmax_t)
+
+  using ::imaxdiv;
+
+  // Likewise, with lldiv_t div(_Longlong, _Longlong).
+  //
+  // imaxdiv_t div(intmax_t, intmax_t)
+
+  using ::strtoimax;
+  using ::strtoumax;
+
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1
+  using ::wcstoimax;
+  using ::wcstoumax;
+#endif
+} // namespace
+
+#endif _GLIBCXX_USE_C99_INTTYPES_TR1
+
+#else
+
+# if _GLIBCXX_HAVE_INTTYPES_H
+#  include_next <inttypes.h>
+# endif
+
+#endif // C++11
+
+#endif // _GLIBCXX_INTTYPES_H
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/iso646.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/iso646.h
new file mode 100644
index 0000000..81d6bc0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/iso646.h
@@ -0,0 +1,34 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file iso646.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <ciso646>
+
+#ifndef _GLIBCXX_ISO646_H
+#define _GLIBCXX_ISO646_H 1
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/limits.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/limits.h
new file mode 100644
index 0000000..a6bc105
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/limits.h
@@ -0,0 +1,34 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file limits.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <climits>
+
+#ifndef _GLIBCXX_LIMITS_H
+#define _GLIBCXX_LIMITS_H 1
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/locale.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/locale.h
new file mode 100644
index 0000000..475e21c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/locale.h
@@ -0,0 +1,40 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file locale.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <clocale>
+
+#ifndef _GLIBCXX_LOCALE_H
+#define _GLIBCXX_LOCALE_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::lconv;
+using std::setlocale;
+using std::localeconv;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/math.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/math.h
new file mode 100644
index 0000000..c6d59ba
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/math.h
@@ -0,0 +1,76 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file math.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cmath>
+
+#ifndef _GLIBCXX_MATH_H
+#define _GLIBCXX_MATH_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::abs;
+using std::acos;
+using std::asin;
+using std::atan;
+using std::atan2;
+using std::cos;
+using std::sin;
+using std::tan;
+using std::cosh;
+using std::sinh;
+using std::tanh;
+using std::exp;
+using std::frexp;
+using std::ldexp;
+using std::log;
+using std::log10;
+using std::modf;
+using std::pow;
+using std::sqrt;
+using std::ceil;
+using std::fabs;
+using std::floor;
+using std::fmod;
+
+#if _GLIBCXX_USE_C99
+using std::fpclassify;
+using std::isfinite;
+using std::isinf;
+using std::isnan;
+using std::isnormal;
+using std::signbit;
+using std::isgreater;
+using std::isgreaterequal;
+using std::isless;
+using std::islessequal;
+using std::islessgreater;
+using std::isunordered;
+#endif
+
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/setjmp.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/setjmp.h
new file mode 100644
index 0000000..b982fef
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/setjmp.h
@@ -0,0 +1,39 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file setjmp.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <csetjmp>
+
+#ifndef _GLIBCXX_SETJMP_H
+#define _GLIBCXX_SETJMP_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::jmp_buf;
+using std::longjmp;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/signal.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/signal.h
new file mode 100644
index 0000000..b134937
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/signal.h
@@ -0,0 +1,40 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file signal.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <csignal>
+
+#ifndef _GLIBCXX_SIGNAL_H
+#define _GLIBCXX_SIGNAL_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::sig_atomic_t;
+using std::raise;
+using std::signal;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/stdarg.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdarg.h
new file mode 100644
index 0000000..ed60c22
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdarg.h
@@ -0,0 +1,38 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stdarg.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cstdarg>
+
+#ifndef _GLIBCXX_STDARG_H
+#define _GLIBCXX_STDARG_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::va_list;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/stdbool.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdbool.h
new file mode 100644
index 0000000..f0f044c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdbool.h
@@ -0,0 +1,42 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stdbool.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <bits/c++config.h>
+
+#if __cplusplus >= 201103L
+# include <cstdbool>
+#else
+# if _GLIBCXX_HAVE_STDBOOL_H
+#  include_next <stdbool.h>
+# endif
+#endif
+
+#ifndef _GLIBCXX_STDBOOL_H
+#define _GLIBCXX_STDBOOL_H 1
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/stddef.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/stddef.h
new file mode 100644
index 0000000..cb2264b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/stddef.h
@@ -0,0 +1,39 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stddef.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cstddef>
+
+#ifndef _GLIBCXX_STDDEF_H
+#define _GLIBCXX_STDDEF_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::size_t;
+using std::ptrdiff_t;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/stdint.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdint.h
new file mode 100644
index 0000000..04c2b57
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdint.h
@@ -0,0 +1,110 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stdint.h
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_STDINT_H
+#define _GLIBCXX_STDINT_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if __cplusplus >= 201103L
+
+// For 8.22.1/1 (see C99, Notes 219, 220, 222)
+# if _GLIBCXX_HAVE_STDINT_H
+#  ifndef __STDC_LIMIT_MACROS
+#   define _UNDEF__STDC_LIMIT_MACROS
+#   define __STDC_LIMIT_MACROS
+#  endif
+#  ifndef __STDC_CONSTANT_MACROS
+#   define _UNDEF__STDC_CONSTANT_MACROS
+#   define __STDC_CONSTANT_MACROS
+#  endif
+#  include_next <stdint.h>
+#  ifdef _UNDEF__STDC_LIMIT_MACROS
+#   undef __STDC_LIMIT_MACROS
+#   undef _UNDEF__STDC_LIMIT_MACROS
+#  endif
+#  ifdef _UNDEF__STDC_CONSTANT_MACROS
+#   undef __STDC_CONSTANT_MACROS
+#   undef _UNDEF__STDC_CONSTANT_MACROS
+#  endif
+# endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+namespace std
+{
+  using ::int8_t;
+  using ::int16_t;
+  using ::int32_t;
+  using ::int64_t;
+
+  using ::int_fast8_t;
+  using ::int_fast16_t;
+  using ::int_fast32_t;
+  using ::int_fast64_t;
+
+  using ::int_least8_t;
+  using ::int_least16_t;
+  using ::int_least32_t;
+  using ::int_least64_t;
+
+  using ::intmax_t;
+  using ::intptr_t;
+  
+  using ::uint8_t;
+  using ::uint16_t;
+  using ::uint32_t;
+  using ::uint64_t;
+
+  using ::uint_fast8_t;
+  using ::uint_fast16_t;
+  using ::uint_fast32_t;
+  using ::uint_fast64_t;
+
+  using ::uint_least8_t;
+  using ::uint_least16_t;
+  using ::uint_least32_t;
+  using ::uint_least64_t;
+
+  using ::uintmax_t;
+  using ::uintptr_t;
+} // namespace
+
+#endif // _GLIBCXX_USE_C99_STDINT_TR1
+
+#else
+
+# if _GLIBCXX_HAVE_STDINT_H
+#  include_next <stdint.h>
+# endif
+
+#endif // C++11
+
+#endif // _GLIBCXX_STDINT_H
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/stdio.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdio.h
new file mode 100644
index 0000000..2a101e6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdio.h
@@ -0,0 +1,86 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stdio.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cstdio>
+
+#ifndef _GLIBCXX_STDIO_H
+#define _GLIBCXX_STDIO_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::FILE;
+using std::fpos_t;
+
+using std::remove;
+using std::rename;
+using std::tmpfile;
+using std::tmpnam;
+using std::fclose;
+using std::fflush;
+using std::fopen;
+using std::freopen;
+using std::setbuf;
+using std::setvbuf;
+using std::fprintf;
+using std::fscanf;
+using std::printf;
+using std::scanf;
+using std::snprintf;
+using std::sprintf;
+using std::sscanf;
+using std::vfprintf;
+using std::vfscanf;
+using std::vprintf;
+using std::vscanf;
+using std::vsnprintf;
+using std::vsprintf;
+using std::vsscanf;
+using std::fgetc;
+using std::fgets;
+using std::fputc;
+using std::fputs;
+using std::getc;
+using std::getchar;
+using std::gets;
+using std::putc;
+using std::putchar;
+using std::puts;
+using std::ungetc;
+using std::fread;
+using std::fwrite;
+using std::fgetpos;
+using std::fseek;
+using std::fsetpos;
+using std::ftell;
+using std::rewind;
+using std::clearerr;
+using std::feof;
+using std::ferror;
+using std::perror;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/stdlib.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdlib.h
new file mode 100644
index 0000000..62cf0ef
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/stdlib.h
@@ -0,0 +1,68 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stdlib.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cstdlib>
+
+#ifndef _GLIBCXX_STDLIB_H
+#define _GLIBCXX_STDLIB_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::div_t;
+using std::ldiv_t;
+
+using std::abort;
+using std::abs;
+using std::atexit;
+using std::atof;
+using std::atoi;
+using std::atol;
+using std::bsearch;
+using std::calloc;
+using std::div;
+using std::exit;
+using std::free;
+using std::getenv;
+using std::labs;
+using std::ldiv;
+using std::malloc;
+using std::mblen;
+using std::mbstowcs;
+using std::mbtowc;
+using std::qsort;
+using std::rand;
+using std::realloc;
+using std::srand;
+using std::strtod;
+using std::strtol;
+using std::strtoul;
+using std::system;
+using std::wcstombs;
+using std::wctomb;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/string.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/string.h
new file mode 100644
index 0000000..d49fb47
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/string.h
@@ -0,0 +1,59 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file string.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cstring>
+
+#ifndef _GLIBCXX_STRING_H
+#define _GLIBCXX_STRING_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::memcpy;
+using std::memmove;
+using std::strcpy;
+using std::strncpy;
+using std::strcat;
+using std::strncat;
+using std::memcmp;
+using std::strcmp;
+using std::strcoll;
+using std::strncmp;
+using std::strxfrm;
+using std::memchr;
+using std::strchr;
+using std::strcspn;
+using std::strpbrk;
+using std::strrchr;
+using std::strspn;
+using std::strstr;
+using std::strtok;
+using std::memset;
+using std::strerror;
+using std::strlen;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/tgmath.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/tgmath.h
new file mode 100644
index 0000000..aef6edd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/tgmath.h
@@ -0,0 +1,42 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tgmath.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <bits/c++config.h>
+
+#if __cplusplus >= 201103L
+# include <ctgmath>
+#else
+# if _GLIBCXX_HAVE_TGMATH_H
+#  include_next <tgmath.h>
+# endif
+#endif
+
+#ifndef _GLIBCXX_TGMATH_H
+#define _GLIBCXX_TGMATH_H 1
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/time.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/time.h
new file mode 100644
index 0000000..e241ee8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/time.h
@@ -0,0 +1,61 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file time.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <ctime>
+
+#ifndef _GLIBCXX_TIME_H
+#define _GLIBCXX_TIME_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+// Get rid of those macros defined in <time.h> in lieu of real functions.
+#undef clock
+#undef difftime
+#undef mktime
+#undef time
+#undef asctime
+#undef ctime
+#undef gmtime
+#undef localtime
+#undef strftime
+
+using std::clock_t;
+using std::time_t;
+using std::tm;
+
+using std::clock;
+using std::difftime;
+using std::mktime;
+using std::time;
+using std::asctime;
+using std::ctime;
+using std::gmtime;
+using std::localtime;
+using std::strftime;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/wchar.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/wchar.h
new file mode 100644
index 0000000..fed87f1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/wchar.h
@@ -0,0 +1,116 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file wchar.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cwchar>
+
+#ifndef _GLIBCXX_WCHAR_H
+#define _GLIBCXX_WCHAR_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::mbstate_t;
+
+#if _GLIBCXX_USE_WCHAR_T
+using std::wint_t;
+
+using std::btowc;
+using std::wctob;
+using std::fgetwc;
+using std::fgetwc;
+using std::fgetws;
+using std::fputwc;
+using std::fputws;
+using std::fwide;
+using std::fwprintf;
+using std::fwscanf;
+using std::swprintf;
+using std::swscanf;
+using std::vfwprintf;
+#if _GLIBCXX_HAVE_VFWSCANF
+using std::vfwscanf;
+#endif
+using std::vswprintf;
+#if _GLIBCXX_HAVE_VSWSCANF
+using std::vswscanf;
+#endif
+using std::vwprintf;
+#if _GLIBCXX_HAVE_VWSCANF
+using std::vwscanf;
+#endif
+using std::wprintf;
+using std::wscanf;
+using std::getwc;
+using std::getwchar;
+using std::mbsinit;
+using std::mbrlen;
+using std::mbrtowc;
+using std::mbsrtowcs;
+using std::wcsrtombs;
+using std::putwc;
+using std::putwchar;
+using std::ungetwc;
+using std::wcrtomb;
+using std::wcstod;
+#if _GLIBCXX_HAVE_WCSTOF
+using std::wcstof;
+#endif
+using std::wcstol;
+using std::wcstoul;
+using std::wcscpy;
+using std::wcsncpy;
+using std::wcscat;
+using std::wcsncat;
+using std::wcscmp;
+using std::wcscoll;
+using std::wcsncmmp;
+using std::wcsxfrm;
+using std::wcschr;
+using std::wcscspn;
+using std::wcslen;
+using std::wcspbrk;
+using std::wcsrchr;
+using std::wcsspn;
+using std::wcsstr;
+using std::wcstok;
+using std::wmemchr;
+using std::wmemcmp;
+using std::wmemcpy;
+using std::wmemmove;
+using std::wmemset;
+using std::wcsftime;
+
+#if _GLIBCXX_USE_C99
+using std::wcstold;
+using std::wcstoll;
+using std::wcstoull;
+#endif
+
+#endif  //_GLIBCXX_USE_WCHAR_T
+
+#endif 
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_compatibility/wctype.h b/gcc-4.9/libstdc++-v3/include/c_compatibility/wctype.h
new file mode 100644
index 0000000..0ced64c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_compatibility/wctype.h
@@ -0,0 +1,56 @@
+// -*- C++ -*- compatibility header.
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file wctype.h
+ *  This is a Standard C++ Library header.
+ */
+
+#include <cwctype>
+
+#ifndef _GLIBCXX_CWCTYPE_H
+#define _GLIBCXX_CWCTYPE_H 1
+
+#ifdef _GLIBCXX_NAMESPACE_C
+using std::wctype_t;
+using std::wctrans_t;
+using std::iswalpha;
+using std::iswupper;
+using std::iswlower;
+using std::iswdigit;
+using std::iswxdigit;
+using std::iswalnum;
+using std::iswspace;
+using std::iswpunct;
+using std::iswprint;
+using std::iswgraph;
+using std::iswcntrl;
+using std::iswctype;
+using std::towctrans;
+using std::towlower;
+using std::towupper;
+using std::wctrans;
+using std::wctype;
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cassert b/gcc-4.9/libstdc++-v3/include/c_global/cassert
new file mode 100644
index 0000000..5cdfa81
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cassert
@@ -0,0 +1,43 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cassert
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c assert.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 19.2  Assertions
+//
+
+// No include guards on this header...
+
+#pragma GCC system_header
+
+#include <assert.h>
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/ccomplex b/gcc-4.9/libstdc++-v3/include/c_global/ccomplex
new file mode 100644
index 0000000..2c48aaf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/ccomplex
@@ -0,0 +1,40 @@
+// <ccomplex> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/ccomplex
+ *  This is a Standard C++ Library header.
+ */
+
+#pragma GCC system_header
+
+#ifndef _GLIBCXX_CCOMPLEX
+#define _GLIBCXX_CCOMPLEX 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#endif
+
+#include <complex>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cctype b/gcc-4.9/libstdc++-v3/include/c_global/cctype
new file mode 100644
index 0000000..41bb54c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cctype
@@ -0,0 +1,94 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cctype
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c ctype.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: <ccytpe>
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <ctype.h>
+
+#ifndef _GLIBCXX_CCTYPE
+#define _GLIBCXX_CCTYPE 1
+
+// Get rid of those macros defined in <ctype.h> in lieu of real functions.
+#undef isalnum
+#undef isalpha
+#undef iscntrl
+#undef isdigit
+#undef isgraph
+#undef islower
+#undef isprint
+#undef ispunct
+#undef isspace
+#undef isupper
+#undef isxdigit
+#undef tolower
+#undef toupper
+
+namespace std
+{
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+} // namespace std
+
+#if __cplusplus >= 201103L
+
+#ifdef _GLIBCXX_USE_C99_CTYPE_TR1
+
+#undef isblank
+
+namespace std
+{
+  using ::isblank;
+} // namespace std
+
+#endif // _GLIBCXX_USE_C99_CTYPE_TR1
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cerrno b/gcc-4.9/libstdc++-v3/include/c_global/cerrno
new file mode 100644
index 0000000..81a0da1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cerrno
@@ -0,0 +1,51 @@
+// The -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cerrno
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c errno.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 19.3  Error numbers
+//
+
+#pragma GCC system_header
+
+#include <errno.h>
+
+#ifndef _GLIBCXX_CERRNO
+#define _GLIBCXX_CERRNO 1
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef errno
+#define errno errno
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cfenv b/gcc-4.9/libstdc++-v3/include/c_global/cfenv
new file mode 100644
index 0000000..a335878
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cfenv
@@ -0,0 +1,84 @@
+// <cfenv> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cfenv
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_CFENV
+#define _GLIBCXX_CFENV 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_FENV_H
+# include <fenv.h>
+#endif
+
+#ifdef _GLIBCXX_USE_C99_FENV_TR1
+
+#undef feclearexcept
+#undef fegetexceptflag
+#undef feraiseexcept
+#undef fesetexceptflag
+#undef fetestexcept
+#undef fegetround
+#undef fesetround
+#undef fegetenv
+#undef feholdexcept
+#undef fesetenv
+#undef feupdateenv
+
+namespace std
+{
+  // types
+  using ::fenv_t;
+  using ::fexcept_t;
+
+  // functions
+  using ::feclearexcept;
+  using ::fegetexceptflag;
+  using ::feraiseexcept;
+  using ::fesetexceptflag;
+  using ::fetestexcept;
+
+  using ::fegetround;
+  using ::fesetround;
+
+  using ::fegetenv;
+  using ::feholdexcept;
+  using ::fesetenv;
+  using ::feupdateenv;
+} // namespace std
+
+#endif // _GLIBCXX_USE_C99_FENV_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_CFENV
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cfloat b/gcc-4.9/libstdc++-v3/include/c_global/cfloat
new file mode 100644
index 0000000..2789400
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cfloat
@@ -0,0 +1,55 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cfloat
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c float.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#pragma GCC system_header
+
+#include <float.h>
+
+#ifndef _GLIBCXX_CFLOAT
+#define _GLIBCXX_CFLOAT 1
+
+#if __cplusplus >= 201103L
+#  ifndef DECIMAL_DIG
+#    define DECIMAL_DIG __DECIMAL_DIG__
+#  endif
+#  ifndef FLT_EVAL_METHOD
+#    define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+#  endif
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cinttypes b/gcc-4.9/libstdc++-v3/include/c_global/cinttypes
new file mode 100644
index 0000000..3b74e5a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cinttypes
@@ -0,0 +1,81 @@
+// <cinttypes> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cinttypes
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_CINTTYPES
+#define _GLIBCXX_CINTTYPES 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <cstdint>
+
+// For 27.9.2/3 (see C99, Note 184)
+#if _GLIBCXX_HAVE_INTTYPES_H
+# ifndef __STDC_FORMAT_MACROS
+#  define _UNDEF__STDC_FORMAT_MACROS
+#  define __STDC_FORMAT_MACROS
+# endif
+# include <inttypes.h>
+# ifdef _UNDEF__STDC_FORMAT_MACROS
+#  undef __STDC_FORMAT_MACROS
+#  undef _UNDEF__STDC_FORMAT_MACROS
+# endif
+#endif
+
+#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1
+
+namespace std
+{
+  // types
+  using ::imaxdiv_t;
+
+  // functions
+  using ::imaxabs;
+  using ::imaxdiv;
+
+  // GCC does not support extended integer types
+  // intmax_t abs(intmax_t)
+  // imaxdiv_t div(intmax_t, intmax_t)
+
+  using ::strtoimax;
+  using ::strtoumax;
+
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1
+  using ::wcstoimax;
+  using ::wcstoumax;
+#endif
+} // namespace std
+
+#endif // _GLIBCXX_USE_C99_INTTYPES_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_CINTTYPES
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/ciso646 b/gcc-4.9/libstdc++-v3/include/c_global/ciso646
new file mode 100644
index 0000000..748ae01
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/ciso646
@@ -0,0 +1,33 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ciso646
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c iso646.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/climits b/gcc-4.9/libstdc++-v3/include/c_global/climits
new file mode 100644
index 0000000..2d57d7a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/climits
@@ -0,0 +1,58 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/climits
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c limits.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#pragma GCC system_header
+
+#include <limits.h>
+
+#ifndef _GLIBCXX_CLIMITS
+#define _GLIBCXX_CLIMITS 1
+
+#ifndef LLONG_MIN
+#define LLONG_MIN (-__LONG_LONG_MAX__ - 1)
+#endif
+
+#ifndef LLONG_MAX
+#define LLONG_MAX __LONG_LONG_MAX__
+#endif
+
+#ifndef ULLONG_MAX
+#define ULLONG_MAX (__LONG_LONG_MAX__ * 2ULL + 1)
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/clocale b/gcc-4.9/libstdc++-v3/include/c_global/clocale
new file mode 100644
index 0000000..11fb674
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/clocale
@@ -0,0 +1,58 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file clocale
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c locale.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <locale.h>
+
+#ifndef _GLIBCXX_CLOCALE
+#define _GLIBCXX_CLOCALE 1
+
+// Get rid of those macros defined in <locale.h> in lieu of real functions.
+#undef setlocale
+#undef localeconv
+
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cmath b/gcc-4.9/libstdc++-v3/include/c_global/cmath
new file mode 100644
index 0000000..c534912
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cmath
@@ -0,0 +1,1686 @@
+// -*- C++ -*- C forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cmath
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c math.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 26.5  C library
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+#include <math.h>
+
+#ifndef _GLIBCXX_CMATH
+#define _GLIBCXX_CMATH 1
+
+// Get rid of those macros defined in <math.h> in lieu of real functions.
+#undef abs
+#undef div
+#undef acos
+#undef asin
+#undef atan
+#undef atan2
+#undef ceil
+#undef cos
+#undef cosh
+#undef exp
+#undef fabs
+#undef floor
+#undef fmod
+#undef frexp
+#undef ldexp
+#undef log
+#undef log10
+#undef modf
+#undef pow
+#undef sin
+#undef sinh
+#undef sqrt
+#undef tan
+#undef tanh
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+#endif
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    abs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::acos;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  acos(float __x)
+  { return __builtin_acosf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  acos(long double __x)
+  { return __builtin_acosl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    acos(_Tp __x)
+    { return __builtin_acos(__x); }
+
+  using ::asin;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  asin(float __x)
+  { return __builtin_asinf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  asin(long double __x)
+  { return __builtin_asinl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    asin(_Tp __x)
+    { return __builtin_asin(__x); }
+
+  using ::atan;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  atan(float __x)
+  { return __builtin_atanf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  atan(long double __x)
+  { return __builtin_atanl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    atan(_Tp __x)
+    { return __builtin_atan(__x); }
+
+  using ::atan2;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  atan2(float __y, float __x)
+  { return __builtin_atan2f(__y, __x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  atan2(long double __y, long double __x)
+  { return __builtin_atan2l(__y, __x); }
+#endif
+
+  template<typename _Tp, typename _Up>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    atan2(_Tp __y, _Up __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return atan2(__type(__y), __type(__x));
+    }
+
+  using ::ceil;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  ceil(float __x)
+  { return __builtin_ceilf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  ceil(long double __x)
+  { return __builtin_ceill(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    ceil(_Tp __x)
+    { return __builtin_ceil(__x); }
+
+  using ::cos;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  cos(float __x)
+  { return __builtin_cosf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  cos(long double __x)
+  { return __builtin_cosl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cos(_Tp __x)
+    { return __builtin_cos(__x); }
+
+  using ::cosh;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  cosh(float __x)
+  { return __builtin_coshf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  cosh(long double __x)
+  { return __builtin_coshl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cosh(_Tp __x)
+    { return __builtin_cosh(__x); }
+
+  using ::exp;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  exp(float __x)
+  { return __builtin_expf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  exp(long double __x)
+  { return __builtin_expl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    exp(_Tp __x)
+    { return __builtin_exp(__x); }
+
+  using ::fabs;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::floor;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  floor(float __x)
+  { return __builtin_floorf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  floor(long double __x)
+  { return __builtin_floorl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    floor(_Tp __x)
+    { return __builtin_floor(__x); }
+
+  using ::fmod;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  fmod(float __x, float __y)
+  { return __builtin_fmodf(__x, __y); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  fmod(long double __x, long double __y)
+  { return __builtin_fmodl(__x, __y); }
+#endif
+
+  template<typename _Tp, typename _Up>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmod(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmod(__type(__x), __type(__y));
+    }
+
+  using ::frexp;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline float
+  frexp(float __x, int* __exp)
+  { return __builtin_frexpf(__x, __exp); }
+
+  inline long double
+  frexp(long double __x, int* __exp)
+  { return __builtin_frexpl(__x, __exp); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    frexp(_Tp __x, int* __exp)
+    { return __builtin_frexp(__x, __exp); }
+
+  using ::ldexp;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  ldexp(float __x, int __exp)
+  { return __builtin_ldexpf(__x, __exp); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  ldexp(long double __x, int __exp)
+  { return __builtin_ldexpl(__x, __exp); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    ldexp(_Tp __x, int __exp)
+    { return __builtin_ldexp(__x, __exp); }
+
+  using ::log;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  log(float __x)
+  { return __builtin_logf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  log(long double __x)
+  { return __builtin_logl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    log(_Tp __x)
+    { return __builtin_log(__x); }
+
+  using ::log10;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  log10(float __x)
+  { return __builtin_log10f(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  log10(long double __x)
+  { return __builtin_log10l(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    log10(_Tp __x)
+    { return __builtin_log10(__x); }
+
+  using ::modf;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline float
+  modf(float __x, float* __iptr)
+  { return __builtin_modff(__x, __iptr); }
+
+  inline long double
+  modf(long double __x, long double* __iptr)
+  { return __builtin_modfl(__x, __iptr); }
+#endif
+
+  using ::pow;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  pow(float __x, float __y)
+  { return __builtin_powf(__x, __y); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  pow(long double __x, long double __y)
+  { return __builtin_powl(__x, __y); }
+
+#if __cplusplus < 201103L
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 550. What should the return type of pow(float,int) be?
+  inline double
+  pow(double __x, int __i)
+  { return __builtin_powi(__x, __i); }
+
+  inline float
+  pow(float __x, int __n)
+  { return __builtin_powif(__x, __n); }
+
+  inline long double
+  pow(long double __x, int __n)
+  { return __builtin_powil(__x, __n); }
+#endif
+#endif
+
+  template<typename _Tp, typename _Up>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+
+  using ::sin;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+
+  using ::sinh;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+
+  using ::sqrt;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+
+  using ::tan;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+
+  using ::tanh;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline _GLIBCXX_CONSTEXPR float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+
+  inline _GLIBCXX_CONSTEXPR long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+#endif
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if _GLIBCXX_USE_C99_MATH
+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+
+// These are possible macros imported from C99-land.
+#undef fpclassify
+#undef isfinite
+#undef isinf
+#undef isnan
+#undef isnormal
+#undef signbit
+#undef isgreater
+#undef isgreaterequal
+#undef isless
+#undef islessequal
+#undef islessgreater
+#undef isunordered
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if __cplusplus >= 201103L
+  constexpr int
+  fpclassify(float __x)
+  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+				FP_SUBNORMAL, FP_ZERO, __x); }
+
+  constexpr int
+  fpclassify(double __x)
+  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+				FP_SUBNORMAL, FP_ZERO, __x); }
+
+  constexpr int
+  fpclassify(long double __x)
+  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+				FP_SUBNORMAL, FP_ZERO, __x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              int>::__type
+    fpclassify(_Tp __x)
+    { return __x != 0 ? FP_NORMAL : FP_ZERO; }
+
+  constexpr bool
+  isfinite(float __x)
+  { return __builtin_isfinite(__x); }
+
+  constexpr bool
+  isfinite(double __x)
+  { return __builtin_isfinite(__x); }
+
+  constexpr bool
+  isfinite(long double __x)
+  { return __builtin_isfinite(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isfinite(_Tp __x)
+    { return true; }
+
+  constexpr bool
+  isinf(float __x)
+  { return __builtin_isinf(__x); }
+
+  constexpr bool
+  isinf(double __x)
+  { return __builtin_isinf(__x); }
+
+  constexpr bool
+  isinf(long double __x)
+  { return __builtin_isinf(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isinf(_Tp __x)
+    { return false; }
+
+  constexpr bool
+  isnan(float __x)
+  { return __builtin_isnan(__x); }
+
+  constexpr bool
+  isnan(double __x)
+  { return __builtin_isnan(__x); }
+
+  constexpr bool
+  isnan(long double __x)
+  { return __builtin_isnan(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnan(_Tp __x)
+    { return false; }
+
+  constexpr bool
+  isnormal(float __x)
+  { return __builtin_isnormal(__x); }
+
+  constexpr bool
+  isnormal(double __x)
+  { return __builtin_isnormal(__x); }
+
+  constexpr bool
+  isnormal(long double __x)
+  { return __builtin_isnormal(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnormal(_Tp __x)
+    { return __x != 0 ? true : false; }
+
+  // The front-end doesn't provide a type generic builtin (libstdc++/58625).
+  constexpr bool
+  signbit(float __x)
+  { return __builtin_signbitf(__x); }
+
+  constexpr bool
+  signbit(double __x)
+  { return __builtin_signbit(__x); }
+
+  constexpr bool
+  signbit(long double __x)
+  { return __builtin_signbitl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    signbit(_Tp __x)
+    { return __x < 0 ? true : false; }
+
+  constexpr bool
+  isgreater(float __x, float __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(double __x, double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(long double __x, long double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+			    && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreater(__type(__x), __type(__y));
+    }
+
+  constexpr bool
+  isgreaterequal(float __x, float __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(double __x, double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(long double __x, long double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+			    && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreaterequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreaterequal(__type(__x), __type(__y));
+    }
+
+  constexpr bool
+  isless(float __x, float __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(double __x, double __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(long double __x, long double __y)
+  { return __builtin_isless(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+			    && __is_arithmetic<_Up>::__value), bool>::__type
+    isless(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isless(__type(__x), __type(__y));
+    }
+
+  constexpr bool
+  islessequal(float __x, float __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(double __x, double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(long double __x, long double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+			    && __is_arithmetic<_Up>::__value), bool>::__type
+    islessequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessequal(__type(__x), __type(__y));
+    }
+
+  constexpr bool
+  islessgreater(float __x, float __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(double __x, double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(long double __x, long double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+			    && __is_arithmetic<_Up>::__value), bool>::__type
+    islessgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessgreater(__type(__x), __type(__y));
+    }
+
+  constexpr bool
+  isunordered(float __x, float __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(double __x, double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(long double __x, long double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+			    && __is_arithmetic<_Up>::__value), bool>::__type
+    isunordered(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isunordered(__type(__x), __type(__y));
+    }
+
+#else
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    fpclassify(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+				  FP_SUBNORMAL, FP_ZERO, __type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isfinite(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isfinite(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isinf(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isinf(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isnan(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnan(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isnormal(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnormal(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    signbit(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_signbit(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isgreaterequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isless(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isless(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    islessequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    islessgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isunordered(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isunordered(__type(__f1), __type(__f2));
+    }
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
+#endif
+
+#if __cplusplus >= 201103L
+
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+
+#undef acosh
+#undef acoshf
+#undef acoshl
+#undef asinh
+#undef asinhf
+#undef asinhl
+#undef atanh
+#undef atanhf
+#undef atanhl
+#undef cbrt
+#undef cbrtf
+#undef cbrtl
+#undef copysign
+#undef copysignf
+#undef copysignl
+#undef erf
+#undef erff
+#undef erfl
+#undef erfc
+#undef erfcf
+#undef erfcl
+#undef exp2
+#undef exp2f
+#undef exp2l
+#undef expm1
+#undef expm1f
+#undef expm1l
+#undef fdim
+#undef fdimf
+#undef fdiml
+#undef fma
+#undef fmaf
+#undef fmal
+#undef fmax
+#undef fmaxf
+#undef fmaxl
+#undef fmin
+#undef fminf
+#undef fminl
+#undef hypot
+#undef hypotf
+#undef hypotl
+#undef ilogb
+#undef ilogbf
+#undef ilogbl
+#undef lgamma
+#undef lgammaf
+#undef lgammal
+#undef llrint
+#undef llrintf
+#undef llrintl
+#undef llround
+#undef llroundf
+#undef llroundl
+#undef log1p
+#undef log1pf
+#undef log1pl
+#undef log2
+#undef log2f
+#undef log2l
+#undef logb
+#undef logbf
+#undef logbl
+#undef lrint
+#undef lrintf
+#undef lrintl
+#undef lround
+#undef lroundf
+#undef lroundl
+#undef nan
+#undef nanf
+#undef nanl
+#undef nearbyint
+#undef nearbyintf
+#undef nearbyintl
+#undef nextafter
+#undef nextafterf
+#undef nextafterl
+#undef nexttoward
+#undef nexttowardf
+#undef nexttowardl
+#undef remainder
+#undef remainderf
+#undef remainderl
+#undef remquo
+#undef remquof
+#undef remquol
+#undef rint
+#undef rintf
+#undef rintl
+#undef round
+#undef roundf
+#undef roundl
+#undef scalbln
+#undef scalblnf
+#undef scalblnl
+#undef scalbn
+#undef scalbnf
+#undef scalbnl
+#undef tgamma
+#undef tgammaf
+#undef tgammal
+#undef trunc
+#undef truncf
+#undef truncl
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // types
+  using ::double_t;
+  using ::float_t;
+
+  // functions
+  using ::acosh;
+  using ::acoshf;
+  using ::acoshl;
+
+  using ::asinh;
+  using ::asinhf;
+  using ::asinhl;
+
+  using ::atanh;
+  using ::atanhf;
+  using ::atanhl;
+
+  using ::cbrt;
+  using ::cbrtf;
+  using ::cbrtl;
+
+  using ::copysign;
+  using ::copysignf;
+  using ::copysignl;
+
+  using ::erf;
+  using ::erff;
+  using ::erfl;
+
+  using ::erfc;
+  using ::erfcf;
+  using ::erfcl;
+
+  using ::exp2;
+  using ::exp2f;
+  using ::exp2l;
+
+  using ::expm1;
+  using ::expm1f;
+  using ::expm1l;
+
+  using ::fdim;
+  using ::fdimf;
+  using ::fdiml;
+
+  using ::fma;
+  using ::fmaf;
+  using ::fmal;
+
+  using ::fmax;
+  using ::fmaxf;
+  using ::fmaxl;
+
+  using ::fmin;
+  using ::fminf;
+  using ::fminl;
+
+  using ::hypot;
+  using ::hypotf;
+  using ::hypotl;
+
+  using ::ilogb;
+  using ::ilogbf;
+  using ::ilogbl;
+
+  using ::lgamma;
+  using ::lgammaf;
+  using ::lgammal;
+
+  using ::llrint;
+  using ::llrintf;
+  using ::llrintl;
+
+  using ::llround;
+  using ::llroundf;
+  using ::llroundl;
+
+  using ::log1p;
+  using ::log1pf;
+  using ::log1pl;
+
+  using ::log2;
+  using ::log2f;
+  using ::log2l;
+
+  using ::logb;
+  using ::logbf;
+  using ::logbl;
+
+  using ::lrint;
+  using ::lrintf;
+  using ::lrintl;
+
+  using ::lround;
+  using ::lroundf;
+  using ::lroundl;
+
+  using ::nan;
+  using ::nanf;
+  using ::nanl;
+
+  using ::nearbyint;
+  using ::nearbyintf;
+  using ::nearbyintl;
+
+  using ::nextafter;
+  using ::nextafterf;
+  using ::nextafterl;
+
+  using ::nexttoward;
+  using ::nexttowardf;
+  using ::nexttowardl;
+
+  using ::remainder;
+  using ::remainderf;
+  using ::remainderl;
+
+  using ::remquo;
+  using ::remquof;
+  using ::remquol;
+
+  using ::rint;
+  using ::rintf;
+  using ::rintl;
+
+  using ::round;
+  using ::roundf;
+  using ::roundl;
+
+  using ::scalbln;
+  using ::scalblnf;
+  using ::scalblnl;
+
+  using ::scalbn;
+  using ::scalbnf;
+  using ::scalbnl;
+
+  using ::tgamma;
+  using ::tgammaf;
+  using ::tgammal;
+
+  using ::trunc;
+  using ::truncf;
+  using ::truncl;
+
+  /// Additional overloads.
+  constexpr float
+  acosh(float __x)
+  { return __builtin_acoshf(__x); }
+
+  constexpr long double
+  acosh(long double __x)
+  { return __builtin_acoshl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    acosh(_Tp __x)
+    { return __builtin_acosh(__x); }
+
+  constexpr float
+  asinh(float __x)
+  { return __builtin_asinhf(__x); }
+
+  constexpr long double
+  asinh(long double __x)
+  { return __builtin_asinhl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    asinh(_Tp __x)
+    { return __builtin_asinh(__x); }
+
+  constexpr float
+  atanh(float __x)
+  { return __builtin_atanhf(__x); }
+
+  constexpr long double
+  atanh(long double __x)
+  { return __builtin_atanhl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    atanh(_Tp __x)
+    { return __builtin_atanh(__x); }
+
+  constexpr float
+  cbrt(float __x)
+  { return __builtin_cbrtf(__x); }
+
+  constexpr long double
+  cbrt(long double __x)
+  { return __builtin_cbrtl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    cbrt(_Tp __x)
+    { return __builtin_cbrt(__x); }
+
+  constexpr float
+  copysign(float __x, float __y)
+  { return __builtin_copysignf(__x, __y); }
+
+  constexpr long double
+  copysign(long double __x, long double __y)
+  { return __builtin_copysignl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    copysign(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return copysign(__type(__x), __type(__y));
+    }
+
+  constexpr float
+  erf(float __x)
+  { return __builtin_erff(__x); }
+
+  constexpr long double
+  erf(long double __x)
+  { return __builtin_erfl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    erf(_Tp __x)
+    { return __builtin_erf(__x); }
+
+  constexpr float
+  erfc(float __x)
+  { return __builtin_erfcf(__x); }
+
+  constexpr long double
+  erfc(long double __x)
+  { return __builtin_erfcl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    erfc(_Tp __x)
+    { return __builtin_erfc(__x); }
+
+  constexpr float
+  exp2(float __x)
+  { return __builtin_exp2f(__x); }
+
+  constexpr long double
+  exp2(long double __x)
+  { return __builtin_exp2l(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    exp2(_Tp __x)
+    { return __builtin_exp2(__x); }
+
+  constexpr float
+  expm1(float __x)
+  { return __builtin_expm1f(__x); }
+
+  constexpr long double
+  expm1(long double __x)
+  { return __builtin_expm1l(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    expm1(_Tp __x)
+    { return __builtin_expm1(__x); }
+
+  constexpr float
+  fdim(float __x, float __y)
+  { return __builtin_fdimf(__x, __y); }
+
+  constexpr long double
+  fdim(long double __x, long double __y)
+  { return __builtin_fdiml(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fdim(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fdim(__type(__x), __type(__y));
+    }
+
+  constexpr float
+  fma(float __x, float __y, float __z)
+  { return __builtin_fmaf(__x, __y, __z); }
+
+  constexpr long double
+  fma(long double __x, long double __y, long double __z)
+  { return __builtin_fmal(__x, __y, __z); }
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    fma(_Tp __x, _Up __y, _Vp __z)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+      return fma(__type(__x), __type(__y), __type(__z));
+    }
+
+  constexpr float
+  fmax(float __x, float __y)
+  { return __builtin_fmaxf(__x, __y); }
+
+  constexpr long double
+  fmax(long double __x, long double __y)
+  { return __builtin_fmaxl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmax(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmax(__type(__x), __type(__y));
+    }
+
+  constexpr float
+  fmin(float __x, float __y)
+  { return __builtin_fminf(__x, __y); }
+
+  constexpr long double
+  fmin(long double __x, long double __y)
+  { return __builtin_fminl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmin(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmin(__type(__x), __type(__y));
+    }
+
+  constexpr float
+  hypot(float __x, float __y)
+  { return __builtin_hypotf(__x, __y); }
+
+  constexpr long double
+  hypot(long double __x, long double __y)
+  { return __builtin_hypotl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    hypot(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return hypot(__type(__x), __type(__y));
+    }
+
+  constexpr int
+  ilogb(float __x)
+  { return __builtin_ilogbf(__x); }
+
+  constexpr int
+  ilogb(long double __x)
+  { return __builtin_ilogbl(__x); }
+
+  template<typename _Tp>
+    constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                    int>::__type
+    ilogb(_Tp __x)
+    { return __builtin_ilogb(__x); }
+
+  constexpr float
+  lgamma(float __x)
+  { return __builtin_lgammaf(__x); }
+
+  constexpr long double
+  lgamma(long double __x)
+  { return __builtin_lgammal(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    lgamma(_Tp __x)
+    { return __builtin_lgamma(__x); }
+
+  constexpr long long
+  llrint(float __x)
+  { return __builtin_llrintf(__x); }
+
+  constexpr long long
+  llrint(long double __x)
+  { return __builtin_llrintl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              long long>::__type
+    llrint(_Tp __x)
+    { return __builtin_llrint(__x); }
+
+  constexpr long long
+  llround(float __x)
+  { return __builtin_llroundf(__x); }
+
+  constexpr long long
+  llround(long double __x)
+  { return __builtin_llroundl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              long long>::__type
+    llround(_Tp __x)
+    { return __builtin_llround(__x); }
+
+  constexpr float
+  log1p(float __x)
+  { return __builtin_log1pf(__x); }
+
+  constexpr long double
+  log1p(long double __x)
+  { return __builtin_log1pl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    log1p(_Tp __x)
+    { return __builtin_log1p(__x); }
+
+  // DR 568.
+  constexpr float
+  log2(float __x)
+  { return __builtin_log2f(__x); }
+
+  constexpr long double
+  log2(long double __x)
+  { return __builtin_log2l(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    log2(_Tp __x)
+    { return __builtin_log2(__x); }
+
+  constexpr float
+  logb(float __x)
+  { return __builtin_logbf(__x); }
+
+  constexpr long double
+  logb(long double __x)
+  { return __builtin_logbl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    logb(_Tp __x)
+    { return __builtin_logb(__x); }
+
+  constexpr long
+  lrint(float __x)
+  { return __builtin_lrintf(__x); }
+
+  constexpr long
+  lrint(long double __x)
+  { return __builtin_lrintl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              long>::__type
+    lrint(_Tp __x)
+    { return __builtin_lrint(__x); }
+
+  constexpr long
+  lround(float __x)
+  { return __builtin_lroundf(__x); }
+
+  constexpr long
+  lround(long double __x)
+  { return __builtin_lroundl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              long>::__type
+    lround(_Tp __x)
+    { return __builtin_lround(__x); }
+
+  constexpr float
+  nearbyint(float __x)
+  { return __builtin_nearbyintf(__x); }
+
+  constexpr long double
+  nearbyint(long double __x)
+  { return __builtin_nearbyintl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    nearbyint(_Tp __x)
+    { return __builtin_nearbyint(__x); }
+
+  constexpr float
+  nextafter(float __x, float __y)
+  { return __builtin_nextafterf(__x, __y); }
+
+  constexpr long double
+  nextafter(long double __x, long double __y)
+  { return __builtin_nextafterl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    nextafter(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return nextafter(__type(__x), __type(__y));
+    }
+
+  constexpr float
+  nexttoward(float __x, long double __y)
+  { return __builtin_nexttowardf(__x, __y); }
+
+  constexpr long double
+  nexttoward(long double __x, long double __y)
+  { return __builtin_nexttowardl(__x, __y); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    nexttoward(_Tp __x, long double __y)
+    { return __builtin_nexttoward(__x, __y); }
+
+  constexpr float
+  remainder(float __x, float __y)
+  { return __builtin_remainderf(__x, __y); }
+
+  constexpr long double
+  remainder(long double __x, long double __y)
+  { return __builtin_remainderl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remainder(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remainder(__type(__x), __type(__y));
+    }
+
+  inline float
+  remquo(float __x, float __y, int* __pquo)
+  { return __builtin_remquof(__x, __y, __pquo); }
+
+  inline long double
+  remquo(long double __x, long double __y, int* __pquo)
+  { return __builtin_remquol(__x, __y, __pquo); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remquo(_Tp __x, _Up __y, int* __pquo)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remquo(__type(__x), __type(__y), __pquo);
+    }
+
+  constexpr float
+  rint(float __x)
+  { return __builtin_rintf(__x); }
+
+  constexpr long double
+  rint(long double __x)
+  { return __builtin_rintl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    rint(_Tp __x)
+    { return __builtin_rint(__x); }
+
+  constexpr float
+  round(float __x)
+  { return __builtin_roundf(__x); }
+
+  constexpr long double
+  round(long double __x)
+  { return __builtin_roundl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    round(_Tp __x)
+    { return __builtin_round(__x); }
+
+  constexpr float
+  scalbln(float __x, long __ex)
+  { return __builtin_scalblnf(__x, __ex); }
+
+  constexpr long double
+  scalbln(long double __x, long __ex)
+  { return __builtin_scalblnl(__x, __ex); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    scalbln(_Tp __x, long __ex)
+    { return __builtin_scalbln(__x, __ex); }
+ 
+  constexpr float
+  scalbn(float __x, int __ex)
+  { return __builtin_scalbnf(__x, __ex); }
+
+  constexpr long double
+  scalbn(long double __x, int __ex)
+  { return __builtin_scalbnl(__x, __ex); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    scalbn(_Tp __x, int __ex)
+    { return __builtin_scalbn(__x, __ex); }
+
+  constexpr float
+  tgamma(float __x)
+  { return __builtin_tgammaf(__x); }
+
+  constexpr long double
+  tgamma(long double __x)
+  { return __builtin_tgammal(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    tgamma(_Tp __x)
+    { return __builtin_tgamma(__x); }
+ 
+  constexpr float
+  trunc(float __x)
+  { return __builtin_truncf(__x); }
+
+  constexpr long double
+  trunc(long double __x)
+  { return __builtin_truncl(__x); }
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+                                              double>::__type
+    trunc(_Tp __x)
+    { return __builtin_trunc(__x); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _GLIBCXX_USE_C99_MATH_TR1
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/csetjmp b/gcc-4.9/libstdc++-v3/include/c_global/csetjmp
new file mode 100644
index 0000000..f36d068
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/csetjmp
@@ -0,0 +1,61 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file csetjmp
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c setjmp.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <setjmp.h>
+
+#ifndef _GLIBCXX_CSETJMP
+#define _GLIBCXX_CSETJMP 1
+
+// Get rid of those macros defined in <setjmp.h> in lieu of real functions.
+#undef longjmp
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef setjmp
+#define setjmp(env) setjmp (env)
+#endif
+
+namespace std
+{
+  using ::jmp_buf;
+  using ::longjmp;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/csignal b/gcc-4.9/libstdc++-v3/include/c_global/csignal
new file mode 100644
index 0000000..f05a210
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/csignal
@@ -0,0 +1,57 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file csignal
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c signal.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <signal.h>
+
+#ifndef _GLIBCXX_CSIGNAL
+#define _GLIBCXX_CSIGNAL 1
+
+// Get rid of those macros defined in <signal.h> in lieu of real functions.
+#undef raise
+
+namespace std
+{
+  using ::sig_atomic_t;
+  using ::signal;
+  using ::raise;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstdalign b/gcc-4.9/libstdc++-v3/include/c_global/cstdalign
new file mode 100644
index 0000000..d2fff63
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstdalign
@@ -0,0 +1,44 @@
+// <cstdalign> -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdalign
+ *  This is a Standard C++ Library header.
+ */
+
+#pragma GCC system_header
+
+#ifndef _GLIBCXX_CSTDALIGN
+#define _GLIBCXX_CSTDALIGN 1
+
+#if __cplusplus < 201103L
+#  include <bits/c++0x_warning.h>
+#else
+#  include <bits/c++config.h>
+#  if _GLIBCXX_HAVE_STDALIGN_H
+#    include <stdalign.h>
+#  endif
+#endif
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstdarg b/gcc-4.9/libstdc++-v3/include/c_global/cstdarg
new file mode 100644
index 0000000..d2c69b3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstdarg
@@ -0,0 +1,57 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdarg
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stdarg.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <stdarg.h>
+
+#ifndef _GLIBCXX_CSTDARG
+#define _GLIBCXX_CSTDARG 1
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef va_end
+#define va_end(ap) va_end (ap)
+#endif
+
+namespace std
+{
+  using ::va_list;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstdbool b/gcc-4.9/libstdc++-v3/include/c_global/cstdbool
new file mode 100644
index 0000000..1b06435
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstdbool
@@ -0,0 +1,44 @@
+// <cstdbool> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdbool
+ *  This is a Standard C++ Library header.
+ */
+
+#pragma GCC system_header
+
+#ifndef _GLIBCXX_CSTDBOOL
+#define _GLIBCXX_CSTDBOOL 1
+
+#if __cplusplus < 201103L
+#  include <bits/c++0x_warning.h>
+#else
+#  include <bits/c++config.h>
+#  if _GLIBCXX_HAVE_STDBOOL_H
+#    include <stdbool.h>
+#  endif
+#endif
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstddef b/gcc-4.9/libstdc++-v3/include/c_global/cstddef
new file mode 100644
index 0000000..1a87dd6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstddef
@@ -0,0 +1,55 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cstddef
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stddef.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.1  Types
+//
+
+#ifndef _GLIBCXX_CSTDDEF
+#define _GLIBCXX_CSTDDEF 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <stddef.h>
+
+#if __cplusplus >= 201103L
+namespace std
+{
+  // We handle size_t, ptrdiff_t, and nullptr_t in c++config.h.
+  using ::max_align_t;
+}
+#endif
+
+#endif // _GLIBCXX_CSTDDEF
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstdint b/gcc-4.9/libstdc++-v3/include/c_global/cstdint
new file mode 100644
index 0000000..7fa0d1b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstdint
@@ -0,0 +1,89 @@
+// <cstdint> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdint
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_CSTDINT
+#define _GLIBCXX_CSTDINT 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_STDINT_H
+# include <stdint.h>
+#endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+namespace std
+{
+  using ::int8_t;
+  using ::int16_t;
+  using ::int32_t;
+  using ::int64_t;
+
+  using ::int_fast8_t;
+  using ::int_fast16_t;
+  using ::int_fast32_t;
+  using ::int_fast64_t;
+
+  using ::int_least8_t;
+  using ::int_least16_t;
+  using ::int_least32_t;
+  using ::int_least64_t;
+
+  using ::intmax_t;
+  using ::intptr_t;
+  
+  using ::uint8_t;
+  using ::uint16_t;
+  using ::uint32_t;
+  using ::uint64_t;
+
+  using ::uint_fast8_t;
+  using ::uint_fast16_t;
+  using ::uint_fast32_t;
+  using ::uint_fast64_t;
+
+  using ::uint_least8_t;
+  using ::uint_least16_t;
+  using ::uint_least32_t;
+  using ::uint_least64_t;
+
+  using ::uintmax_t;
+  using ::uintptr_t;
+} // namespace std
+
+#endif // _GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_CSTDINT
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstdio b/gcc-4.9/libstdc++-v3/include/c_global/cstdio
new file mode 100644
index 0000000..6043b3d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstdio
@@ -0,0 +1,194 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdio
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stdio.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 27.8.2  C Library files
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <stdio.h>
+
+#ifndef _GLIBCXX_CSTDIO
+#define _GLIBCXX_CSTDIO 1
+
+#ifndef _GLIBCXX_HAVE_GETS
+extern "C" char* gets (char* __s) __attribute__((deprecated));
+#endif
+
+// Get rid of those macros defined in <stdio.h> in lieu of real functions.
+#undef clearerr
+#undef fclose
+#undef feof
+#undef ferror
+#undef fflush
+#undef fgetc
+#undef fgetpos
+#undef fgets
+#undef fopen
+#undef fprintf
+#undef fputc
+#undef fputs
+#undef fread
+#undef freopen
+#undef fscanf
+#undef fseek
+#undef fsetpos
+#undef ftell
+#undef fwrite
+#undef getc
+#undef getchar
+#if __cplusplus <= 201103L
+# undef gets
+#endif
+#undef perror
+#undef printf
+#undef putc
+#undef putchar
+#undef puts
+#undef remove
+#undef rename
+#undef rewind
+#undef scanf
+#undef setbuf
+#undef setvbuf
+#undef sprintf
+#undef sscanf
+#undef tmpfile
+#undef tmpnam
+#undef ungetc
+#undef vfprintf
+#undef vprintf
+#undef vsprintf
+
+namespace std
+{
+  using ::FILE;
+  using ::fpos_t;
+
+  using ::clearerr;
+  using ::fclose;
+  using ::feof;
+  using ::ferror;
+  using ::fflush;
+  using ::fgetc;
+  using ::fgetpos;
+  using ::fgets;
+  using ::fopen;
+  using ::fprintf;
+  using ::fputc;
+  using ::fputs;
+  using ::fread;
+  using ::freopen;
+  using ::fscanf;
+  using ::fseek;
+  using ::fsetpos;
+  using ::ftell;
+  using ::fwrite;
+  using ::getc;
+  using ::getchar;
+#if __cplusplus <= 201103L
+  // LWG 2249
+  using ::gets;
+#endif
+  using ::perror;
+  using ::printf;
+  using ::putc;
+  using ::putchar;
+  using ::puts;
+  using ::remove;
+  using ::rename;
+  using ::rewind;
+  using ::scanf;
+  using ::setbuf;
+  using ::setvbuf;
+  using ::sprintf;
+  using ::sscanf;
+  using ::tmpfile;
+#if _GLIBCXX_USE_TMPNAM
+  using ::tmpnam;
+#endif
+  using ::ungetc;
+  using ::vfprintf;
+  using ::vprintf;
+  using ::vsprintf;
+} // namespace
+
+#if _GLIBCXX_USE_C99
+
+#undef snprintf
+#undef vfscanf
+#undef vscanf
+#undef vsnprintf
+#undef vsscanf
+
+namespace __gnu_cxx
+{
+#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
+  extern "C" int
+  (snprintf)(char * __restrict, std::size_t, const char * __restrict, ...)
+  throw ();
+  extern "C" int
+  (vfscanf)(FILE * __restrict, const char * __restrict, __gnuc_va_list);
+  extern "C" int (vscanf)(const char * __restrict, __gnuc_va_list);
+  extern "C" int
+  (vsnprintf)(char * __restrict, std::size_t, const char * __restrict,
+	      __gnuc_va_list) throw ();
+  extern "C" int
+  (vsscanf)(const char * __restrict, const char * __restrict, __gnuc_va_list)
+  throw ();
+#endif
+
+#if !_GLIBCXX_USE_C99_DYNAMIC
+  using ::snprintf;
+  using ::vfscanf;
+  using ::vscanf;
+  using ::vsnprintf;
+  using ::vsscanf;
+#endif
+} // namespace __gnu_cxx
+
+namespace std
+{
+  using ::__gnu_cxx::snprintf;
+  using ::__gnu_cxx::vfscanf;
+  using ::__gnu_cxx::vscanf;
+  using ::__gnu_cxx::vsnprintf;
+  using ::__gnu_cxx::vsscanf;
+} // namespace std
+
+#endif // _GLIBCXX_USE_C99
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstdlib b/gcc-4.9/libstdc++-v3/include/c_global/cstdlib
new file mode 100644
index 0000000..e98a726
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstdlib
@@ -0,0 +1,260 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdlib
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stdlib.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#ifndef _GLIBCXX_CSTDLIB
+#define _GLIBCXX_CSTDLIB 1
+
+#if !_GLIBCXX_HOSTED
+// The C standard does not require a freestanding implementation to
+// provide <stdlib.h>.  However, the C++ standard does still require
+// <cstdlib> -- but only the functionality mentioned in
+// [lib.support.start.term].
+
+#define EXIT_SUCCESS 0
+#define EXIT_FAILURE 1
+
+namespace std
+{
+  extern "C" void abort(void) throw () _GLIBCXX_NORETURN;
+  extern "C" int atexit(void (*)(void)) throw ();
+  extern "C" void exit(int) throw () _GLIBCXX_NORETURN;
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT
+  extern "C" int at_quick_exit(void (*)(void)) throw ();
+# endif
+# ifdef _GLIBCXX_HAVE_QUICK_EXIT
+  extern "C" void quick_exit(int) throw() _GLIBCXX_NORETURN;
+# endif
+#endif
+} // namespace std
+
+#else
+
+#include <stdlib.h>
+
+// Get rid of those macros defined in <stdlib.h> in lieu of real functions.
+#undef abort
+#undef abs
+#undef atexit
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT
+#  undef at_quick_exit
+# endif
+#endif
+#undef atof
+#undef atoi
+#undef atol
+#undef bsearch
+#undef calloc
+#undef div
+#undef exit
+#undef free
+#undef getenv
+#undef labs
+#undef ldiv
+#undef malloc
+#undef mblen
+#undef mbstowcs
+#undef mbtowc
+#undef qsort
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_QUICK_EXIT
+#  undef quick_exit
+# endif
+#endif
+#undef rand
+#undef realloc
+#undef srand
+#undef strtod
+#undef strtol
+#undef strtoul
+#undef system
+#undef wcstombs
+#undef wctomb
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using ::div_t;
+  using ::ldiv_t;
+
+  using ::abort;
+  using ::abs;
+  using ::atexit;
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT
+  using ::at_quick_exit;
+# endif
+#endif
+  using ::atof;
+  using ::atoi;
+  using ::atol;
+  using ::bsearch;
+  using ::calloc;
+  using ::div;
+  using ::exit;
+  using ::free;
+  using ::getenv;
+  using ::labs;
+  using ::ldiv;
+  using ::malloc;
+#ifdef _GLIBCXX_HAVE_MBSTATE_T
+  using ::mblen;
+  using ::mbstowcs;
+  using ::mbtowc;
+#endif // _GLIBCXX_HAVE_MBSTATE_T
+  using ::qsort;
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_QUICK_EXIT
+  using ::quick_exit;
+# endif
+#endif
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  using ::wcstombs;
+  using ::wctomb;
+#endif // _GLIBCXX_USE_WCHAR_T
+
+#ifndef __CORRECT_ISO_CPP_STDLIB_H_PROTO
+  inline long
+  abs(long __i) { return __builtin_labs(__i); }
+
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+#endif
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+  inline long long
+  abs(long long __x) { return __builtin_llabs (__x); }
+#endif
+
+#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
+  inline __int128
+  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if _GLIBCXX_USE_C99
+
+#undef _Exit
+#undef llabs
+#undef lldiv
+#undef atoll
+#undef strtoll
+#undef strtoull
+#undef strtof
+#undef strtold
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::lldiv_t;
+#endif
+#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
+  extern "C" void (_Exit)(int) throw () _GLIBCXX_NORETURN;
+#endif
+#if !_GLIBCXX_USE_C99_DYNAMIC
+  using ::_Exit;
+#endif
+
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::llabs;
+
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+
+  using ::lldiv;
+#endif
+
+#if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  extern "C" long long int (atoll)(const char *) throw ();
+  extern "C" long long int
+    (strtoll)(const char * __restrict, char ** __restrict, int) throw ();
+  extern "C" unsigned long long int
+    (strtoull)(const char * __restrict, char ** __restrict, int) throw ();
+#endif
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+#endif
+  using ::strtof;
+  using ::strtold;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
+
+namespace std
+{
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::__gnu_cxx::lldiv_t;
+#endif
+  using ::__gnu_cxx::_Exit;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+#endif
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+} // namespace std
+
+#endif // _GLIBCXX_USE_C99
+
+#endif // !_GLIBCXX_HOSTED
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cstring b/gcc-4.9/libstdc++-v3/include/c_global/cstring
new file mode 100644
index 0000000..7974273
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cstring
@@ -0,0 +1,123 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cstring
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c string.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <string.h>
+
+#ifndef _GLIBCXX_CSTRING
+#define _GLIBCXX_CSTRING 1
+
+// Get rid of those macros defined in <string.h> in lieu of real functions.
+#undef memchr
+#undef memcmp
+#undef memcpy
+#undef memmove
+#undef memset
+#undef strcat
+#undef strchr
+#undef strcmp
+#undef strcoll
+#undef strcpy
+#undef strcspn
+#undef strerror
+#undef strlen
+#undef strncat
+#undef strncmp
+#undef strncpy
+#undef strpbrk
+#undef strrchr
+#undef strspn
+#undef strstr
+#undef strtok
+#undef strxfrm
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using ::memchr;
+  using ::memcmp;
+  using ::memcpy;
+  using ::memmove;
+  using ::memset;
+  using ::strcat;
+  using ::strcmp;
+  using ::strcoll;
+  using ::strcpy;
+  using ::strcspn;
+  using ::strerror;
+  using ::strlen;
+  using ::strncat;
+  using ::strncmp;
+  using ::strncpy;
+  using ::strspn;
+  using ::strtok;
+  using ::strxfrm;
+  using ::strchr;
+  using ::strpbrk;
+  using ::strrchr;
+  using ::strstr;
+
+#ifndef __CORRECT_ISO_CPP_STRING_H_PROTO
+  inline void*
+  memchr(void* __s, int __c, size_t __n)
+  { return __builtin_memchr(__s, __c, __n); }
+
+  inline char*
+  strchr(char* __s, int __n)
+  { return __builtin_strchr(__s, __n); }
+
+  inline char*
+  strpbrk(char* __s1, const char* __s2)
+  { return __builtin_strpbrk(__s1, __s2); }
+
+  inline char*
+  strrchr(char* __s, int __n)
+  { return __builtin_strrchr(__s, __n); }
+
+  inline char*
+  strstr(char* __s1, const char* __s2)
+  { return __builtin_strstr(__s1, __s2); }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/ctgmath b/gcc-4.9/libstdc++-v3/include/c_global/ctgmath
new file mode 100644
index 0000000..df36263
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/ctgmath
@@ -0,0 +1,41 @@
+// <ctgmath> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/ctgmath
+ *  This is a Standard C++ Library header.
+ */
+
+#pragma GCC system_header
+
+#ifndef _GLIBCXX_CTGMATH
+#define _GLIBCXX_CTGMATH 1
+
+#if __cplusplus < 201103L
+#  include <bits/c++0x_warning.h>
+#else
+#  include <cmath>
+#endif
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/ctime b/gcc-4.9/libstdc++-v3/include/c_global/ctime
new file mode 100644
index 0000000..29ac896
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/ctime
@@ -0,0 +1,75 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/ctime
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c time.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.5  Date and time
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <time.h>
+
+#ifndef _GLIBCXX_CTIME
+#define _GLIBCXX_CTIME 1
+
+// Get rid of those macros defined in <time.h> in lieu of real functions.
+#undef clock
+#undef difftime
+#undef mktime
+#undef time
+#undef asctime
+#undef ctime
+#undef gmtime
+#undef localtime
+#undef strftime
+
+namespace std
+{
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+
+  using ::clock;
+  using ::difftime;
+  using ::mktime;
+  using ::time;
+  using ::asctime;
+  using ::ctime;
+  using ::gmtime;
+  using ::localtime;
+  using ::strftime;
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cwchar b/gcc-4.9/libstdc++-v3/include/c_global/cwchar
new file mode 100644
index 0000000..c2ff50d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cwchar
@@ -0,0 +1,303 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cwchar
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c wchar.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 21.4
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_WCHAR_H
+#include <wchar.h>
+#endif
+
+#ifndef _GLIBCXX_CWCHAR
+#define _GLIBCXX_CWCHAR 1
+
+// Need to do a bit of trickery here with mbstate_t as char_traits
+// assumes it is in wchar.h, regardless of wchar_t specializations.
+#ifndef _GLIBCXX_HAVE_MBSTATE_T
+extern "C"
+{
+  typedef struct
+  {
+    int __fill[6];
+  } mbstate_t;
+}
+#endif
+
+namespace std
+{
+  using ::mbstate_t;
+} // namespace std
+
+// Get rid of those macros defined in <wchar.h> in lieu of real functions.
+#undef btowc
+#undef fgetwc
+#undef fgetws
+#undef fputwc
+#undef fputws
+#undef fwide
+#undef fwprintf
+#undef fwscanf
+#undef getwc
+#undef getwchar
+#undef mbrlen
+#undef mbrtowc
+#undef mbsinit
+#undef mbsrtowcs
+#undef putwc
+#undef putwchar
+#undef swprintf
+#undef swscanf
+#undef ungetwc
+#undef vfwprintf
+#if _GLIBCXX_HAVE_VFWSCANF
+# undef vfwscanf
+#endif
+#undef vswprintf
+#if _GLIBCXX_HAVE_VSWSCANF
+# undef vswscanf
+#endif
+#undef vwprintf
+#if _GLIBCXX_HAVE_VWSCANF
+# undef vwscanf
+#endif
+#undef wcrtomb
+#undef wcscat
+#undef wcschr
+#undef wcscmp
+#undef wcscoll
+#undef wcscpy
+#undef wcscspn
+#undef wcsftime
+#undef wcslen
+#undef wcsncat
+#undef wcsncmp
+#undef wcsncpy
+#undef wcspbrk
+#undef wcsrchr
+#undef wcsrtombs
+#undef wcsspn
+#undef wcsstr
+#undef wcstod
+#if _GLIBCXX_HAVE_WCSTOF
+# undef wcstof
+#endif
+#undef wcstok
+#undef wcstol
+#undef wcstoul
+#undef wcsxfrm
+#undef wctob
+#undef wmemchr
+#undef wmemcmp
+#undef wmemcpy
+#undef wmemmove
+#undef wmemset
+#undef wprintf
+#undef wscanf
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using ::wint_t;
+
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+#ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
+  using ::swprintf;
+#endif
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+#if _GLIBCXX_HAVE_VFWSCANF
+  using ::vfwscanf;
+#endif
+#ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
+  using ::vswprintf;
+#endif
+#if _GLIBCXX_HAVE_VSWSCANF
+  using ::vswscanf;
+#endif
+  using ::vwprintf;
+#if _GLIBCXX_HAVE_VWSCANF
+  using ::vwscanf;
+#endif
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+#if _GLIBCXX_HAVE_WCSTOF
+  using ::wcstof;
+#endif
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+
+#ifndef __CORRECT_ISO_CPP_WCHAR_H_PROTO
+  inline wchar_t*
+  wcschr(wchar_t* __p, wchar_t __c)
+  { return wcschr(const_cast<const wchar_t*>(__p), __c); }
+
+  inline wchar_t*
+  wcspbrk(wchar_t* __s1, const wchar_t* __s2)
+  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
+
+  inline wchar_t*
+  wcsrchr(wchar_t* __p, wchar_t __c)
+  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
+
+  inline wchar_t*
+  wcsstr(wchar_t* __s1, const wchar_t* __s2)
+  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
+
+  inline wchar_t*
+  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
+  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if _GLIBCXX_USE_C99
+
+#undef wcstold
+#undef wcstoll
+#undef wcstoull
+
+namespace __gnu_cxx
+{
+#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
+  extern "C" long double
+    (wcstold)(const wchar_t * __restrict, wchar_t ** __restrict) throw ();
+#endif
+#if !_GLIBCXX_USE_C99_DYNAMIC
+  using ::wcstold;
+#endif
+#if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  extern "C" long long int
+    (wcstoll)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw ();
+  extern "C" unsigned long long int
+    (wcstoull)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw ();
+#endif
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::wcstoll;
+  using ::wcstoull;
+#endif
+} // namespace __gnu_cxx
+
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+} // namespace
+
+#endif
+
+#endif //_GLIBCXX_USE_WCHAR_T
+
+#if __cplusplus >= 201103L
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+
+namespace std
+{
+#if _GLIBCXX_HAVE_WCSTOF
+  using std::wcstof;
+#endif
+#if _GLIBCXX_HAVE_VFWSCANF
+  using std::vfwscanf;
+#endif
+#if _GLIBCXX_HAVE_VSWSCANF
+  using std::vswscanf;
+#endif
+#if _GLIBCXX_HAVE_VWSCANF
+  using std::vwscanf;
+#endif
+
+#if _GLIBCXX_USE_C99
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoull;
+#endif
+} // namespace
+
+#endif // _GLIBCXX_USE_WCHAR_T
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_global/cwctype b/gcc-4.9/libstdc++-v3/include/c_global/cwctype
new file mode 100644
index 0000000..817e80b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_global/cwctype
@@ -0,0 +1,110 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cwctype
+ *  This is a Standard C++ Library file.  You should @c \#include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c wctype.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: <cwctype>
+//
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_WCTYPE_H
+
+#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 10
+// Work around glibc BZ 9694
+#include <stddef.h>
+#endif
+
+#include <wctype.h>
+#endif // _GLIBCXX_HAVE_WCTYPE_H
+
+#ifndef _GLIBCXX_CWCTYPE
+#define _GLIBCXX_CWCTYPE 1
+
+// Get rid of those macros defined in <wctype.h> in lieu of real functions.
+#undef iswalnum
+#undef iswalpha
+#if _GLIBCXX_HAVE_ISWBLANK
+# undef iswblank
+#endif
+#undef iswcntrl
+#undef iswctype
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef towctrans
+#undef towlower
+#undef towupper
+#undef wctrans
+#undef wctype
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std
+{
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+#if _GLIBCXX_HAVE_ISWBLANK
+  using ::iswblank;
+#endif
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+} // namespace
+
+#endif //_GLIBCXX_USE_WCHAR_T
+
+#endif // _GLIBCXX_CWCTYPE
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cassert b/gcc-4.9/libstdc++-v3/include/c_std/cassert
new file mode 100644
index 0000000..2e91387
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cassert
@@ -0,0 +1,43 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cassert
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c assert.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 19.2  Assertions
+//
+
+// No include guards on this header...
+
+#pragma GCC system_header
+
+#include <assert.h>
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cctype b/gcc-4.9/libstdc++-v3/include/c_std/cctype
new file mode 100644
index 0000000..acc3c2c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cctype
@@ -0,0 +1,79 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cctype
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c ctype.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: <ccytpe>
+//
+
+#ifndef _GLIBCXX_CCTYPE
+#define _GLIBCXX_CCTYPE 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <ctype.h>
+
+// Get rid of those macros defined in <ctype.h> in lieu of real functions.
+#undef isalnum
+#undef isalpha
+#undef iscntrl
+#undef isdigit
+#undef isgraph
+#undef islower
+#undef isprint
+#undef ispunct
+#undef isspace
+#undef isupper
+#undef isxdigit
+#undef tolower
+#undef toupper
+
+namespace std
+{
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cerrno b/gcc-4.9/libstdc++-v3/include/c_std/cerrno
new file mode 100644
index 0000000..5271837
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cerrno
@@ -0,0 +1,51 @@
+// The -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cerrno
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c errno.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 19.3  Error numbers
+//
+
+#ifndef _GLIBCXX_CERRNO
+#define _GLIBCXX_CERRNO 1
+
+#pragma GCC system_header
+
+#include <errno.h>
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef errno
+#define errno errno
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cfloat b/gcc-4.9/libstdc++-v3/include/c_std/cfloat
new file mode 100644
index 0000000..a792462
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cfloat
@@ -0,0 +1,46 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cfloat
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c float.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#ifndef _GLIBCXX_CFLOAT
+#define _GLIBCXX_CFLOAT 1
+
+#pragma GCC system_header
+
+#include <float.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/ciso646 b/gcc-4.9/libstdc++-v3/include/c_std/ciso646
new file mode 100644
index 0000000..7374919
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/ciso646
@@ -0,0 +1,33 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ciso646
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c iso646.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/climits b/gcc-4.9/libstdc++-v3/include/c_std/climits
new file mode 100644
index 0000000..d0cd631
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/climits
@@ -0,0 +1,46 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/climits
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c limits.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#ifndef _GLIBCXX_CLIMITS
+#define _GLIBCXX_CLIMITS 1
+
+#pragma GCC system_header
+
+#include <limits.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/clocale b/gcc-4.9/libstdc++-v3/include/c_std/clocale
new file mode 100644
index 0000000..e653ae2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/clocale
@@ -0,0 +1,58 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file clocale
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c locale.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.2.2  Implementation properties: C library
+//
+
+#ifndef _GLIBCXX_CLOCALE
+#define _GLIBCXX_CLOCALE 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <locale.h>
+
+// Get rid of those macros defined in <locale.h> in lieu of real functions.
+#undef setlocale
+#undef localeconv
+
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cmath b/gcc-4.9/libstdc++-v3/include/c_std/cmath
new file mode 100644
index 0000000..ccd5c0e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cmath
@@ -0,0 +1,591 @@
+// -*- C++ -*- C forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cmath
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c math.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 26.5  C library
+//
+
+#ifndef _GLIBCXX_CMATH
+#define _GLIBCXX_CMATH 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+
+#include <math.h>
+
+// Get rid of those macros defined in <math.h> in lieu of real functions.
+#undef abs
+#undef div
+#undef acos
+#undef asin
+#undef atan
+#undef atan2
+#undef ceil
+#undef cos
+#undef cosh
+#undef exp
+#undef fabs
+#undef floor
+#undef fmod
+#undef frexp
+#undef ldexp
+#undef log
+#undef log10
+#undef modf
+#undef pow
+#undef sin
+#undef sinh
+#undef sqrt
+#undef tan
+#undef tanh
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  inline double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+
+  inline float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    abs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::acos;
+
+  inline float
+  acos(float __x)
+  { return __builtin_acosf(__x); }
+
+  inline long double
+  acos(long double __x)
+  { return __builtin_acosl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    acos(_Tp __x)
+    { return __builtin_acos(__x); }
+
+  using ::asin;
+
+  inline float
+  asin(float __x)
+  { return __builtin_asinf(__x); }
+
+  inline long double
+  asin(long double __x)
+  { return __builtin_asinl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+					   double>::__type
+    asin(_Tp __x)
+    { return __builtin_asin(__x); }
+
+  using ::atan;
+
+  inline float
+  atan(float __x)
+  { return __builtin_atanf(__x); }
+
+  inline long double
+  atan(long double __x)
+  { return __builtin_atanl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    atan(_Tp __x)
+    { return __builtin_atan(__x); }
+
+  using ::atan2;
+
+  inline float
+  atan2(float __y, float __x)
+  { return __builtin_atan2f(__y, __x); }
+
+  inline long double
+  atan2(long double __y, long double __x)
+  { return __builtin_atan2l(__y, __x); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
+    					   && __is_integer<_Up>::__value, 
+					   double>::__type
+    atan2(_Tp __y, _Up __x)
+    { return __builtin_atan2(__y, __x); }
+
+  using ::ceil;
+
+  inline float
+  ceil(float __x)
+  { return __builtin_ceilf(__x); }
+
+  inline long double
+  ceil(long double __x)
+  { return __builtin_ceill(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    ceil(_Tp __x)
+    { return __builtin_ceil(__x); }
+
+  using ::cos;
+
+  inline float
+  cos(float __x)
+  { return __builtin_cosf(__x); }
+
+  inline long double
+  cos(long double __x)
+  { return __builtin_cosl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    cos(_Tp __x)
+    { return __builtin_cos(__x); }
+
+  using ::cosh;
+
+  inline float
+  cosh(float __x)
+  { return __builtin_coshf(__x); }
+
+  inline long double
+  cosh(long double __x)
+  { return __builtin_coshl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    cosh(_Tp __x)
+    { return __builtin_cosh(__x); }
+
+  using ::exp;
+
+  inline float
+  exp(float __x)
+  { return __builtin_expf(__x); }
+
+  inline long double
+  exp(long double __x)
+  { return __builtin_expl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    exp(_Tp __x)
+    { return __builtin_exp(__x); }
+
+  using ::fabs;
+
+  inline float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::floor;
+
+  inline float
+  floor(float __x)
+  { return __builtin_floorf(__x); }
+
+  inline long double
+  floor(long double __x)
+  { return __builtin_floorl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    floor(_Tp __x)
+    { return __builtin_floor(__x); }
+
+  using ::fmod;
+
+  inline float
+  fmod(float __x, float __y)
+  { return __builtin_fmodf(__x, __y); }
+
+  inline long double
+  fmod(long double __x, long double __y)
+  { return __builtin_fmodl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
+    					   && __is_integer<_Up>::__value, 
+					   double>::__type
+    fmod(_Tp __x, _Up __y)
+    { return __builtin_fmod(__x, __y); }
+
+  using ::frexp;
+
+  inline float
+  frexp(float __x, int* __exp)
+  { return __builtin_frexpf(__x, __exp); }
+
+  inline long double
+  frexp(long double __x, int* __exp)
+  { return __builtin_frexpl(__x, __exp); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    frexp(_Tp __x, int* __exp)
+    { return __builtin_frexp(__x, __exp); }
+
+  using ::ldexp;
+
+  inline float
+  ldexp(float __x, int __exp)
+  { return __builtin_ldexpf(__x, __exp); }
+
+  inline long double
+  ldexp(long double __x, int __exp)
+  { return __builtin_ldexpl(__x, __exp); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    ldexp(_Tp __x, int __exp)
+    { return __builtin_ldexp(__x, __exp); }
+
+  using ::log;
+
+  inline float
+  log(float __x)
+  { return __builtin_logf(__x); }
+
+  inline long double
+  log(long double __x)
+  { return __builtin_logl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    log(_Tp __x)
+    { return __builtin_log(__x); }
+
+  using ::log10;
+
+  inline float
+  log10(float __x)
+  { return __builtin_log10f(__x); }
+
+  inline long double
+  log10(long double __x)
+  { return __builtin_log10l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    log10(_Tp __x)
+    { return __builtin_log10(__x); }
+
+  using ::modf;
+
+  inline float
+  modf(float __x, float* __iptr)
+  { return __builtin_modff(__x, __iptr); }
+
+  inline long double
+  modf(long double __x, long double* __iptr)
+  { return __builtin_modfl(__x, __iptr); }
+
+  using ::pow;
+
+  inline float
+  pow(float __x, float __y)
+  { return __builtin_powf(__x, __y); }
+
+  inline long double
+  pow(long double __x, long double __y)
+  { return __builtin_powl(__x, __y); }
+
+  inline double
+  pow(double __x, int __i)
+  { return __builtin_powi(__x, __i); }
+
+  inline float
+  pow(float __x, int __n)
+  { return __builtin_powif(__x, __n); }
+
+  inline long double
+  pow(long double __x, int __n)
+  { return __builtin_powil(__x, __n); }
+
+  using ::sin;
+
+  inline float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+
+  inline long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+
+  using ::sinh;
+
+  inline float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+
+  inline long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+
+  using ::sqrt;
+
+  inline float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+
+  inline long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+
+  using ::tan;
+
+  inline float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+
+  inline long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+
+  using ::tanh;
+
+  inline float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+
+  inline long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if _GLIBCXX_USE_C99_MATH
+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+
+// These are possible macros imported from C99-land.
+#undef fpclassify
+#undef isfinite
+#undef isinf
+#undef isnan
+#undef isnormal
+#undef signbit
+#undef isgreater
+#undef isgreaterequal
+#undef isless
+#undef islessequal
+#undef islessgreater
+#undef isunordered
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    fpclassify(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+				  FP_SUBNORMAL, FP_ZERO, __type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isfinite(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isfinite(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isinf(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isinf(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isnan(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnan(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isnormal(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnormal(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    signbit(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_signbit(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isgreaterequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isless(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isless(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 
+					   int>::__type
+    islessequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    islessgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isunordered(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isunordered(__type(__f1), __type(__f2));
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/csetjmp b/gcc-4.9/libstdc++-v3/include/c_std/csetjmp
new file mode 100644
index 0000000..298cd47
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/csetjmp
@@ -0,0 +1,61 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file csetjmp
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c setjmp.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSETJMP
+#define _GLIBCXX_CSETJMP 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <setjmp.h>
+
+// Get rid of those macros defined in <setjmp.h> in lieu of real functions.
+#undef longjmp
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef setjmp
+#define setjmp(env) setjmp (env)
+#endif
+
+namespace std
+{
+  using ::jmp_buf;
+  using ::longjmp;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/csignal b/gcc-4.9/libstdc++-v3/include/c_std/csignal
new file mode 100644
index 0000000..839593d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/csignal
@@ -0,0 +1,57 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file csignal
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c signal.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSIGNAL
+#define _GLIBCXX_CSIGNAL 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <signal.h>
+
+// Get rid of those macros defined in <signal.h> in lieu of real functions.
+#undef raise
+
+namespace std
+{
+  using ::sig_atomic_t;
+  using ::signal;
+  using ::raise;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cstdarg b/gcc-4.9/libstdc++-v3/include/c_std/cstdarg
new file mode 100644
index 0000000..08d051c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cstdarg
@@ -0,0 +1,57 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdarg
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stdarg.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSTDARG
+#define _GLIBCXX_CSTDARG 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <stdarg.h>
+
+// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
+#ifndef va_end
+#define va_end(ap) va_end (ap)
+#endif
+
+namespace std
+{
+  using ::va_list;
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cstddef b/gcc-4.9/libstdc++-v3/include/c_std/cstddef
new file mode 100644
index 0000000..f4845f0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cstddef
@@ -0,0 +1,55 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cstddef
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stddef.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 18.1  Types
+//
+
+#ifndef _GLIBCXX_CSTDDEF
+#define _GLIBCXX_CSTDDEF 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <stddef.h>
+
+#if __cplusplus >= 201103L
+namespace std
+{
+  // We handle size_t, ptrdiff_t, and nullptr_t in c++config.h.
+  using ::max_align_t;
+}
+#endif
+
+#endif // _GLIBCXX_CSTDDEF
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cstdio b/gcc-4.9/libstdc++-v3/include/c_std/cstdio
new file mode 100644
index 0000000..9434da6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cstdio
@@ -0,0 +1,192 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdio
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stdio.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 27.8.2  C Library files
+//
+
+#ifndef _GLIBCXX_CSTDIO
+#define _GLIBCXX_CSTDIO 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <stdio.h>
+
+#ifndef _GLIBCXX_HAVE_GETS
+extern "C" char* gets (char* __s) __attribute__((deprecated));
+#endif
+
+// Get rid of those macros defined in <stdio.h> in lieu of real functions.
+#undef clearerr
+#undef fclose
+#undef feof
+#undef ferror
+#undef fflush
+#undef fgetc
+#undef fgetpos
+#undef fgets
+#undef fopen
+#undef fprintf
+#undef fputc
+#undef fputs
+#undef fread
+#undef freopen
+#undef fscanf
+#undef fseek
+#undef fsetpos
+#undef ftell
+#undef fwrite
+#undef getc
+#undef getchar
+#if __cplusplus <= 201103L
+# undef gets
+#endif
+#undef perror
+#undef printf
+#undef putc
+#undef putchar
+#undef puts
+#undef remove
+#undef rename
+#undef rewind
+#undef scanf
+#undef setbuf
+#undef setvbuf
+#undef sprintf
+#undef sscanf
+#undef tmpfile
+#undef tmpnam
+#undef ungetc
+#undef vfprintf
+#undef vprintf
+#undef vsprintf
+
+namespace std
+{
+  using ::FILE;
+  using ::fpos_t;
+
+  using ::clearerr;
+  using ::fclose;
+  using ::feof;
+  using ::ferror;
+  using ::fflush;
+  using ::fgetc;
+  using ::fgetpos;
+  using ::fgets;
+  using ::fopen;
+  using ::fprintf;
+  using ::fputc;
+  using ::fputs;
+  using ::fread;
+  using ::freopen;
+  using ::fscanf;
+  using ::fseek;
+  using ::fsetpos;
+  using ::ftell;
+  using ::fwrite;
+  using ::getc;
+  using ::getchar;
+#if __cplusplus <= 201103L
+  // LWG 2249
+  using ::gets;
+#endif
+  using ::perror;
+  using ::printf;
+  using ::putc;
+  using ::putchar;
+  using ::puts;
+  using ::remove;
+  using ::rename;
+  using ::rewind;
+  using ::scanf;
+  using ::setbuf;
+  using ::setvbuf;
+  using ::sprintf;
+  using ::sscanf;
+  using ::tmpfile;
+  using ::tmpnam;
+  using ::ungetc;
+  using ::vfprintf;
+  using ::vprintf;
+  using ::vsprintf;
+} // namespace std
+
+#if _GLIBCXX_USE_C99
+
+#undef snprintf
+#undef vfscanf
+#undef vscanf
+#undef vsnprintf
+#undef vsscanf
+
+namespace __gnu_cxx
+{
+#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
+  extern "C" int
+  (snprintf)(char * __restrict, std::size_t, const char * __restrict, ...)
+  throw ();
+  extern "C" int
+  (vfscanf)(FILE * __restrict, const char * __restrict, __gnuc_va_list);
+  extern "C" int (vscanf)(const char * __restrict, __gnuc_va_list);
+  extern "C" int
+  (vsnprintf)(char * __restrict, std::size_t, const char * __restrict,
+	      __gnuc_va_list) throw ();
+  extern "C" int
+  (vsscanf)(const char * __restrict, const char * __restrict, __gnuc_va_list)
+  throw ();
+#endif
+
+#if !_GLIBCXX_USE_C99_DYNAMIC
+  using ::snprintf;
+  using ::vfscanf;
+  using ::vscanf;
+  using ::vsnprintf;
+  using ::vsscanf;
+#endif
+} // namespace __gnu_cxx
+
+namespace std
+{
+  using ::__gnu_cxx::snprintf;
+  using ::__gnu_cxx::vfscanf;
+  using ::__gnu_cxx::vscanf;
+  using ::__gnu_cxx::vsnprintf;
+  using ::__gnu_cxx::vsscanf;
+} // namespace std
+
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cstdlib b/gcc-4.9/libstdc++-v3/include/c_std/cstdlib
new file mode 100644
index 0000000..7f0d9b2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cstdlib
@@ -0,0 +1,258 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cstdlib
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c stdlib.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSTDLIB
+#define _GLIBCXX_CSTDLIB 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if !_GLIBCXX_HOSTED
+// The C standard does not require a freestanding implementation to
+// provide <stdlib.h>.  However, the C++ standard does still require
+// <cstdlib> -- but only the functionality mentioned in
+// [lib.support.start.term].
+
+#define EXIT_SUCCESS 0
+#define EXIT_FAILURE 1
+
+namespace std
+{
+  extern "C" void abort(void) throw () _GLIBCXX_NORETURN;
+  extern "C" int atexit(void (*)(void)) throw ();
+  extern "C" void exit(int) throw () _GLIBCXX_NORETURN;
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT
+  extern "C" int at_quick_exit(void (*)(void)) throw ();
+# endif
+# ifdef _GLIBCXX_HAVE_QUICK_EXIT
+  extern "C" void quick_exit(int) throw() _GLIBCXX_NORETURN;
+# endif
+#endif
+} // namespace
+
+#else
+
+#include <stdlib.h>
+
+// Get rid of those macros defined in <stdlib.h> in lieu of real functions.
+#undef abort
+#undef abs
+#undef atexit
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT
+#  undef at_quick_exit
+# endif
+#endif
+#undef atof
+#undef atoi
+#undef atol
+#undef bsearch
+#undef calloc
+#undef div
+#undef exit
+#undef free
+#undef getenv
+#undef labs
+#undef ldiv
+#undef malloc
+#undef mblen
+#undef mbstowcs
+#undef mbtowc
+#undef qsort
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_QUICK_EXIT
+#  undef quick_exit
+# endif
+#endif
+#undef rand
+#undef realloc
+#undef srand
+#undef strtod
+#undef strtol
+#undef strtoul
+#undef system
+#undef wcstombs
+#undef wctomb
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using ::div_t;
+  using ::ldiv_t;
+
+  using ::abort;
+  using ::abs;
+  using ::atexit;
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT
+  using ::at_quick_exit;
+# endif
+#endif
+  using ::atof;
+  using ::atoi;
+  using ::atol;
+  using ::bsearch;
+  using ::calloc;
+  using ::div;
+  using ::exit;
+  using ::free;
+  using ::getenv;
+  using ::labs;
+  using ::ldiv;
+  using ::malloc;
+#ifdef _GLIBCXX_HAVE_MBSTATE_T
+  using ::mblen;
+  using ::mbstowcs;
+  using ::mbtowc;
+#endif // _GLIBCXX_HAVE_MBSTATE_T
+  using ::qsort;
+#if __cplusplus >= 201103L
+# ifdef _GLIBCXX_HAVE_QUICK_EXIT
+  using ::quick_exit;
+# endif
+#endif
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  using ::wcstombs;
+  using ::wctomb;
+#endif // _GLIBCXX_USE_WCHAR_T
+
+  inline long
+  abs(long __i) { return __builtin_labs(__i); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+  inline long long
+  abs(long long __x) { return __builtin_llabs (__x); }
+#endif
+
+#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
+  inline __int128
+  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
+#endif
+
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if _GLIBCXX_USE_C99
+
+#undef _Exit
+#undef llabs
+#undef lldiv
+#undef atoll
+#undef strtoll
+#undef strtoull
+#undef strtof
+#undef strtold
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::lldiv_t;
+#endif
+#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
+  extern "C" void (_Exit)(int) throw () _GLIBCXX_NORETURN;
+#endif
+#if !_GLIBCXX_USE_C99_DYNAMIC
+  using ::_Exit;
+#endif
+
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::llabs;
+
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+
+  using ::lldiv;
+#endif
+
+#if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  extern "C" long long int (atoll)(const char *) throw ();
+  extern "C" long long int
+    (strtoll)(const char * __restrict, char ** __restrict, int) throw ();
+  extern "C" unsigned long long int
+    (strtoull)(const char * __restrict, char ** __restrict, int) throw ();
+#endif
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+#endif
+  using ::strtof;
+  using ::strtold;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
+
+namespace std
+{
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::__gnu_cxx::lldiv_t;
+#endif
+  using ::__gnu_cxx::_Exit;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+#endif
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+} // namespace std
+
+#endif // _GLIBCXX_USE_C99
+
+#endif // !_GLIBCXX_HOSTED
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cstring b/gcc-4.9/libstdc++-v3/include/c_std/cstring
new file mode 100644
index 0000000..6ef97be
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cstring
@@ -0,0 +1,123 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file cstring
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c string.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+#ifndef _GLIBCXX_CSTRING
+#define _GLIBCXX_CSTRING 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <string.h>
+
+// Get rid of those macros defined in <string.h> in lieu of real functions.
+#undef memcpy
+#undef memmove
+#undef strcpy
+#undef strncpy
+#undef strcat
+#undef strncat
+#undef memcmp
+#undef strcmp
+#undef strcoll
+#undef strncmp
+#undef strxfrm
+#undef memchr
+#undef strchr
+#undef strcspn
+#undef strpbrk
+#undef strrchr
+#undef strspn
+#undef strstr
+#undef strtok
+#undef memset
+#undef strerror
+#undef strlen
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using ::memcpy;
+  using ::memmove;
+  using ::strcpy;
+  using ::strncpy;
+  using ::strcat;
+  using ::strncat;
+  using ::memcmp;
+  using ::strcmp;
+  using ::strcoll;
+  using ::strncmp;
+  using ::strxfrm;
+  using ::strcspn;
+  using ::strspn;
+  using ::strtok;
+  using ::memset;
+  using ::strerror;
+  using ::strlen;
+  using ::memchr;
+  using ::strchr;
+  using ::strpbrk;
+  using ::strrchr;
+  using ::strstr;
+
+#ifndef __CORRECT_ISO_CPP_STRING_H_PROTO
+  inline void*
+  memchr(void* __s, int __c, size_t __n)
+  { return __builtin_memchr(__s, __c, __n); }
+
+  inline char*
+  strchr(char* __s, int __n)
+  { return __builtin_strchr(__s, __n); }
+
+  inline char*
+  strpbrk(char* __s1, const char* __s2)
+  { return __builtin_strpbrk(__s1, __s2); }
+
+  inline char*
+  strrchr(char* __s, int __n)
+  { return __builtin_strrchr(__s, __n); }
+
+  inline char*
+  strstr(char* __s1, const char* __s2)
+  { return __builtin_strstr(__s1, __s2); }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/ctime b/gcc-4.9/libstdc++-v3/include/c_std/ctime
new file mode 100644
index 0000000..22616d2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/ctime
@@ -0,0 +1,75 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/ctime
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c time.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 20.5  Date and time
+//
+
+#ifndef _GLIBCXX_CTIME
+#define _GLIBCXX_CTIME 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <time.h>
+
+// Get rid of those macros defined in <time.h> in lieu of real functions.
+#undef clock
+#undef difftime
+#undef mktime
+#undef time
+#undef asctime
+#undef ctime
+#undef gmtime
+#undef localtime
+#undef strftime
+
+namespace std
+{
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+
+  using ::clock;
+  using ::difftime;
+  using ::mktime;
+  using ::time;
+  using ::asctime;
+  using ::ctime;
+  using ::gmtime;
+  using ::localtime;
+  using ::strftime;
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cwchar b/gcc-4.9/libstdc++-v3/include/c_std/cwchar
new file mode 100644
index 0000000..c6f1f23
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cwchar
@@ -0,0 +1,269 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cwchar
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c wchar.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: 21.4
+//
+
+#ifndef _GLIBCXX_CWCHAR
+#define _GLIBCXX_CWCHAR 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_WCHAR_H
+#include <wchar.h>
+#endif
+
+// Need to do a bit of trickery here with mbstate_t as char_traits
+// assumes it is in wchar.h, regardless of wchar_t specializations.
+#ifndef _GLIBCXX_HAVE_MBSTATE_T
+extern "C"
+{
+  typedef struct
+  {
+    int __fill[6];
+  } mbstate_t;
+}
+#endif
+
+namespace std
+{
+  using ::mbstate_t;
+} // namespace std
+
+// Get rid of those macros defined in <wchar.h> in lieu of real functions.
+#undef btowc
+#undef fgetwc
+#undef fgetws
+#undef fputwc
+#undef fputws
+#undef fwide
+#undef fwprintf
+#undef fwscanf
+#undef getwc
+#undef getwchar
+#undef mbrlen
+#undef mbrtowc
+#undef mbsinit
+#undef mbsrtowcs
+#undef putwc
+#undef putwchar
+#undef swprintf
+#undef swscanf
+#undef ungetwc
+#undef vfwprintf
+#if _GLIBCXX_HAVE_VFWSCANF
+# undef vfwscanf
+#endif
+#undef vswprintf
+#if _GLIBCXX_HAVE_VSWSCANF
+# undef vswscanf
+#endif
+#undef vwprintf
+#if _GLIBCXX_HAVE_VWSCANF
+# undef vwscanf
+#endif
+#undef wcrtomb
+#undef wcscat
+#undef wcschr
+#undef wcscmp
+#undef wcscoll
+#undef wcscpy
+#undef wcscspn
+#undef wcsftime
+#undef wcslen
+#undef wcsncat
+#undef wcsncmp
+#undef wcsncpy
+#undef wcspbrk
+#undef wcsrchr
+#undef wcsrtombs
+#undef wcsspn
+#undef wcsstr
+#undef wcstod
+#if _GLIBCXX_HAVE_WCSTOF
+# undef wcstof
+#endif
+#undef wcstok
+#undef wcstol
+#undef wcstoul
+#undef wcsxfrm
+#undef wctob
+#undef wmemchr
+#undef wmemcmp
+#undef wmemcpy
+#undef wmemmove
+#undef wmemset
+#undef wprintf
+#undef wscanf
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using ::wint_t;
+
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+  using ::swprintf;
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+#if _GLIBCXX_HAVE_VFWSCANF
+  using ::vfwscanf;
+#endif
+  using ::vswprintf;
+#if _GLIBCXX_HAVE_VSWSCANF
+  using ::vswscanf;
+#endif
+  using ::vwprintf;
+#if _GLIBCXX_HAVE_VWSCANF
+  using ::vwscanf;
+#endif
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+#if _GLIBCXX_HAVE_WCSTOF
+  using ::wcstof;
+#endif
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+
+#ifndef __CORRECT_ISO_CPP_WCHAR_H_PROTO
+  inline wchar_t*
+  wcschr(wchar_t* __p, wchar_t __c)
+  { return wcschr(const_cast<const wchar_t*>(__p), __c); }
+
+  inline wchar_t*
+  wcspbrk(wchar_t* __s1, const wchar_t* __s2)
+  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
+
+  inline wchar_t*
+  wcsrchr(wchar_t* __p, wchar_t __c)
+  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
+
+  inline wchar_t*
+  wcsstr(wchar_t* __s1, const wchar_t* __s2)
+  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
+
+  inline wchar_t*
+  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
+  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if _GLIBCXX_USE_C99
+
+#undef wcstold
+#undef wcstoll
+#undef wcstoull
+
+namespace __gnu_cxx
+{
+#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
+  extern "C" long double
+    (wcstold)(const wchar_t * __restrict, wchar_t ** __restrict) throw ();
+#endif
+#if !_GLIBCXX_USE_C99_DYNAMIC
+  using ::wcstold;
+#endif
+#if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  extern "C" long long int
+    (wcstoll)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw ();
+  extern "C" unsigned long long int
+    (wcstoull)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw ();
+#endif
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using ::wcstoll;
+  using ::wcstoull;
+#endif
+} // namespace __gnu_cxx
+
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+} // namespace std
+
+#endif
+
+#endif //_GLIBCXX_USE_WCHAR_T
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/c_std/cwctype b/gcc-4.9/libstdc++-v3/include/c_std/cwctype
new file mode 100644
index 0000000..8691cb6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/c_std/cwctype
@@ -0,0 +1,111 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/cwctype
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the @a *.h implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c wctype.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std (except for names which are defined
+ *  as macros in C).
+ */
+
+//
+// ISO C++ 14882: <cwctype>
+//
+
+#ifndef _GLIBCXX_CWCTYPE
+#define _GLIBCXX_CWCTYPE 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_WCTYPE_H
+
+#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 10
+// Work around glibc BZ 9694
+#include <stddef.h>
+#endif
+
+#include <wctype.h>
+#endif // _GLIBCXX_HAVE_WCTYPE_H
+
+// Get rid of those macros defined in <wctype.h> in lieu of real functions.
+#undef iswalnum
+#undef iswalpha
+#if _GLIBCXX_HAVE_ISWBLANK
+# undef iswblank
+#endif
+#undef iswcntrl
+#undef iswctype
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef towctrans
+#undef towlower
+#undef towupper
+#undef wctrans
+#undef wctype
+
+#if _GLIBCXX_USE_WCHAR_T
+
+namespace std
+{
+  using ::wint_t;	  // cwchar
+
+  using ::wctype_t;
+  using ::wctrans_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+#if _GLIBCXX_HAVE_ISWBLANK
+  using ::iswblank;
+#endif
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+} // namespace std
+
+#endif //_GLIBCXX_USE_WCHAR_T
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/array b/gcc-4.9/libstdc++-v3/include/debug/array
new file mode 100644
index 0000000..ef01c98
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/array
@@ -0,0 +1,310 @@
+// Debugging array implementation -*- C++ -*-
+
+// Copyright (C) 2012-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/array
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_DEBUG_ARRAY
+#define _GLIBCXX_DEBUG_ARRAY 1
+
+#pragma GCC system_header
+
+#include <debug/safe_sequence.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp 	    			      value_type;
+      typedef value_type*			      pointer;
+      typedef const value_type*                       const_pointer;
+      typedef value_type&                   	      reference;
+      typedef const value_type&             	      const_reference;
+      typedef value_type*                             iterator;
+      typedef const value_type*                       const_iterator;
+      typedef std::size_t                    	      size_type;
+      typedef std::ptrdiff_t                   	      difference_type;
+      typedef std::reverse_iterator<iterator>	      reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+
+      // Support for zero-sized arrays mandatory.
+      typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;
+      typename _AT_Type::_Type                         _M_elems;
+
+      template<std::size_t _Size>
+	struct _Array_check_subscript
+ 	{
+	  std::size_t size() { return _Size; }
+
+	  _Array_check_subscript(std::size_t __index)
+	  { __glibcxx_check_subscript(__index); }
+        };
+
+      template<std::size_t _Size>
+	struct _Array_check_nonempty
+ 	{
+	  bool empty() { return _Size == 0; }
+
+	  _Array_check_nonempty()
+	  { __glibcxx_check_nonempty(); }
+        };
+
+      // No explicit construct/copy/destroy for aggregate type.
+
+      // DR 776.
+      void
+      fill(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void
+      swap(array& __other)
+      noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+      // Iterators.
+      iterator
+      begin() noexcept
+      { return iterator(data()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(data()); }
+
+      iterator
+      end() noexcept
+      { return iterator(data() + _Nm); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      reverse_iterator 
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator 
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator 
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(data()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      const_reverse_iterator 
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      // Capacity.
+      constexpr size_type 
+      size() const noexcept { return _Nm; }
+
+      constexpr size_type 
+      max_size() const noexcept { return _Nm; }
+
+      constexpr bool 
+      empty() const noexcept { return size() == 0; }
+
+      // Element access.
+      reference
+      operator[](size_type __n) noexcept
+      {
+	__glibcxx_check_subscript(__n);
+	return _AT_Type::_S_ref(_M_elems, __n);
+      }
+
+      constexpr const_reference
+      operator[](size_type __n) const noexcept
+      {
+	return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+	 : (_GLIBCXX_THROW_OR_ABORT(_Array_check_subscript<_Nm>(__n)),
+	    _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      reference
+      at(size_type __n)
+      {
+	if (__n >= _Nm)
+	  std::__throw_out_of_range_fmt(__N("array::at: __n "
+				            "(which is %zu) >= _Nm "
+					    "(which is %zu)"),
+					__n, _Nm);
+	return _AT_Type::_S_ref(_M_elems, __n);
+      }
+
+      constexpr const_reference
+      at(size_type __n) const
+      {
+	// Result of conditional expression must be an lvalue so use
+	// boolean ? lvalue : (throw-expr, lvalue)
+	return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+	  : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
+					       ">= _Nm (which is %zu)"),
+					   __n, _Nm),
+	     _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      reference 
+      front() noexcept
+      {
+	__glibcxx_check_nonempty();
+	return *begin();
+      }
+
+      constexpr const_reference 
+      front() const noexcept
+      {
+	return _Nm ? _AT_Type::_S_ref(_M_elems, 0)
+	  : (_GLIBCXX_THROW_OR_ABORT(_Array_check_nonempty<_Nm>()),
+	     _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      reference 
+      back() noexcept
+      {
+	__glibcxx_check_nonempty();
+	return _Nm ? *(end() - 1) : *end();
+      }
+
+      constexpr const_reference 
+      back() const noexcept
+      {
+	return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+	  : (_GLIBCXX_THROW_OR_ABORT(_Array_check_nonempty<_Nm>()),
+	     _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      pointer
+      data() noexcept
+      { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
+
+      const_pointer
+      data() const noexcept
+      { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
+    };
+
+  // Array comparisons.
+  template<typename _Tp, std::size_t _Nm>
+    inline bool 
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    { 
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+					  __b.begin(), __b.end()); 
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+  // Specialized algorithms.
+  template<typename _Tp, std::size_t _Nm>
+    inline void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
+	_S_ref(__arr._M_elems, _Int);
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&&
+    get(array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::move(get<_Int>(__arr));
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&
+    get(const array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
+	_S_ref(__arr._M_elems, _Int);
+    }
+} // namespace __debug
+
+  // Tuple interface to class template array.
+
+  /// tuple_size
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<__debug::array<_Tp, _Nm>>
+    : public integral_constant<std::size_t, _Nm> { };
+
+  /// tuple_element
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, __debug::array<_Tp, _Nm>>
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      typedef _Tp type;
+    };
+} // namespace std
+
+#endif // _GLIBCXX_DEBUG_ARRAY
diff --git a/gcc-4.9/libstdc++-v3/include/debug/bitset b/gcc-4.9/libstdc++-v3/include/debug/bitset
new file mode 100644
index 0000000..9530399
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/bitset
@@ -0,0 +1,426 @@
+// Debugging bitset implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/bitset
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_BITSET
+#define _GLIBCXX_DEBUG_BITSET
+
+#include <bitset>
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::bitset with additional safety/checking/debug instrumentation.
+  template<size_t _Nb>
+    class bitset
+    : public _GLIBCXX_STD_C::bitset<_Nb>
+#if __cplusplus < 201103L
+    , public __gnu_debug::_Safe_sequence_base
+#endif
+    {
+      typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
+
+    public:
+      // In C++0x we rely on normal reference type to preserve the property
+      // of bitset to be use as a literal.
+      // TODO: Find another solution.
+#if __cplusplus >= 201103L
+      typedef typename _Base::reference reference;
+#else
+      // bit reference:
+      class reference
+      : private _Base::reference
+        , public __gnu_debug::_Safe_iterator_base
+      {
+	typedef typename _Base::reference _Base_ref;
+
+	friend class bitset;
+	reference();
+
+	reference(const _Base_ref& __base,
+		  bitset* __seq __attribute__((__unused__))) _GLIBCXX_NOEXCEPT
+	: _Base_ref(__base)
+	, _Safe_iterator_base(__seq, false)
+	{ }
+
+      public:
+	reference(const reference& __x) _GLIBCXX_NOEXCEPT
+	: _Base_ref(__x)
+	, _Safe_iterator_base(__x, false)
+	{ }
+
+	reference&
+	operator=(bool __x) _GLIBCXX_NOEXCEPT
+	{
+	  _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
+			      _M_message(__gnu_debug::__msg_bad_bitset_write)
+				._M_iterator(*this));
+	  *static_cast<_Base_ref*>(this) = __x;
+	  return *this;
+	}
+
+	reference&
+	operator=(const reference& __x) _GLIBCXX_NOEXCEPT
+	{
+	  _GLIBCXX_DEBUG_VERIFY(! __x._M_singular(),
+			       _M_message(__gnu_debug::__msg_bad_bitset_read)
+				._M_iterator(__x));
+	  _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
+			      _M_message(__gnu_debug::__msg_bad_bitset_write)
+				._M_iterator(*this));
+	  *static_cast<_Base_ref*>(this) = __x;
+	  return *this;
+	}
+
+	bool
+	operator~() const _GLIBCXX_NOEXCEPT
+	{
+	  _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
+			       _M_message(__gnu_debug::__msg_bad_bitset_read)
+				._M_iterator(*this));
+	  return ~(*static_cast<const _Base_ref*>(this));
+	}
+
+	operator bool() const _GLIBCXX_NOEXCEPT
+	{
+	  _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
+			      _M_message(__gnu_debug::__msg_bad_bitset_read)
+				._M_iterator(*this));
+	  return *static_cast<const _Base_ref*>(this);
+	}
+
+	reference&
+	flip() _GLIBCXX_NOEXCEPT
+	{
+	  _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
+			      _M_message(__gnu_debug::__msg_bad_bitset_flip)
+				._M_iterator(*this));
+	  _Base_ref::flip();
+	  return *this;
+	}
+      };
+#endif
+
+      // 23.3.5.1 constructors:
+      _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
+      : _Base() { }
+
+#if __cplusplus >= 201103L
+      constexpr bitset(unsigned long long __val) noexcept
+#else
+      bitset(unsigned long __val)
+#endif
+      : _Base(__val) { }
+
+      template<typename _CharT, typename _Traits, typename _Alloc>
+        explicit
+        bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __pos = 0,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
+	: _Base(__str, __pos, __n) { }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 396. what are characters zero and one.
+      template<class _CharT, class _Traits, class _Alloc>
+	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __pos,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __n,
+	       _CharT __zero, _CharT __one = _CharT('1'))
+	: _Base(__str, __pos, __n, __zero, __one) { }
+
+      bitset(const _Base& __x) : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      template<typename _CharT>
+        explicit
+        bitset(const _CharT* __str,
+	       typename std::basic_string<_CharT>::size_type __n
+	       = std::basic_string<_CharT>::npos,
+	       _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
+	: _Base(__str, __n, __zero, __one) { }
+#endif
+
+      // 23.3.5.2 bitset operations:
+      bitset<_Nb>&
+      operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() &= __rhs;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() |= __rhs;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() ^= __rhs;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator<<=(size_t __pos) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() <<= __pos;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator>>=(size_t __pos) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() >>= __pos;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      set() _GLIBCXX_NOEXCEPT
+      {
+	_Base::set();
+	return *this;
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 186. bitset::set() second parameter should be bool
+      bitset<_Nb>&
+      set(size_t __pos, bool __val = true)
+      {
+	_Base::set(__pos, __val);
+	return *this;
+      }
+
+      bitset<_Nb>&
+      reset() _GLIBCXX_NOEXCEPT
+      {
+	_Base::reset();
+	return *this;
+      }
+
+      bitset<_Nb>&
+      reset(size_t __pos)
+      {
+	_Base::reset(__pos);
+	return *this;
+      }
+
+      bitset<_Nb>
+      operator~() const _GLIBCXX_NOEXCEPT
+      { return bitset(~_M_base()); }
+
+      bitset<_Nb>&
+      flip() _GLIBCXX_NOEXCEPT
+      {
+	_Base::flip();
+	return *this;
+      }
+
+      bitset<_Nb>&
+      flip(size_t __pos)
+      {
+	_Base::flip(__pos);
+	return *this;
+      }
+
+      // element access:
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 11. Bitset minor problems
+      reference
+      operator[](size_t __pos)
+      {
+	__glibcxx_check_subscript(__pos);
+#if __cplusplus >= 201103L
+	return _M_base()[__pos];
+#else
+	return reference(_M_base()[__pos], this);
+#endif
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 11. Bitset minor problems
+      _GLIBCXX_CONSTEXPR bool
+      operator[](size_t __pos) const
+      {
+#if __cplusplus < 201103L
+	// TODO: Check in debug-mode too.
+	__glibcxx_check_subscript(__pos);
+#endif
+	return _Base::operator[](__pos);
+      }
+
+      using _Base::to_ulong;
+#if __cplusplus >= 201103L
+      using _Base::to_ullong;
+#endif
+
+      template <typename _CharT, typename _Traits, typename _Alloc>
+        std::basic_string<_CharT, _Traits, _Alloc>
+        to_string() const
+        { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 396. what are characters zero and one.
+      template<class _CharT, class _Traits, class _Alloc>
+	std::basic_string<_CharT, _Traits, _Alloc>
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{
+	  return _M_base().template
+	    to_string<_CharT, _Traits, _Alloc>(__zero, __one);
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 434. bitset::to_string() hard to use.
+      template<typename _CharT, typename _Traits>
+        std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+        to_string() const
+        { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 853. to_string needs updating with zero and one.
+      template<class _CharT, class _Traits>
+	std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{ return to_string<_CharT, _Traits,
+	                   std::allocator<_CharT> >(__zero, __one); }
+
+      template<typename _CharT>
+        std::basic_string<_CharT, std::char_traits<_CharT>,
+                          std::allocator<_CharT> >
+        to_string() const
+        {
+          return to_string<_CharT, std::char_traits<_CharT>,
+                           std::allocator<_CharT> >();
+        }
+
+      template<class _CharT>
+	std::basic_string<_CharT, std::char_traits<_CharT>,
+	                  std::allocator<_CharT> >
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{
+	  return to_string<_CharT, std::char_traits<_CharT>,
+	                   std::allocator<_CharT> >(__zero, __one);
+	}
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string() const
+      {
+	return to_string<char,std::char_traits<char>,std::allocator<char> >();
+      }
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string(char __zero, char __one = '1') const
+      {
+	return to_string<char, std::char_traits<char>,
+	                 std::allocator<char> >(__zero, __one);
+      }
+
+      using _Base::count;
+      using _Base::size;
+
+      bool
+      operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
+      { return _M_base() == __rhs; }
+
+      bool
+      operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
+      { return _M_base() != __rhs; }
+
+      using _Base::test;
+      using _Base::all;
+      using _Base::any;
+      using _Base::none;
+
+      bitset<_Nb>
+      operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT
+      { return bitset<_Nb>(_M_base() << __pos); }
+
+      bitset<_Nb>
+      operator>>(size_t __pos) const _GLIBCXX_NOEXCEPT
+      { return bitset<_Nb>(_M_base() >> __pos); }
+
+      _Base& 
+      _M_base() _GLIBCXX_NOEXCEPT
+      { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT
+      { return *this; }
+    };
+
+  template<size_t _Nb>
+    bitset<_Nb>
+    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    { return bitset<_Nb>(__x) &= __y; }
+
+  template<size_t _Nb>
+    bitset<_Nb>
+    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    { return bitset<_Nb>(__x) |= __y; }
+
+  template<size_t _Nb>
+    bitset<_Nb>
+    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    { return bitset<_Nb>(__x) ^= __y; }
+
+  template<typename _CharT, typename _Traits, size_t _Nb>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
+    { return __is >> __x._M_base(); }
+
+  template<typename _CharT, typename _Traits, size_t _Nb>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const bitset<_Nb>& __x)
+    { return __os << __x._M_base(); }
+
+} // namespace __debug
+
+#if __cplusplus >= 201103L
+  // DR 1182.
+  /// std::hash specialization for bitset.
+  template<size_t _Nb>
+    struct hash<__debug::bitset<_Nb>>
+    : public __hash_base<size_t, __debug::bitset<_Nb>>
+    {
+      size_t
+      operator()(const __debug::bitset<_Nb>& __b) const noexcept
+      { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
+    };
+#endif
+
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/debug.h b/gcc-4.9/libstdc++-v3/include/debug/debug.h
new file mode 100644
index 0000000..1b37471
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/debug.h
@@ -0,0 +1,131 @@
+// Debugging support implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/debug.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_MACRO_SWITCH_H
+#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1
+
+/** Macros and namespaces used by the implementation outside of debug
+ *  wrappers to verify certain properties. The __glibcxx_requires_xxx
+ *  macros are merely wrappers around the __glibcxx_check_xxx wrappers
+ *  when we are compiling with debug mode, but disappear when we are
+ *  in release mode so that there is no checking performed in, e.g.,
+ *  the standard library algorithms.
+*/
+
+// Debug mode namespaces.
+
+/**
+ * @namespace std::__debug
+ * @brief GNU debug code, replaces standard behavior with debug behavior.
+ */
+namespace std
+{ 
+  namespace __debug { } 
+}
+
+/** @namespace __gnu_debug
+ *  @brief GNU debug classes for public use.
+*/
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+}
+
+#ifndef _GLIBCXX_DEBUG
+
+# define _GLIBCXX_DEBUG_ASSERT(_Condition)
+# define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
+# define _GLIBCXX_DEBUG_ONLY(_Statement) ;
+# define __glibcxx_requires_cond(_Cond,_Msg)
+# define __glibcxx_requires_valid_range(_First,_Last)
+# define __glibcxx_requires_non_empty_range(_First,_Last)
+# define __glibcxx_requires_sorted(_First,_Last)
+# define __glibcxx_requires_sorted_pred(_First,_Last,_Pred)
+# define __glibcxx_requires_sorted_set(_First1,_Last1,_First2)
+# define __glibcxx_requires_sorted_set_pred(_First1,_Last1,_First2,_Pred)
+# define __glibcxx_requires_partitioned_lower(_First,_Last,_Value)
+# define __glibcxx_requires_partitioned_upper(_First,_Last,_Value)
+# define __glibcxx_requires_partitioned_lower_pred(_First,_Last,_Value,_Pred)
+# define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred)
+# define __glibcxx_requires_heap(_First,_Last)
+# define __glibcxx_requires_heap_pred(_First,_Last,_Pred)
+# define __glibcxx_requires_nonempty()
+# define __glibcxx_requires_string(_String)
+# define __glibcxx_requires_string_len(_String,_Len)
+# define __glibcxx_requires_subscript(_N)
+
+#else
+
+# include <debug/macros.h>
+
+#define _GLIBCXX_DEBUG_ASSERT(_Condition) __glibcxx_assert(_Condition)
+
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+# define _GLIBCXX_DEBUG_PEDASSERT(_Condition) _GLIBCXX_DEBUG_ASSERT(_Condition)
+#else
+# define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
+#endif
+
+# define _GLIBCXX_DEBUG_ONLY(_Statement) _Statement
+
+# define __glibcxx_requires_cond(_Cond,_Msg) _GLIBCXX_DEBUG_VERIFY(_Cond,_Msg)
+# define __glibcxx_requires_valid_range(_First,_Last) \
+     __glibcxx_check_valid_range(_First,_Last)
+# define __glibcxx_requires_non_empty_range(_First,_Last) \
+     __glibcxx_check_non_empty_range(_First,_Last)
+# define __glibcxx_requires_sorted(_First,_Last) \
+     __glibcxx_check_sorted(_First,_Last)
+# define __glibcxx_requires_sorted_pred(_First,_Last,_Pred) \
+     __glibcxx_check_sorted_pred(_First,_Last,_Pred)
+# define __glibcxx_requires_sorted_set(_First1,_Last1,_First2) \
+     __glibcxx_check_sorted_set(_First1,_Last1,_First2)
+# define __glibcxx_requires_sorted_set_pred(_First1,_Last1,_First2,_Pred) \
+     __glibcxx_check_sorted_set_pred(_First1,_Last1,_First2,_Pred)
+# define __glibcxx_requires_partitioned_lower(_First,_Last,_Value)	\
+     __glibcxx_check_partitioned_lower(_First,_Last,_Value)
+# define __glibcxx_requires_partitioned_upper(_First,_Last,_Value)	\
+     __glibcxx_check_partitioned_upper(_First,_Last,_Value)
+# define __glibcxx_requires_partitioned_lower_pred(_First,_Last,_Value,_Pred) \
+     __glibcxx_check_partitioned_lower_pred(_First,_Last,_Value,_Pred)
+# define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred) \
+     __glibcxx_check_partitioned_upper_pred(_First,_Last,_Value,_Pred)
+# define __glibcxx_requires_heap(_First,_Last) \
+     __glibcxx_check_heap(_First,_Last)
+# define __glibcxx_requires_heap_pred(_First,_Last,_Pred) \
+     __glibcxx_check_heap_pred(_First,_Last,_Pred)
+# define __glibcxx_requires_nonempty() __glibcxx_check_nonempty()
+# define __glibcxx_requires_string(_String) __glibcxx_check_string(_String)
+# define __glibcxx_requires_string_len(_String,_Len)	\
+     __glibcxx_check_string_len(_String,_Len)
+# define __glibcxx_requires_subscript(_N) __glibcxx_check_subscript(_N)
+
+# include <debug/functions.h>
+
+#endif
+
+#endif // _GLIBCXX_DEBUG_MACRO_SWITCH_H
diff --git a/gcc-4.9/libstdc++-v3/include/debug/deque b/gcc-4.9/libstdc++-v3/include/debug/deque
new file mode 100644
index 0000000..225d06c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/deque
@@ -0,0 +1,626 @@
+// Debugging deque implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/deque
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_DEQUE
+#define _GLIBCXX_DEBUG_DEQUE 1
+
+#include <deque>
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::deque with safety/checking/debug instrumentation.
+  template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
+    class deque
+    : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>,
+      public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
+    {
+      typedef  _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
+
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+    public:
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator,deque>
+						    iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,deque>
+						    const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+
+      typedef _Tp				    value_type;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      // 23.2.1.1 construct/copy/destroy:
+
+      deque() : _Base() { }
+
+      explicit
+      deque(const _Allocator& __a)
+      : _Base(__a) { }
+
+#if __cplusplus >= 201103L
+      explicit
+      deque(size_type __n)
+      : _Base(__n) { }
+
+      deque(size_type __n, const _Tp& __value,
+	    const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) { }
+#else
+      explicit
+      deque(size_type __n, const _Tp& __value = _Tp(),
+	    const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) { }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        deque(_InputIterator __first, _InputIterator __last,
+	      const _Allocator& __a = _Allocator())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __a)
+        { }
+
+      deque(const deque& __x)
+      : _Base(__x) { }
+
+      deque(const _Base& __x)
+      : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      deque(deque&& __x)
+      : _Base(std::move(__x))
+      { this->_M_swap(__x); }
+
+      deque(initializer_list<value_type> __l,
+	    const allocator_type& __a = allocator_type())
+      : _Base(__l, __a) { }
+#endif
+
+      ~deque() _GLIBCXX_NOEXCEPT { }
+
+      deque&
+      operator=(const deque& __x)
+      {
+	*static_cast<_Base*>(this) = __x;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      deque&
+      operator=(deque&& __x) noexcept
+      {
+	// NB: DR 1204.
+	// NB: DR 675.
+	__glibcxx_check_self_move_assign(__x);
+	clear();
+	swap(__x);
+	return *this;
+      }
+
+      deque&
+      operator=(initializer_list<value_type> __l)
+      {
+	*static_cast<_Base*>(this) = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::assign(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  this->_M_invalidate_all();
+	}
+
+      void
+      assign(size_type __n, const _Tp& __t)
+      {
+	_Base::assign(__n, __t);
+	this->_M_invalidate_all();
+      }
+
+#if __cplusplus >= 201103L
+      void
+      assign(initializer_list<value_type> __l)
+      {
+	_Base::assign(__l);
+	this->_M_invalidate_all();
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+    private:
+      void
+      _M_invalidate_after_nth(difference_type __n)
+      {
+	typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
+	this->_M_invalidate_if(_After_nth(__n, _Base::begin()));
+      }
+      
+    public:
+      // 23.2.1.2 capacity:
+      using _Base::size;
+      using _Base::max_size;
+
+#if __cplusplus >= 201103L
+      void
+      resize(size_type __sz)
+      {
+	bool __invalidate_all = __sz > this->size();
+	if (__sz < this->size())
+	  this->_M_invalidate_after_nth(__sz);
+
+	_Base::resize(__sz);
+
+	if (__invalidate_all)
+	  this->_M_invalidate_all();
+      }
+
+      void
+      resize(size_type __sz, const _Tp& __c)
+      {
+	bool __invalidate_all = __sz > this->size();
+	if (__sz < this->size())
+	  this->_M_invalidate_after_nth(__sz);
+
+	_Base::resize(__sz, __c);
+
+	if (__invalidate_all)
+	  this->_M_invalidate_all();
+      }
+#else
+      void
+      resize(size_type __sz, _Tp __c = _Tp())
+      {
+	bool __invalidate_all = __sz > this->size();
+	if (__sz < this->size())
+	  this->_M_invalidate_after_nth(__sz);
+
+	_Base::resize(__sz, __c);
+
+	if (__invalidate_all)
+	  this->_M_invalidate_all();
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      void
+      shrink_to_fit() noexcept
+      {
+	if (_Base::_M_shrink_to_fit())
+	  this->_M_invalidate_all();
+      }
+#endif
+
+      using _Base::empty;
+
+      // element access:
+      reference
+      operator[](size_type __n) _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_subscript(__n);
+	return _M_base()[__n];
+      }
+
+      const_reference
+      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_subscript(__n);
+	return _M_base()[__n];
+      }
+
+      using _Base::at;
+
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::back();
+      }
+
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::back();
+      }
+
+      // 23.2.1.3 modifiers:
+      void
+      push_front(const _Tp& __x)
+      {
+	_Base::push_front(__x);
+	this->_M_invalidate_all();
+      }
+
+      void
+      push_back(const _Tp& __x)
+      {
+	_Base::push_back(__x);
+	this->_M_invalidate_all();
+      }
+
+#if __cplusplus >= 201103L
+      void
+      push_front(_Tp&& __x)
+      { emplace_front(std::move(__x)); }
+
+      void
+      push_back(_Tp&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_front(_Args&&... __args)
+	{
+	  _Base::emplace_front(std::forward<_Args>(__args)...);
+	  this->_M_invalidate_all();
+	}
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args)
+	{
+	  _Base::emplace_back(std::forward<_Args>(__args)...);
+	  this->_M_invalidate_all();
+	}
+
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__position);
+	  _Base_iterator __res = _Base::emplace(__position.base(),
+						std::forward<_Args>(__args)...);
+	  this->_M_invalidate_all();
+	  return iterator(__res, this);
+	}
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const _Tp& __x)
+#else
+      insert(iterator __position, const _Tp& __x)
+#endif
+      {
+	__glibcxx_check_insert(__position);
+	_Base_iterator __res = _Base::insert(__position.base(), __x);
+	this->_M_invalidate_all();
+	return iterator(__res, this);
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, _Tp&& __x)
+      { return emplace(__position, std::move(__x)); }
+
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      {
+	__glibcxx_check_insert(__position);
+	_Base_iterator __res = _Base::insert(__position.base(), __l);
+	this->_M_invalidate_all();
+	return iterator(__res, this);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, size_type __n, const _Tp& __x)
+      {
+	__glibcxx_check_insert(__position);
+	_Base_iterator __res = _Base::insert(__position.base(), __n, __x);
+	this->_M_invalidate_all();
+	return iterator(__res, this);
+      }
+#else
+      void
+      insert(iterator __position, size_type __n, const _Tp& __x)
+      {
+	__glibcxx_check_insert(__position);
+	_Base::insert(__position.base(), __n, __x);
+	this->_M_invalidate_all();
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	iterator
+        insert(const_iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_insert_range(__position, __first, __last);
+	  _Base_iterator __res = _Base::insert(__position.base(),
+					       __gnu_debug::__base(__first),
+					       __gnu_debug::__base(__last));
+	  this->_M_invalidate_all();
+	  return iterator(__res, this);
+	}
+#else
+      template<class _InputIterator>
+        void
+        insert(iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_insert_range(__position, __first, __last);
+	  _Base::insert(__position.base(), __gnu_debug::__base(__first),
+					   __gnu_debug::__base(__last));
+	  this->_M_invalidate_all();
+	}
+#endif
+
+      void
+      pop_front() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	this->_M_invalidate_if(_Equal(_Base::begin()));
+	_Base::pop_front();
+      }
+
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	this->_M_invalidate_if(_Equal(--_Base::end()));
+	_Base::pop_back();
+      }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position)
+#else
+      erase(iterator __position)	
+#endif
+      {
+	__glibcxx_check_erase(__position);
+#if __cplusplus >= 201103L
+	_Base_const_iterator __victim = __position.base();
+#else
+	_Base_iterator __victim = __position.base();
+#endif
+	if (__victim == _Base::begin() || __victim == _Base::end() - 1)
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	    return iterator(_Base::erase(__victim), this);
+	  }
+	else
+	  {
+	    _Base_iterator __res = _Base::erase(__victim);
+	    this->_M_invalidate_all();
+	    return iterator(__res, this);
+	  }
+      }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last)
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+
+	if (__first.base() == __last.base())
+#if __cplusplus >= 201103L
+	  return iterator(__first.base()._M_const_cast(), this);
+#else
+	  return __first;
+#endif
+        else if (__first.base() == _Base::begin()
+		 || __last.base() == _Base::end())
+	  {
+	    this->_M_detach_singular();
+	    for (_Base_const_iterator __position = __first.base();
+		 __position != __last.base(); ++__position)
+	      {
+		this->_M_invalidate_if(_Equal(__position));
+	      }
+	    __try
+	      {
+		return iterator(_Base::erase(__first.base(), __last.base()),
+				this);
+	      }
+	    __catch(...)
+	      {
+		this->_M_revalidate_singular();
+		__throw_exception_again;
+	      }
+	  }
+	else
+	  {
+	    _Base_iterator __res = _Base::erase(__first.base(),
+						__last.base());
+	    this->_M_invalidate_all();
+	    return iterator(__res, this);
+	  }
+      }
+
+      void
+      swap(deque& __x) _GLIBCXX_NOEXCEPT
+      {
+	_Base::swap(__x);
+	this->_M_swap(__x);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+    };
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const deque<_Tp, _Alloc>& __lhs,
+	      const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const deque<_Tp, _Alloc>& __lhs,
+	      const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __debug
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/formatter.h b/gcc-4.9/libstdc++-v3/include/debug/formatter.h
new file mode 100644
index 0000000..e8ab724
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/formatter.h
@@ -0,0 +1,464 @@
+// Debug-mode error formatting implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/formatter.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_FORMATTER_H
+#define _GLIBCXX_DEBUG_FORMATTER_H 1
+
+#include <bits/c++config.h>
+#include <bits/cpp_type_traits.h>
+#include <typeinfo>
+
+namespace __gnu_debug
+{
+  using std::type_info;
+
+  template<typename _Iterator>
+    bool __check_singular(const _Iterator&);
+
+  class _Safe_sequence_base;
+
+  template<typename _Iterator, typename _Sequence>
+    class _Safe_iterator;
+
+  template<typename _Iterator, typename _Sequence>
+    class _Safe_local_iterator;
+
+  template<typename _Sequence>
+    class _Safe_sequence;
+
+  enum _Debug_msg_id
+  {
+    // General checks
+    __msg_valid_range,
+    __msg_insert_singular,
+    __msg_insert_different,
+    __msg_erase_bad,
+    __msg_erase_different,
+    __msg_subscript_oob,
+    __msg_empty,
+    __msg_unpartitioned,
+    __msg_unpartitioned_pred,
+    __msg_unsorted,
+    __msg_unsorted_pred,
+    __msg_not_heap,
+    __msg_not_heap_pred,
+    // std::bitset checks
+    __msg_bad_bitset_write,
+    __msg_bad_bitset_read,
+    __msg_bad_bitset_flip,
+    // std::list checks
+    __msg_self_splice,
+    __msg_splice_alloc,
+    __msg_splice_bad,
+    __msg_splice_other,
+    __msg_splice_overlap,
+    // iterator checks
+    __msg_init_singular,
+    __msg_init_copy_singular,
+    __msg_init_const_singular,
+    __msg_copy_singular,
+    __msg_bad_deref,
+    __msg_bad_inc,
+    __msg_bad_dec,
+    __msg_iter_subscript_oob,
+    __msg_advance_oob,
+    __msg_retreat_oob,
+    __msg_iter_compare_bad,
+    __msg_compare_different,
+    __msg_iter_order_bad,
+    __msg_order_different,
+    __msg_distance_bad,
+    __msg_distance_different,
+    // istream_iterator
+    __msg_deref_istream,
+    __msg_inc_istream,
+    // ostream_iterator
+    __msg_output_ostream,
+    // istreambuf_iterator
+    __msg_deref_istreambuf,
+    __msg_inc_istreambuf,
+    // forward_list
+    __msg_insert_after_end,
+    __msg_erase_after_bad,
+    __msg_valid_range2,
+    // unordered container local iterators
+    __msg_local_iter_compare_bad,
+    __msg_non_empty_range,
+    // self move assign
+    __msg_self_move_assign,
+    // unordered container buckets
+    __msg_bucket_index_oob,
+    __msg_valid_load_factor,
+    // others
+    __msg_equal_allocs,
+    __msg_insert_range_from_self
+  };
+
+  class _Error_formatter
+  {
+    /// Whether an iterator is constant, mutable, or unknown
+    enum _Constness
+    {
+      __unknown_constness,
+      __const_iterator,
+      __mutable_iterator,
+      __last_constness
+    };
+
+    // The state of the iterator (fine-grained), if we know it.
+    enum _Iterator_state
+    {
+      __unknown_state,
+      __singular,      // singular, may still be attached to a sequence
+      __begin,         // dereferenceable, and at the beginning
+      __middle,        // dereferenceable, not at the beginning
+      __end,           // past-the-end, may be at beginning if sequence empty
+      __before_begin,  // before begin
+      __last_state
+    };
+
+    // Tags denoting the type of parameter for construction
+    struct _Is_iterator { };
+    struct _Is_sequence { };
+
+    // A parameter that may be referenced by an error message
+    struct _Parameter
+    {
+      enum
+      {
+	__unused_param,
+	__iterator,
+	__sequence,
+	__integer,
+	__string
+      } _M_kind;
+
+      union
+      {
+	// When _M_kind == __iterator
+	struct
+	{
+	  const char*      _M_name;
+	  const void*      _M_address;
+	  const type_info* _M_type;
+	  _Constness       _M_constness;
+	  _Iterator_state  _M_state;
+	  const void*      _M_sequence;
+	  const type_info* _M_seq_type;
+	} _M_iterator;
+
+	// When _M_kind == __sequence
+	struct
+	{
+	  const char*      _M_name;
+	  const void*      _M_address;
+	  const type_info* _M_type;
+	} _M_sequence;
+
+	// When _M_kind == __integer
+	struct
+	{
+	  const char* _M_name;
+	  long        _M_value;
+	} _M_integer;
+
+	// When _M_kind == __string
+	struct
+	{
+	  const char* _M_name;
+	  const char* _M_value;
+	} _M_string;
+      } _M_variant;
+
+      _Parameter() : _M_kind(__unused_param), _M_variant() { }
+
+      _Parameter(long __value, const char* __name) 
+      : _M_kind(__integer), _M_variant()
+      {
+	_M_variant._M_integer._M_name = __name;
+	_M_variant._M_integer._M_value = __value;
+      }
+
+      _Parameter(const char* __value, const char* __name) 
+      : _M_kind(__string), _M_variant()
+      {
+	_M_variant._M_string._M_name = __name;
+	_M_variant._M_string._M_value = __value;
+      }
+
+      template<typename _Iterator, typename _Sequence>
+        _Parameter(const _Safe_iterator<_Iterator, _Sequence>& __it,
+		   const char* __name, _Is_iterator)
+	: _M_kind(__iterator),  _M_variant()
+        {
+	  _M_variant._M_iterator._M_name = __name;
+	  _M_variant._M_iterator._M_address = &__it;
+#ifdef __GXX_RTTI
+	  _M_variant._M_iterator._M_type = &typeid(__it);
+#else
+	  _M_variant._M_iterator._M_type = 0;
+#endif
+	  _M_variant._M_iterator._M_constness =
+	    std::__are_same<_Safe_iterator<_Iterator, _Sequence>,
+	                    typename _Sequence::iterator>::
+	      __value ? __mutable_iterator : __const_iterator;
+	  _M_variant._M_iterator._M_sequence = __it._M_get_sequence();
+#ifdef __GXX_RTTI
+	  _M_variant._M_iterator._M_seq_type = &typeid(_Sequence);
+#else
+	  _M_variant._M_iterator._M_seq_type = 0;
+#endif
+
+	  if (__it._M_singular())
+	    _M_variant._M_iterator._M_state = __singular;
+	  else
+	    {
+	      if (__it._M_is_before_begin())
+		_M_variant._M_iterator._M_state = __before_begin;
+	      else if (__it._M_is_end())
+		_M_variant._M_iterator._M_state = __end;
+	      else if (__it._M_is_begin())
+		_M_variant._M_iterator._M_state = __begin;
+	      else
+		_M_variant._M_iterator._M_state = __middle;
+	    }
+	}
+
+      template<typename _Iterator, typename _Sequence>
+	_Parameter(const _Safe_local_iterator<_Iterator, _Sequence>& __it,
+		   const char* __name, _Is_iterator)
+	: _M_kind(__iterator),  _M_variant()
+	{
+	  _M_variant._M_iterator._M_name = __name;
+	  _M_variant._M_iterator._M_address = &__it;
+#ifdef __GXX_RTTI
+	  _M_variant._M_iterator._M_type = &typeid(__it);
+#else
+	  _M_variant._M_iterator._M_type = 0;
+#endif
+	  _M_variant._M_iterator._M_constness =
+	    std::__are_same<_Safe_local_iterator<_Iterator, _Sequence>,
+	                    typename _Sequence::local_iterator>::
+	      __value ? __mutable_iterator : __const_iterator;
+	  _M_variant._M_iterator._M_sequence = __it._M_get_sequence();
+#ifdef __GXX_RTTI
+	  _M_variant._M_iterator._M_seq_type = &typeid(_Sequence);
+#else
+	  _M_variant._M_iterator._M_seq_type = 0;
+#endif
+
+	  if (__it._M_singular())
+	    _M_variant._M_iterator._M_state = __singular;
+	  else
+	    {
+	      if (__it._M_is_end())
+		_M_variant._M_iterator._M_state = __end;
+	      else if (__it._M_is_begin())
+		_M_variant._M_iterator._M_state = __begin;
+	      else
+		_M_variant._M_iterator._M_state = __middle;
+	    }
+	}
+
+      template<typename _Type>
+        _Parameter(const _Type*& __it, const char* __name, _Is_iterator)
+        : _M_kind(__iterator), _M_variant()
+        {
+	  _M_variant._M_iterator._M_name = __name;
+	  _M_variant._M_iterator._M_address = &__it;
+#ifdef __GXX_RTTI
+	  _M_variant._M_iterator._M_type = &typeid(__it);
+#else
+	  _M_variant._M_iterator._M_type = 0;
+#endif
+	  _M_variant._M_iterator._M_constness = __mutable_iterator;
+	  _M_variant._M_iterator._M_state = __it? __unknown_state : __singular;
+	  _M_variant._M_iterator._M_sequence = 0;
+	  _M_variant._M_iterator._M_seq_type = 0;
+	}
+
+      template<typename _Type>
+        _Parameter(_Type*& __it, const char* __name, _Is_iterator)
+        : _M_kind(__iterator), _M_variant()
+        {
+	  _M_variant._M_iterator._M_name = __name;
+	  _M_variant._M_iterator._M_address = &__it;
+#ifdef __GXX_RTTI
+	  _M_variant._M_iterator._M_type = &typeid(__it);
+#else
+	  _M_variant._M_iterator._M_type = 0;
+#endif
+	  _M_variant._M_iterator._M_constness = __const_iterator;
+	  _M_variant._M_iterator._M_state = __it? __unknown_state : __singular;
+	  _M_variant._M_iterator._M_sequence = 0;
+	  _M_variant._M_iterator._M_seq_type = 0;
+	}
+
+      template<typename _Iterator>
+        _Parameter(const _Iterator& __it, const char* __name, _Is_iterator)
+        : _M_kind(__iterator), _M_variant()
+        {
+	  _M_variant._M_iterator._M_name = __name;
+	  _M_variant._M_iterator._M_address = &__it;
+#ifdef __GXX_RTTI
+	  _M_variant._M_iterator._M_type = &typeid(__it);
+#else
+	  _M_variant._M_iterator._M_type = 0;
+#endif
+	  _M_variant._M_iterator._M_constness = __unknown_constness;
+	  _M_variant._M_iterator._M_state =
+	    __gnu_debug::__check_singular(__it)? __singular : __unknown_state;
+	  _M_variant._M_iterator._M_sequence = 0;
+	  _M_variant._M_iterator._M_seq_type = 0;
+	}
+
+      template<typename _Sequence>
+        _Parameter(const _Safe_sequence<_Sequence>& __seq,
+		   const char* __name, _Is_sequence)
+        : _M_kind(__sequence), _M_variant()
+        {
+	  _M_variant._M_sequence._M_name = __name;
+	  _M_variant._M_sequence._M_address =
+	    static_cast<const _Sequence*>(&__seq);
+#ifdef __GXX_RTTI
+	  _M_variant._M_sequence._M_type = &typeid(_Sequence);
+#else
+	  _M_variant._M_sequence._M_type = 0;
+#endif
+	}
+
+      template<typename _Sequence>
+        _Parameter(const _Sequence& __seq, const char* __name, _Is_sequence)
+        : _M_kind(__sequence), _M_variant()
+        {
+	  _M_variant._M_sequence._M_name = __name;
+	  _M_variant._M_sequence._M_address = &__seq;
+#ifdef __GXX_RTTI
+	  _M_variant._M_sequence._M_type = &typeid(_Sequence);
+#else
+	  _M_variant._M_sequence._M_type = 0;
+#endif
+	}
+
+      void
+      _M_print_field(const _Error_formatter* __formatter,
+		     const char* __name) const;
+
+      void
+      _M_print_description(const _Error_formatter* __formatter) const;
+    };
+
+    friend struct _Parameter;
+
+  public:
+    template<typename _Iterator>
+      const _Error_formatter&
+      _M_iterator(const _Iterator& __it, const char* __name = 0)  const
+      {
+	if (_M_num_parameters < std::size_t(__max_parameters))
+	  _M_parameters[_M_num_parameters++] = _Parameter(__it, __name,
+							  _Is_iterator());
+	return *this;
+      }
+
+    const _Error_formatter&
+    _M_integer(long __value, const char* __name = 0) const
+    {
+      if (_M_num_parameters < std::size_t(__max_parameters))
+	_M_parameters[_M_num_parameters++] = _Parameter(__value, __name);
+      return *this;
+    }
+
+    const _Error_formatter&
+    _M_string(const char* __value, const char* __name = 0) const
+    {
+      if (_M_num_parameters < std::size_t(__max_parameters))
+	_M_parameters[_M_num_parameters++] = _Parameter(__value, __name);
+      return *this;
+    }
+
+    template<typename _Sequence>
+      const _Error_formatter&
+      _M_sequence(const _Sequence& __seq, const char* __name = 0) const
+      {
+	if (_M_num_parameters < std::size_t(__max_parameters))
+	  _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name,
+							  _Is_sequence());
+	return *this;
+      }
+
+    const _Error_formatter&
+    _M_message(const char* __text) const
+    { _M_text = __text; return *this; }
+
+    const _Error_formatter&
+    _M_message(_Debug_msg_id __id) const throw ();
+
+    _GLIBCXX_NORETURN void
+    _M_error() const;
+
+  private:
+    _Error_formatter(const char* __file, std::size_t __line)
+    : _M_file(__file), _M_line(__line), _M_num_parameters(0), _M_text(0),
+      _M_max_length(78), _M_column(1), _M_first_line(true), _M_wordwrap(false)
+    { _M_get_max_length(); }
+
+    template<typename _Tp>
+      void
+      _M_format_word(char*, int, const char*, _Tp) const throw ();
+
+    void
+    _M_print_word(const char* __word) const;
+
+    void
+    _M_print_string(const char* __string) const;
+
+    void
+    _M_get_max_length() const throw ();
+
+    enum { __max_parameters = 9 };
+
+    const char*         _M_file;
+    std::size_t         _M_line;
+    mutable _Parameter  _M_parameters[__max_parameters];
+    mutable std::size_t _M_num_parameters;
+    mutable const char* _M_text;
+    mutable std::size_t _M_max_length;
+    enum { _M_indent = 4 } ;
+    mutable std::size_t _M_column;
+    mutable bool        _M_first_line;
+    mutable bool        _M_wordwrap;
+
+  public:
+    static _Error_formatter
+    _M_at(const char* __file, std::size_t __line)
+    { return _Error_formatter(__file, __line); }
+  };
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/forward_list b/gcc-4.9/libstdc++-v3/include/debug/forward_list
new file mode 100644
index 0000000..12f6d7f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/forward_list
@@ -0,0 +1,811 @@
+// <forward_list> -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/forward_list
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_FORWARD_LIST
+#define _GLIBCXX_DEBUG_FORWARD_LIST 1
+
+#pragma GCC system_header
+
+#include <forward_list>
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::forward_list with safety/checking/debug instrumentation.
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class forward_list
+    : public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc>,
+      public __gnu_debug::_Safe_sequence<forward_list<_Tp, _Alloc> >
+    {
+      typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
+
+      typedef typename _Base::iterator       _Base_iterator;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type;
+
+      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
+
+    public:
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator,
+					  forward_list> iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
+					  forward_list> const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+
+      typedef _Tp                                   value_type;
+      typedef _Alloc                                allocator_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+
+      // 23.2.3.1 construct/copy/destroy:
+      explicit
+      forward_list(const _Alloc& __al = _Alloc())
+      : _Base(__al) { }
+
+      forward_list(const forward_list& __list, const _Alloc& __al)
+      : _Base(__list, __al)
+      { }
+
+      forward_list(forward_list&& __list, const _Alloc& __al)
+      : _Base(std::move(__list._M_base()), __al)
+      {
+	if (__list.get_allocator() == __al)
+	  this->_M_swap(__list);
+	else
+	  __list._M_invalidate_all();
+      }
+
+      explicit
+      forward_list(size_type __n, const _Alloc& __al = _Alloc())
+      : _Base(__n, __al)
+      { }
+
+      forward_list(size_type __n, const _Tp& __value,
+                   const _Alloc& __al = _Alloc())
+      : _Base(__n, __value, __al)
+      { }
+
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	forward_list(_InputIterator __first, _InputIterator __last,
+                     const _Alloc& __al = _Alloc())
+        : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __al)
+        { }
+
+      forward_list(const forward_list& __list)
+      : _Base(__list)
+      { }
+
+      forward_list(forward_list&& __list) noexcept
+      : _Base(std::move(__list._M_base()))
+      {
+	this->_M_swap(__list);
+      }
+
+      forward_list(std::initializer_list<_Tp> __il,
+                   const _Alloc& __al = _Alloc())
+      : _Base(__il, __al)
+      { }
+
+      ~forward_list() noexcept
+      { }
+
+      forward_list&
+      operator=(const forward_list& __list)
+      {
+	static_cast<_Base&>(*this) = __list;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      forward_list&
+      operator=(forward_list&& __list)
+      noexcept(_Node_alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__list);
+	bool __xfer_memory = _Node_alloc_traits::_S_propagate_on_move_assign()
+	    || __list.get_allocator() == this->get_allocator();
+	static_cast<_Base&>(*this) = std::move(__list);
+	if (__xfer_memory)
+	  this->_M_swap(__list);
+	else
+	  this->_M_invalidate_all();
+	__list._M_invalidate_all();
+	return *this;
+      }
+
+      forward_list&
+      operator=(std::initializer_list<_Tp> __il)
+      {
+	static_cast<_Base&>(*this) = __il;
+	this->_M_invalidate_all();
+        return *this;
+      }
+
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::assign(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  this->_M_invalidate_all();
+        }
+
+      void
+      assign(size_type __n, const _Tp& __val)
+      {
+	_Base::assign(__n, __val);
+	this->_M_invalidate_all();
+      }
+
+      void
+      assign(std::initializer_list<_Tp> __il)
+      {
+	_Base::assign(__il);
+	this->_M_invalidate_all();
+      }
+
+      using _Base::get_allocator;
+
+      // iterators:
+
+      iterator
+      before_begin() noexcept
+      { return iterator(_Base::before_begin(), this); }
+
+      const_iterator
+      before_begin() const noexcept
+      { return const_iterator(_Base::before_begin(), this); }
+
+      iterator
+      begin() noexcept
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() noexcept
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::cbegin(), this); }
+
+      const_iterator
+      cbefore_begin() const noexcept
+      { return const_iterator(_Base::cbefore_begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::cend(), this); }
+
+      using _Base::empty;
+      using _Base::max_size;
+
+      // element access:
+
+      reference
+      front()
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      const_reference
+      front() const
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      // modi�ers:
+
+      using _Base::emplace_front;
+      using _Base::push_front;
+
+      void
+      pop_front()
+      {
+	__glibcxx_check_nonempty();
+	this->_M_invalidate_if([this](_Base_const_iterator __it)
+	  { return __it == this->_M_base().cbegin(); });
+	_Base::pop_front();
+      }
+
+      template<typename... _Args>
+	iterator
+	emplace_after(const_iterator __pos, _Args&&... __args)
+	{
+	  __glibcxx_check_insert_after(__pos);
+	  return iterator(_Base::emplace_after(__pos.base(),
+					std::forward<_Args>(__args)...),
+			  this);
+       	}
+
+      iterator
+      insert_after(const_iterator __pos, const _Tp& __val)
+      {
+	__glibcxx_check_insert_after(__pos);
+	return iterator(_Base::insert_after(__pos.base(), __val), this);
+      }
+
+      iterator
+      insert_after(const_iterator __pos, _Tp&& __val)
+      {
+	__glibcxx_check_insert_after(__pos);
+	return iterator(_Base::insert_after(__pos.base(), std::move(__val)),
+		       	this);
+      }
+
+      iterator
+      insert_after(const_iterator __pos, size_type __n, const _Tp& __val)
+      {
+	__glibcxx_check_insert_after(__pos);
+	return iterator(_Base::insert_after(__pos.base(), __n, __val),
+		       	this);
+      }
+
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert_after(const_iterator __pos,
+                     _InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_insert_range_after(__pos, __first, __last);
+	  return iterator(_Base::insert_after(__pos.base(),
+					      __gnu_debug::__base(__first),
+					      __gnu_debug::__base(__last)),
+			  this);
+        }
+
+      iterator
+      insert_after(const_iterator __pos, std::initializer_list<_Tp> __il)
+      {
+	__glibcxx_check_insert_after(__pos);
+	return iterator(_Base::insert_after(__pos.base(), __il), this);
+      }
+
+    private:
+      _Base_iterator
+      _M_erase_after(_Base_const_iterator __pos)
+      {
+	_Base_const_iterator __next = std::next(__pos);
+	this->_M_invalidate_if([__next](_Base_const_iterator __it)
+	  { return __it == __next; });
+	return _Base::erase_after(__pos);
+      }
+    public:
+      iterator
+      erase_after(const_iterator __pos)
+      {
+	__glibcxx_check_erase_after(__pos);
+	return iterator(_M_erase_after(__pos.base()), this);
+      }
+
+      iterator
+      erase_after(const_iterator __pos, const_iterator __last)
+      {
+	__glibcxx_check_erase_range_after(__pos, __last);
+	for (_Base_const_iterator __victim = std::next(__pos.base());
+	    __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range2)
+				  ._M_sequence(*this, "this")
+				  ._M_iterator(__pos, "pos")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+	      { return __it == __victim; });
+	  }
+	return iterator(_Base::erase_after(__pos.base(), __last.base()), this);
+      }
+
+      void
+      swap(forward_list& __list)
+      noexcept(_Node_alloc_traits::_S_nothrow_swap())
+      {
+	if (!_Node_alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__list);
+	_Base::swap(__list);
+	this->_M_swap(__list);
+      }
+
+      void
+      resize(size_type __sz)
+      {
+	this->_M_detach_singular();
+
+	// if __sz < size(), invalidate all iterators in [begin+__sz, end()
+	_Base_iterator __victim = _Base::begin();
+	_Base_iterator __end = _Base::end();
+	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
+	  ++__victim;
+
+	for (; __victim != __end; ++__victim)
+	  {
+	    this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+	      { return __it == __victim; });
+	  }
+
+	__try
+	  {
+	    _Base::resize(__sz);
+	  }
+	__catch(...)
+	  {
+	    this->_M_revalidate_singular();
+	    __throw_exception_again;
+          }
+      }
+
+      void
+      resize(size_type __sz, const value_type& __val)
+      {
+	this->_M_detach_singular();
+
+	// if __sz < size(), invalidate all iterators in [begin+__sz, end())
+	_Base_iterator __victim = _Base::begin();
+	_Base_iterator __end = _Base::end();
+	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
+	  ++__victim;
+
+	for (; __victim != __end; ++__victim)
+	  {
+	    this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+	      { return __it == __victim; });
+	  }
+
+	__try
+	  {
+	    _Base::resize(__sz, __val);
+	  }
+	__catch(...)
+	  {
+	    this->_M_revalidate_singular();
+	    __throw_exception_again;
+          }
+      }
+
+      void
+      clear() noexcept
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+      }
+
+      // 23.2.3.5 forward_list operations:
+      void
+      splice_after(const_iterator __pos, forward_list&& __list)
+      {
+        __glibcxx_check_insert_after(__pos);
+	_GLIBCXX_DEBUG_VERIFY(&__list != this,
+			      _M_message(__gnu_debug::__msg_self_splice)
+			      ._M_sequence(*this, "this"));
+	_GLIBCXX_DEBUG_VERIFY(__list.get_allocator() == this->get_allocator(),
+			      _M_message(__gnu_debug::__msg_splice_alloc)
+			      ._M_sequence(*this)
+			      ._M_sequence(__list, "__list"));
+	this->_M_transfer_from_if(__list, [&__list](_Base_const_iterator __it)
+	  {
+	    return __it != __list._M_base().cbefore_begin()
+		   && __it != __list._M_base().end();
+	  });
+	_Base::splice_after(__pos.base(), std::move(__list._M_base()));
+      }
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list)
+      { splice_after(__pos, std::move(__list)); }
+
+      void
+      splice_after(const_iterator __pos, forward_list&& __list,
+		   const_iterator __i)
+      {
+	__glibcxx_check_insert_after(__pos);
+	_GLIBCXX_DEBUG_VERIFY(__i._M_before_dereferenceable(),
+			      _M_message(__gnu_debug::__msg_splice_bad)
+			      ._M_iterator(__i, "__i"));
+	_GLIBCXX_DEBUG_VERIFY(__i._M_attached_to(&__list),
+			      _M_message(__gnu_debug::__msg_splice_other)
+			      ._M_iterator(__i, "__i")
+			      ._M_sequence(__list, "__list"));
+	_GLIBCXX_DEBUG_VERIFY(__list.get_allocator() == this->get_allocator(),
+			      _M_message(__gnu_debug::__msg_splice_alloc)
+			      ._M_sequence(*this)
+			      ._M_sequence(__list, "__list"));
+
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 250. splicing invalidates iterators
+	_Base_const_iterator __next = std::next(__i.base());
+	this->_M_transfer_from_if(__list, [__next](_Base_const_iterator __it)
+	  { return __it == __next; });
+	_Base::splice_after(__pos.base(), std::move(__list._M_base()),
+			    __i.base());
+      }
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list,
+		   const_iterator __i)
+      { splice_after(__pos, std::move(__list), __i); }
+
+      void
+      splice_after(const_iterator __pos, forward_list&& __list,
+		   const_iterator __before, const_iterator __last)
+      {
+        __glibcxx_check_insert_after(__pos);
+	__glibcxx_check_valid_range(__before, __last);
+	_GLIBCXX_DEBUG_VERIFY(__before._M_attached_to(&__list),
+			      _M_message(__gnu_debug::__msg_splice_other)
+			      ._M_sequence(__list, "list")
+			      ._M_iterator(__before, "before"));
+	_GLIBCXX_DEBUG_VERIFY(__before._M_dereferenceable()
+			      || __before._M_is_before_begin(),
+			      _M_message(__gnu_debug::__msg_valid_range2)
+			      ._M_sequence(__list, "list")
+			      ._M_iterator(__before, "before")
+			      ._M_iterator(__last, "last"));
+	_GLIBCXX_DEBUG_VERIFY(__before != __last,
+			      _M_message(__gnu_debug::__msg_valid_range2)
+			      ._M_sequence(__list, "list")
+			      ._M_iterator(__before, "before")
+			      ._M_iterator(__last, "last"));
+	_GLIBCXX_DEBUG_VERIFY(__list.get_allocator() == this->get_allocator(),
+			      _M_message(__gnu_debug::__msg_splice_alloc)
+			      ._M_sequence(*this)
+			      ._M_sequence(__list, "__list"));
+
+	for (_Base_const_iterator __tmp = std::next(__before.base());
+	     __tmp != __last.base(); ++__tmp)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__tmp != __list._M_base().end(),
+				  _M_message(__gnu_debug::__msg_valid_range2)
+				  ._M_sequence(__list, "list")
+				  ._M_iterator(__before, "before")
+				  ._M_iterator(__last, "last"));
+	    _GLIBCXX_DEBUG_VERIFY(&__list != this || __tmp != __pos.base(),
+                                  _M_message(__gnu_debug::__msg_splice_overlap)
+                                  ._M_iterator(__tmp, "position")
+				  ._M_iterator(__before, "before")
+				  ._M_iterator(__last, "last"));
+	    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	    // 250. splicing invalidates iterators
+	    this->_M_transfer_from_if(__list, [__tmp](_Base_const_iterator __it)
+	      { return __it == __tmp; });
+	  }
+
+	_Base::splice_after(__pos.base(), std::move(__list._M_base()),
+			    __before.base(), __last.base());
+      }
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list,
+		   const_iterator __before, const_iterator __last)
+      { splice_after(__pos, std::move(__list), __before, __last); }
+
+      void
+      remove(const _Tp& __val)
+      {
+	_Base_iterator __x = _Base::before_begin();
+	_Base_iterator __old = __x++;
+	while (__x != _Base::end())
+	  {
+	    if (*__x == __val)
+	      __x = _M_erase_after(__old);
+	    else
+	      __old = __x++;
+	  }
+      }
+
+      template<typename _Pred>
+        void
+        remove_if(_Pred __pred)
+	{
+	  _Base_iterator __x = _Base::before_begin();
+	  _Base_iterator __old = __x++;
+	  while (__x != _Base::end())
+	    {
+	      if (__pred(*__x))
+		__x = _M_erase_after(__old);
+	      else
+		__old = __x++;
+	    }
+	}
+
+      void
+      unique()
+      {
+	_Base_iterator __first = _Base::begin();
+	_Base_iterator __last = _Base::end();
+	if (__first == __last)
+	  return;
+	_Base_iterator __next = std::next(__first);
+	while (__next != __last)
+	  {
+	    if (*__first == *__next)
+	      __next = _M_erase_after(__first);
+	    else
+	      __first = __next++;
+	  }
+      }
+
+      template<typename _BinPred>
+        void
+        unique(_BinPred __binary_pred)
+	{
+	  _Base_iterator __first = _Base::begin();
+	  _Base_iterator __last = _Base::end();
+	  if (__first == __last)
+	    return;
+	  _Base_iterator __next = std::next(__first);
+	  while (__next != __last)
+	    {
+	      if (__binary_pred(*__first, *__next))
+		__next = _M_erase_after(__first);
+	      else
+		__first = __next++;
+	    }
+	}
+
+      void
+      merge(forward_list&& __list)
+      {
+	if (this != &__list)
+	{
+	  __glibcxx_check_sorted(_Base::begin(), _Base::end());
+	  __glibcxx_check_sorted(__list._M_base().begin(),
+				 __list._M_base().end());
+	  this->_M_transfer_from_if(__list, [&__list](_Base_const_iterator __it)
+	    {
+	      return __it != __list._M_base().cbefore_begin()
+		     && __it != __list._M_base().cend();
+	    });
+	  _Base::merge(std::move(__list._M_base()));
+	}
+      }
+
+      void
+      merge(forward_list& __list)
+      { merge(std::move(__list)); }
+
+      template<typename _Comp>
+        void
+        merge(forward_list&& __list, _Comp __comp)
+	{
+	  if (this != &__list)
+	  {
+	    __glibcxx_check_sorted_pred(_Base::begin(), _Base::end(), __comp);
+	    __glibcxx_check_sorted_pred(__list._M_base().begin(),
+					__list._M_base().end(), __comp);
+	    this->_M_transfer_from_if(__list,
+				      [&__list](_Base_const_iterator __it)
+	      {
+	        return __it != __list._M_base().cbefore_begin()
+		       && __it != __list._M_base().cend();
+	      });
+	    _Base::merge(std::move(__list._M_base()), __comp);
+	  }
+	}
+
+      template<typename _Comp>
+        void
+        merge(forward_list& __list, _Comp __comp)
+        { merge(std::move(__list), __comp); }
+
+      using _Base::sort;
+      using _Base::reverse;
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    private:
+      void
+      _M_invalidate_all()
+      {
+	this->_M_invalidate_if([this](_Base_const_iterator __it)
+	  {
+	    return __it != this->_M_base().cbefore_begin()
+		   && __it != this->_M_base().cend();
+	  });
+      }
+      typedef __gnu_debug::_Safe_iterator_base _Safe_iterator_base;
+      static void
+      _M_swap_aux(forward_list& __lhs,
+		  _Safe_iterator_base*& __lhs_iterators,
+		  forward_list& __rhs,
+		  _Safe_iterator_base*& __rhs_iterators);
+      void _M_swap(forward_list& __list);
+    };
+
+   template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    _M_swap_aux(forward_list<_Tp, _Alloc>& __lhs,
+		__gnu_debug::_Safe_iterator_base*& __lhs_iterators,
+		forward_list<_Tp, _Alloc>& __rhs,
+		__gnu_debug::_Safe_iterator_base*& __rhs_iterators)
+    {
+      using __gnu_debug::_Safe_iterator_base;
+      _Safe_iterator_base* __bbegin_its = 0;
+      _Safe_iterator_base* __last_bbegin = 0;
+      for (_Safe_iterator_base* __iter = __lhs_iterators; __iter;)
+	{
+	  // Even iterator are casted to const_iterator, not a problem.
+	  const_iterator* __victim = static_cast<const_iterator*>(__iter);
+	  __iter = __iter->_M_next;
+	  if (__victim->base() == __rhs._M_base().cbefore_begin())
+	    {
+	      __victim->_M_unlink();
+	      if (__lhs_iterators == __victim)
+		__lhs_iterators = __victim->_M_next;
+	      if (__bbegin_its)
+		{
+		  __victim->_M_next = __bbegin_its;
+		  __bbegin_its->_M_prior = __victim;
+		}
+	      else
+		__last_bbegin = __victim;
+	      __bbegin_its = __victim;
+	    }
+	  else
+	    __victim->_M_sequence = &__lhs;
+	}
+
+      if (__bbegin_its)
+	{
+	  if (__rhs_iterators)
+	    {
+	      __rhs_iterators->_M_prior = __last_bbegin;
+	      __last_bbegin->_M_next = __rhs_iterators;
+	    }
+	  __rhs_iterators = __bbegin_its;
+	}
+    }
+
+  /* Special forward_list _M_swap version that do not swap the
+   * before-begin ownership.*/
+  template<typename _Tp, typename _Alloc>
+    void
+    forward_list<_Tp, _Alloc>::
+    _M_swap(forward_list<_Tp, _Alloc>& __list)
+    {
+      __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
+      std::swap(this->_M_iterators, __list._M_iterators);
+      std::swap(this->_M_const_iterators, __list._M_const_iterators);
+      // Useless, always 1 on forward_list
+      //std::swap(this->_M_version, __list._M_version);
+      _Safe_iterator_base* __this_its = this->_M_iterators;
+      _M_swap_aux(__list, __list._M_iterators, *this, this->_M_iterators);
+      _Safe_iterator_base* __this_const_its = this->_M_const_iterators;
+      _M_swap_aux(__list, __list._M_const_iterators, *this,
+		  this->_M_const_iterators);
+      _M_swap_aux(*this, __this_its, __list, __list._M_iterators);
+      _M_swap_aux(*this, __this_const_its, __list, __list._M_const_iterators);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    bool
+    operator==(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return __lx._M_base() == __ly._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const forward_list<_Tp, _Alloc>& __lx,
+              const forward_list<_Tp, _Alloc>& __ly)
+    { return __lx._M_base() < __ly._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__lx == __ly); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const forward_list<_Tp, _Alloc>& __lx,
+              const forward_list<_Tp, _Alloc>& __ly)
+    { return (__ly < __lx); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__lx < __ly); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__ly < __lx); }
+
+  /// See std::forward_list::swap().
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(forward_list<_Tp, _Alloc>& __lx,
+	 forward_list<_Tp, _Alloc>& __ly)
+    { __lx.swap(__ly); }
+
+} // namespace __debug
+} // namespace std
+
+namespace __gnu_debug
+{
+  template<class _Tp, class _Alloc>
+    struct _BeforeBeginHelper<std::__debug::forward_list<_Tp, _Alloc> >
+    {
+      typedef std::__debug::forward_list<_Tp, _Alloc> _Sequence;
+
+      template<typename _Iterator>
+	static bool
+	_S_Is(const _Safe_iterator<_Iterator, _Sequence>& __it)
+	{
+	  return
+	    __it.base() == __it._M_get_sequence()->_M_base().before_begin();
+	}
+
+      template<typename _Iterator>
+	static bool
+	_S_Is_Beginnest(const _Safe_iterator<_Iterator, _Sequence>& __it)
+	{ return _S_Is(__it); }
+    };
+
+#ifndef _GLIBCXX_DEBUG_PEDANTIC
+  template<class _Tp, class _Alloc>
+    struct _Insert_range_from_self_is_safe<
+      std::__debug::forward_list<_Tp, _Alloc> >
+    { enum { __value = 1 }; };
+#endif
+}
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/functions.h b/gcc-4.9/libstdc++-v3/include/debug/functions.h
new file mode 100644
index 0000000..b48c36d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/functions.h
@@ -0,0 +1,554 @@
+// Debugging support implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/functions.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_FUNCTIONS_H
+#define _GLIBCXX_DEBUG_FUNCTIONS_H 1
+
+#include <bits/c++config.h>
+#include <bits/stl_iterator_base_types.h> // for iterator_traits, categories and
+					  // _Iter_base
+#include <bits/cpp_type_traits.h>	  // for __is_integer
+#include <bits/move.h>                    // for __addressof and addressof
+# include <bits/stl_function.h>		  // for less
+#if __cplusplus >= 201103L
+# include <type_traits>			  // for is_lvalue_reference and __and_
+#endif
+#include <debug/formatter.h>
+
+namespace __gnu_debug
+{
+  template<typename _Iterator, typename _Sequence>
+    class _Safe_iterator;
+
+  template<typename _Iterator, typename _Sequence>
+    class _Safe_local_iterator;
+
+  template<typename _Sequence>
+    struct _Insert_range_from_self_is_safe
+    { enum { __value = 0 }; };
+
+  template<typename _Sequence>
+    struct _Is_contiguous_sequence : std::__false_type { };
+
+  // An arbitrary iterator pointer is not singular.
+  inline bool
+  __check_singular_aux(const void*) { return false; }
+
+  // We may have an iterator that derives from _Safe_iterator_base but isn't
+  // a _Safe_iterator.
+  template<typename _Iterator>
+    inline bool
+    __check_singular(const _Iterator& __x)
+    { return __check_singular_aux(&__x); }
+
+  /** Non-NULL pointers are nonsingular. */
+  template<typename _Tp>
+    inline bool
+    __check_singular(const _Tp* __ptr)
+    { return __ptr == 0; }
+
+  /** Assume that some arbitrary iterator is dereferenceable, because we
+      can't prove that it isn't. */
+  template<typename _Iterator>
+    inline bool
+    __check_dereferenceable(const _Iterator&)
+    { return true; }
+
+  /** Non-NULL pointers are dereferenceable. */
+  template<typename _Tp>
+    inline bool
+    __check_dereferenceable(const _Tp* __ptr)
+    { return __ptr; }
+
+  /** Safe iterators know if they are dereferenceable. */
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    __check_dereferenceable(const _Safe_iterator<_Iterator, _Sequence>& __x)
+    { return __x._M_dereferenceable(); }
+
+  /** Safe local iterators know if they are dereferenceable. */
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    __check_dereferenceable(const _Safe_local_iterator<_Iterator,
+						       _Sequence>& __x)
+    { return __x._M_dereferenceable(); }
+
+  /** If the distance between two random access iterators is
+   *  nonnegative, assume the range is valid.
+  */
+  template<typename _RandomAccessIterator>
+    inline bool
+    __valid_range_aux2(const _RandomAccessIterator& __first,
+		       const _RandomAccessIterator& __last,
+		       std::random_access_iterator_tag)
+    { return __last - __first >= 0; }
+
+  /** Can't test for a valid range with input iterators, because
+   *  iteration may be destructive. So we just assume that the range
+   *  is valid.
+  */
+  template<typename _InputIterator>
+    inline bool
+    __valid_range_aux2(const _InputIterator&, const _InputIterator&,
+		       std::input_iterator_tag)
+    { return true; }
+
+  /** We say that integral types for a valid range, and defer to other
+   *  routines to realize what to do with integral types instead of
+   *  iterators.
+  */
+  template<typename _Integral>
+    inline bool
+    __valid_range_aux(const _Integral&, const _Integral&, std::__true_type)
+    { return true; }
+
+  /** We have iterators, so figure out what kind of iterators that are
+   *  to see if we can check the range ahead of time.
+  */
+  template<typename _InputIterator>
+    inline bool
+    __valid_range_aux(const _InputIterator& __first,
+		      const _InputIterator& __last, std::__false_type)
+    { return __valid_range_aux2(__first, __last,
+				std::__iterator_category(__first)); }
+
+  /** Don't know what these iterators are, or if they are even
+   *  iterators (we may get an integral type for InputIterator), so
+   *  see if they are integral and pass them on to the next phase
+   *  otherwise.
+  */
+  template<typename _InputIterator>
+    inline bool
+    __valid_range(const _InputIterator& __first, const _InputIterator& __last)
+    {
+      typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+      return __valid_range_aux(__first, __last, _Integral());
+    }
+
+  /** Safe iterators know how to check if they form a valid range. */
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    __valid_range(const _Safe_iterator<_Iterator, _Sequence>& __first,
+		  const _Safe_iterator<_Iterator, _Sequence>& __last)
+    { return __first._M_valid_range(__last); }
+
+  /** Safe local iterators know how to check if they form a valid range. */
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    __valid_range(const _Safe_local_iterator<_Iterator, _Sequence>& __first,
+		  const _Safe_local_iterator<_Iterator, _Sequence>& __last)
+    { return __first._M_valid_range(__last); }
+
+  /* Checks that [first, last) is a valid range, and then returns
+   * __first. This routine is useful when we can't use a separate
+   * assertion statement because, e.g., we are in a constructor.
+  */
+  template<typename _InputIterator>
+    inline _InputIterator
+    __check_valid_range(const _InputIterator& __first,
+			const _InputIterator& __last
+			__attribute__((__unused__)))
+    {
+      __glibcxx_check_valid_range(__first, __last);
+      return __first;
+    }
+
+  /* Handle the case where __other is a pointer to _Sequence::value_type. */
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    __foreign_iterator_aux4(const _Safe_iterator<_Iterator, _Sequence>& __it,
+			    const typename _Sequence::value_type* __other)
+    {
+      typedef const typename _Sequence::value_type* _PointerType;
+      typedef std::less<_PointerType> _Less;
+#if __cplusplus >= 201103L
+      constexpr _Less __l{};
+#else
+      const _Less __l = _Less();
+#endif
+      const _Sequence* __seq = __it._M_get_sequence();
+      const _PointerType __begin = std::__addressof(*__seq->_M_base().begin());
+      const _PointerType __end = std::__addressof(*(__seq->_M_base().end()-1));
+
+      // Check whether __other points within the contiguous storage.
+      return __l(__other, __begin) || __l(__end, __other);
+    }
+
+  /* Fallback overload for when we can't tell, assume it is valid. */
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    __foreign_iterator_aux4(const _Safe_iterator<_Iterator, _Sequence>&, ...)
+    { return true; }
+
+  /* Handle sequences with contiguous storage */
+  template<typename _Iterator, typename _Sequence, typename _InputIterator>
+    inline bool
+    __foreign_iterator_aux3(const _Safe_iterator<_Iterator, _Sequence>& __it,
+			    const _InputIterator& __other,
+			    const _InputIterator& __other_end,
+			    std::__true_type)
+    {
+      if (__other == __other_end)
+	return true;  // inserting nothing is safe even if not foreign iters
+      if (__it._M_get_sequence()->begin() == __it._M_get_sequence()->end())
+	return true;  // can't be self-inserting if self is empty
+      return __foreign_iterator_aux4(__it, std::__addressof(*__other));
+    }
+
+  /* Handle non-contiguous containers, assume it is valid. */
+  template<typename _Iterator, typename _Sequence, typename _InputIterator>
+    inline bool
+    __foreign_iterator_aux3(const _Safe_iterator<_Iterator, _Sequence>&,
+			    const _InputIterator&, const _InputIterator&,
+			    std::__false_type)
+    { return true; }
+
+  /** Handle debug iterators from the same type of container. */
+  template<typename _Iterator, typename _Sequence, typename _OtherIterator>
+    inline bool
+    __foreign_iterator_aux2(const _Safe_iterator<_Iterator, _Sequence>& __it,
+		const _Safe_iterator<_OtherIterator, _Sequence>& __other,
+		const _Safe_iterator<_OtherIterator, _Sequence>&)
+    { return __it._M_get_sequence() != __other._M_get_sequence(); }
+
+  /** Handle debug iterators from different types of container. */
+  template<typename _Iterator, typename _Sequence, typename _OtherIterator,
+	   typename _OtherSequence>
+    inline bool
+    __foreign_iterator_aux2(const _Safe_iterator<_Iterator, _Sequence>& __it,
+		const _Safe_iterator<_OtherIterator, _OtherSequence>&,
+		const _Safe_iterator<_OtherIterator, _OtherSequence>&)
+    { return true; }
+
+  /* Handle non-debug iterators. */
+  template<typename _Iterator, typename _Sequence, typename _InputIterator>
+    inline bool
+    __foreign_iterator_aux2(const _Safe_iterator<_Iterator, _Sequence>& __it,
+			    const _InputIterator& __other,
+			    const _InputIterator& __other_end)
+    {
+      return __foreign_iterator_aux3(__it, __other, __other_end,
+				     _Is_contiguous_sequence<_Sequence>());
+    }
+
+  /* Handle the case where we aren't really inserting a range after all */
+  template<typename _Iterator, typename _Sequence, typename _Integral>
+    inline bool
+    __foreign_iterator_aux(const _Safe_iterator<_Iterator, _Sequence>&,
+			   _Integral, _Integral,
+			   std::__true_type)
+    { return true; }
+
+  /* Handle all iterators. */
+  template<typename _Iterator, typename _Sequence,
+	   typename _InputIterator>
+    inline bool
+    __foreign_iterator_aux(const _Safe_iterator<_Iterator, _Sequence>& __it,
+			   _InputIterator __other, _InputIterator __other_end,
+			   std::__false_type)
+    {
+      return _Insert_range_from_self_is_safe<_Sequence>::__value
+	     || __foreign_iterator_aux2(__it, __other, __other_end);
+    }
+
+  template<typename _Iterator, typename _Sequence,
+	   typename _InputIterator>
+    inline bool
+    __foreign_iterator(const _Safe_iterator<_Iterator, _Sequence>& __it,
+		       _InputIterator __other, _InputIterator __other_end)
+    {
+      typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+      return __foreign_iterator_aux(__it, __other, __other_end, _Integral());
+    }
+
+  /** Checks that __s is non-NULL or __n == 0, and then returns __s. */
+  template<typename _CharT, typename _Integer>
+    inline const _CharT*
+    __check_string(const _CharT* __s,
+		   const _Integer& __n __attribute__((__unused__)))
+    {
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+      __glibcxx_assert(__s != 0 || __n == 0);
+#endif
+      return __s;
+    }
+
+  /** Checks that __s is non-NULL and then returns __s. */
+  template<typename _CharT>
+    inline const _CharT*
+    __check_string(const _CharT* __s)
+    {
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+      __glibcxx_assert(__s != 0);
+#endif
+      return __s;
+    }
+
+  // Can't check if an input iterator sequence is sorted, because we
+  // can't step through the sequence.
+  template<typename _InputIterator>
+    inline bool
+    __check_sorted_aux(const _InputIterator&, const _InputIterator&,
+                       std::input_iterator_tag)
+    { return true; }
+
+  // Can verify if a forward iterator sequence is in fact sorted using
+  // std::__is_sorted
+  template<typename _ForwardIterator>
+    inline bool
+    __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
+                       std::forward_iterator_tag)
+    {
+      if (__first == __last)
+        return true;
+
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, ++__next)
+        if (*__next < *__first)
+          return false;
+
+      return true;
+    }
+
+  // Can't check if an input iterator sequence is sorted, because we can't step
+  // through the sequence.
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    __check_sorted_aux(const _InputIterator&, const _InputIterator&,
+                       _Predicate, std::input_iterator_tag)
+    { return true; }
+
+  // Can verify if a forward iterator sequence is in fact sorted using
+  // std::__is_sorted
+  template<typename _ForwardIterator, typename _Predicate>
+    inline bool
+    __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
+                       _Predicate __pred, std::forward_iterator_tag)
+    {
+      if (__first == __last)
+        return true;
+
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, ++__next)
+        if (__pred(*__next, *__first))
+          return false;
+
+      return true;
+    }
+
+  // Determine if a sequence is sorted.
+  template<typename _InputIterator>
+    inline bool
+    __check_sorted(const _InputIterator& __first, const _InputIterator& __last)
+    {
+      // Verify that the < operator for elements in the sequence is a
+      // StrictWeakOrdering by checking that it is irreflexive.
+      __glibcxx_assert(__first == __last || !(*__first < *__first));
+
+      return __check_sorted_aux(__first, __last,
+				std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    __check_sorted(const _InputIterator& __first, const _InputIterator& __last,
+                   _Predicate __pred)
+    {
+      // Verify that the predicate is StrictWeakOrdering by checking that it
+      // is irreflexive.
+      __glibcxx_assert(__first == __last || !__pred(*__first, *__first));
+
+      return __check_sorted_aux(__first, __last, __pred,
+				std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator>
+    inline bool
+    __check_sorted_set_aux(const _InputIterator& __first,
+			   const _InputIterator& __last,
+			   std::__true_type)
+    { return __check_sorted(__first, __last); }
+
+  template<typename _InputIterator>
+    inline bool
+    __check_sorted_set_aux(const _InputIterator&,
+			   const _InputIterator&,
+			   std::__false_type)
+    { return true; }
+
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    __check_sorted_set_aux(const _InputIterator& __first,
+			   const _InputIterator& __last,
+			   _Predicate __pred, std::__true_type)
+    { return __check_sorted(__first, __last, __pred); }
+
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    __check_sorted_set_aux(const _InputIterator&,
+			   const _InputIterator&, _Predicate,
+			   std::__false_type)
+    { return true; }
+
+  // ... special variant used in std::merge, std::includes, std::set_*.
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline bool
+    __check_sorted_set(const _InputIterator1& __first,
+		       const _InputIterator1& __last,
+		       const _InputIterator2&)
+    {
+      typedef typename std::iterator_traits<_InputIterator1>::value_type
+	_ValueType1;
+      typedef typename std::iterator_traits<_InputIterator2>::value_type
+	_ValueType2;
+
+      typedef typename std::__are_same<_ValueType1, _ValueType2>::__type
+	_SameType;
+      return __check_sorted_set_aux(__first, __last, _SameType());
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _Predicate>
+    inline bool
+    __check_sorted_set(const _InputIterator1& __first,
+		       const _InputIterator1& __last,
+		       const _InputIterator2&, _Predicate __pred)
+    {
+      typedef typename std::iterator_traits<_InputIterator1>::value_type
+	_ValueType1;
+      typedef typename std::iterator_traits<_InputIterator2>::value_type
+	_ValueType2;
+
+      typedef typename std::__are_same<_ValueType1, _ValueType2>::__type
+	_SameType;
+      return __check_sorted_set_aux(__first, __last, __pred, _SameType());
+   }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 270. Binary search requirements overly strict
+  // Determine if a sequence is partitioned w.r.t. this element.
+  template<typename _ForwardIterator, typename _Tp>
+    inline bool
+    __check_partitioned_lower(_ForwardIterator __first,
+			      _ForwardIterator __last, const _Tp& __value)
+    {
+      while (__first != __last && *__first < __value)
+	++__first;
+      if (__first != __last)
+	{
+	  ++__first;
+	  while (__first != __last && !(*__first < __value))
+	    ++__first;
+	}
+      return __first == __last;
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline bool
+    __check_partitioned_upper(_ForwardIterator __first,
+			      _ForwardIterator __last, const _Tp& __value)
+    {
+      while (__first != __last && !(__value < *__first))
+	++__first;
+      if (__first != __last)
+	{
+	  ++__first;
+	  while (__first != __last && __value < *__first)
+	    ++__first;
+	}
+      return __first == __last;
+    }
+
+  // Determine if a sequence is partitioned w.r.t. this element.
+  template<typename _ForwardIterator, typename _Tp, typename _Pred>
+    inline bool
+    __check_partitioned_lower(_ForwardIterator __first,
+			      _ForwardIterator __last, const _Tp& __value,
+			      _Pred __pred)
+    {
+      while (__first != __last && bool(__pred(*__first, __value)))
+	++__first;
+      if (__first != __last)
+	{
+	  ++__first;
+	  while (__first != __last && !bool(__pred(*__first, __value)))
+	    ++__first;
+	}
+      return __first == __last;
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Pred>
+    inline bool
+    __check_partitioned_upper(_ForwardIterator __first,
+			      _ForwardIterator __last, const _Tp& __value,
+			      _Pred __pred)
+    {
+      while (__first != __last && !bool(__pred(__value, *__first)))
+	++__first;
+      if (__first != __last)
+	{
+	  ++__first;
+	  while (__first != __last && bool(__pred(__value, *__first)))
+	    ++__first;
+	}
+      return __first == __last;
+    }
+
+  // Helper struct to detect random access safe iterators.
+  template<typename _Iterator>
+    struct __is_safe_random_iterator
+    {
+      enum { __value = 0 };
+      typedef std::__false_type __type;
+    };
+
+  template<typename _Iterator, typename _Sequence>
+    struct __is_safe_random_iterator<_Safe_iterator<_Iterator, _Sequence> >
+    : std::__are_same<std::random_access_iterator_tag,
+                      typename std::iterator_traits<_Iterator>::
+		      iterator_category>
+    { };
+
+  template<typename _Iterator>
+    struct _Siter_base
+    : std::_Iter_base<_Iterator, __is_safe_random_iterator<_Iterator>::__value>
+    { };
+
+  /** Helper function to extract base iterator of random access safe iterator
+      in order to reduce performance impact of debug mode.  Limited to random
+      access iterator because it is the only category for which it is possible
+      to check for correct iterators order in the __valid_range function
+      thanks to the < operator.
+  */
+  template<typename _Iterator>
+    inline typename _Siter_base<_Iterator>::iterator_type
+    __base(_Iterator __it)
+    { return _Siter_base<_Iterator>::_S_base(__it); }
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/list b/gcc-4.9/libstdc++-v3/include/debug/list
new file mode 100644
index 0000000..9918bc5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/list
@@ -0,0 +1,807 @@
+// Debugging list implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/list
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_LIST
+#define _GLIBCXX_DEBUG_LIST 1
+
+#include <list>
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::list with safety/checking/debug instrumentation.
+  template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
+    class list
+    : public _GLIBCXX_STD_C::list<_Tp, _Allocator>,
+      public __gnu_debug::_Safe_sequence<list<_Tp, _Allocator> >
+    {
+      typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
+
+      typedef typename _Base::iterator       _Base_iterator;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+      typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
+    public:
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator, list>
+						    iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, list>
+						    const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+
+      typedef _Tp				    value_type;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      // 23.2.2.1 construct/copy/destroy:
+
+      list() _GLIBCXX_NOEXCEPT
+      : _Base() { }
+
+      explicit
+      list(const _Allocator& __a) _GLIBCXX_NOEXCEPT
+      : _Base(__a) { }
+
+#if __cplusplus >= 201103L
+      explicit
+      list(size_type __n)
+      : _Base(__n) { }
+
+      list(size_type __n, const _Tp& __value,
+	   const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) { }
+#else
+      explicit
+      list(size_type __n, const _Tp& __value = _Tp(),
+	   const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) { }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+	list(_InputIterator __first, _InputIterator __last,
+	     const _Allocator& __a = _Allocator())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __a)
+        { }
+
+      list(const list& __x)
+      : _Base(__x) { }
+
+      list(const _Base& __x)
+      : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      list(list&& __x) noexcept
+      : _Base(std::move(__x))
+      { this->_M_swap(__x); }
+
+      list(initializer_list<value_type> __l,
+           const allocator_type& __a = allocator_type())
+        : _Base(__l, __a) { }
+#endif
+
+      ~list() _GLIBCXX_NOEXCEPT { }
+
+      list&
+      operator=(const list& __x)
+      {
+	static_cast<_Base&>(*this) = __x;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      list&
+      operator=(list&& __x)
+      {
+	// NB: DR 1204.
+	// NB: DR 675.
+	__glibcxx_check_self_move_assign(__x);
+	clear();
+	swap(__x);
+      	return *this;
+      }
+
+      list&
+      operator=(initializer_list<value_type> __l)
+      {
+	static_cast<_Base&>(*this) = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      void
+      assign(initializer_list<value_type> __l)
+      {
+	_Base::assign(__l);
+	this->_M_invalidate_all();
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::assign(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  this->_M_invalidate_all();
+	}
+
+      void
+      assign(size_type __n, const _Tp& __t)
+      {
+	_Base::assign(__n, __t);
+	this->_M_invalidate_all();
+      }
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // 23.2.2.2 capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+#if __cplusplus >= 201103L
+      void
+      resize(size_type __sz)
+      {
+	this->_M_detach_singular();
+
+	// if __sz < size(), invalidate all iterators in [begin+__sz, end())
+	_Base_iterator __victim = _Base::begin();
+	_Base_iterator __end = _Base::end();
+	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
+	  ++__victim;
+
+	for (; __victim != __end; ++__victim)
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+
+	__try
+	  {
+	    _Base::resize(__sz);
+	  }
+	__catch(...)
+	  {
+	    this->_M_revalidate_singular();
+	    __throw_exception_again;
+	  }
+      }
+
+      void
+      resize(size_type __sz, const _Tp& __c)
+      {
+	this->_M_detach_singular();
+
+	// if __sz < size(), invalidate all iterators in [begin+__sz, end())
+	_Base_iterator __victim = _Base::begin();
+	_Base_iterator __end = _Base::end();
+	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
+	  ++__victim;
+
+	for (; __victim != __end; ++__victim)
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+
+	__try
+	  {
+	    _Base::resize(__sz, __c);
+	  }
+	__catch(...)
+	  {
+	    this->_M_revalidate_singular();
+	    __throw_exception_again;
+	  }
+      }
+#else
+      void
+      resize(size_type __sz, _Tp __c = _Tp())
+      {
+	this->_M_detach_singular();
+
+	// if __sz < size(), invalidate all iterators in [begin+__sz, end())
+	_Base_iterator __victim = _Base::begin();
+	_Base_iterator __end = _Base::end();
+	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
+	  ++__victim;
+
+	for (; __victim != __end; ++__victim)
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+
+	__try
+	  {
+	    _Base::resize(__sz, __c);
+	  }
+	__catch(...)
+	  {
+	    this->_M_revalidate_singular();
+	    __throw_exception_again;
+	  }
+      }
+#endif
+
+      // element access:
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::back();
+      }
+
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::back();
+      }
+
+      // 23.2.2.3 modifiers:
+      using _Base::push_front;
+
+#if __cplusplus >= 201103L
+      using _Base::emplace_front;
+#endif
+
+      void
+      pop_front() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	this->_M_invalidate_if(_Equal(_Base::begin()));
+	_Base::pop_front();
+      }
+
+      using _Base::push_back;
+
+#if __cplusplus >= 201103L
+      using _Base::emplace_back;
+#endif
+
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	this->_M_invalidate_if(_Equal(--_Base::end()));
+	_Base::pop_back();
+      }
+
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__position);
+	  return iterator(_Base::emplace(__position.base(),
+					std::forward<_Args>(__args)...), this);
+	}
+#endif
+
+     iterator
+#if __cplusplus >= 201103L
+     insert(const_iterator __position, const _Tp& __x)
+#else
+     insert(iterator __position, const _Tp& __x)
+#endif
+     {
+       __glibcxx_check_insert(__position);
+       return iterator(_Base::insert(__position.base(), __x), this);
+     }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, _Tp&& __x)
+      { return emplace(__position, std::move(__x)); }
+
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      {
+	__glibcxx_check_insert(__p);
+	return iterator(_Base::insert(__p.base(), __l), this);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, size_type __n, const _Tp& __x)
+      {
+	__glibcxx_check_insert(__position);
+	return iterator(_Base::insert(__position.base(), __n, __x), this);
+      }
+#else
+      void
+      insert(iterator __position, size_type __n, const _Tp& __x)
+      {
+	__glibcxx_check_insert(__position);
+	_Base::insert(__position.base(), __n, __x);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	iterator
+        insert(const_iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+        {
+	  __glibcxx_check_insert_range(__position, __first, __last);
+	  return iterator(_Base::insert(__position.base(),
+					__gnu_debug::__base(__first),
+					__gnu_debug::__base(__last)),
+			  this);
+	}
+#else
+      template<class _InputIterator>
+	void
+        insert(iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+        {
+	  __glibcxx_check_insert_range(__position, __first, __last);
+	  _Base::insert(__position.base(), __gnu_debug::__base(__first),
+					   __gnu_debug::__base(__last));
+	}
+#endif
+
+    private:
+      _Base_iterator
+#if __cplusplus >= 201103L
+      _M_erase(_Base_const_iterator __position) noexcept
+#else
+      _M_erase(_Base_iterator __position)
+#endif
+      {
+	this->_M_invalidate_if(_Equal(__position));
+	return _Base::erase(__position);
+      }
+
+    public:
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position) noexcept
+#else
+      erase(iterator __position)
+#endif
+      {
+	__glibcxx_check_erase(__position);
+	return iterator(_M_erase(__position.base()), this);
+      }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last) noexcept
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+			          _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "position")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	return iterator(_Base::erase(__first.base(), __last.base()), this);
+      }
+
+      void
+      swap(list& __x)
+      {
+	_Base::swap(__x);
+	this->_M_swap(__x);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+      }
+
+      // 23.2.2.4 list operations:
+      void
+#if __cplusplus >= 201103L
+      splice(const_iterator __position, list&& __x) noexcept
+#else
+      splice(iterator __position, list& __x)
+#endif
+      {
+	_GLIBCXX_DEBUG_VERIFY(&__x != this,
+			      _M_message(__gnu_debug::__msg_self_splice)
+			      ._M_sequence(*this, "this"));
+	this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
+	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()));
+      }
+
+#if __cplusplus >= 201103L
+      void
+      splice(const_iterator __position, list& __x) noexcept
+      { splice(__position, std::move(__x)); }
+#endif
+
+      void
+#if __cplusplus >= 201103L
+      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
+#else
+      splice(iterator __position, list& __x, iterator __i)
+#endif
+      {
+	__glibcxx_check_insert(__position);
+
+	// We used to perform the splice_alloc check:  not anymore, redundant
+	// after implementing the relevant bits of N1599.
+
+	_GLIBCXX_DEBUG_VERIFY(__i._M_dereferenceable(),
+			      _M_message(__gnu_debug::__msg_splice_bad)
+			      ._M_iterator(__i, "__i"));
+	_GLIBCXX_DEBUG_VERIFY(__i._M_attached_to(&__x),
+			      _M_message(__gnu_debug::__msg_splice_other)
+			     ._M_iterator(__i, "__i")._M_sequence(__x, "__x"));
+
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 250. splicing invalidates iterators
+	this->_M_transfer_from_if(__x, _Equal(__i.base()));
+	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
+		      __i.base());
+      }
+
+#if __cplusplus >= 201103L
+      void
+      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
+      { splice(__position, std::move(__x), __i); }
+#endif
+
+      void
+#if __cplusplus >= 201103L
+      splice(const_iterator __position, list&& __x, const_iterator __first,
+	     const_iterator __last) noexcept
+#else
+      splice(iterator __position, list& __x, iterator __first,
+	     iterator __last)
+#endif
+      {
+	__glibcxx_check_insert(__position);
+	__glibcxx_check_valid_range(__first, __last);
+	_GLIBCXX_DEBUG_VERIFY(__first._M_attached_to(&__x),
+			      _M_message(__gnu_debug::__msg_splice_other)
+			      ._M_sequence(__x, "x")
+			      ._M_iterator(__first, "first"));
+
+	// We used to perform the splice_alloc check:  not anymore, redundant
+	// after implementing the relevant bits of N1599.
+
+	for (_Base_const_iterator __tmp = __first.base();
+	     __tmp != __last.base(); ++__tmp)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    _GLIBCXX_DEBUG_VERIFY(&__x != this || __tmp != __position.base(),
+				_M_message(__gnu_debug::__msg_splice_overlap)
+				  ._M_iterator(__tmp, "position")
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	    // 250. splicing invalidates iterators
+	    this->_M_transfer_from_if(__x, _Equal(__tmp));
+	  }
+
+	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
+		      __first.base(), __last.base());
+      }
+
+#if __cplusplus >= 201103L
+      void
+      splice(const_iterator __position, list& __x,
+	     const_iterator __first, const_iterator __last) noexcept
+      { splice(__position, std::move(__x), __first, __last); }
+#endif
+
+      void
+      remove(const _Tp& __value)
+      {
+	for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); )
+	  {
+	    if (*__x == __value)
+	      __x = _M_erase(__x);
+	    else
+	      ++__x;
+	  }
+      }
+
+      template<class _Predicate>
+        void
+        remove_if(_Predicate __pred)
+        {
+	  for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); )
+	    {
+	      if (__pred(*__x))
+		__x = _M_erase(__x);
+	      else
+		++__x;
+	    }
+	}
+
+      void
+      unique()
+      {
+	_Base_iterator __first = _Base::begin();
+	_Base_iterator __last = _Base::end();
+	if (__first == __last)
+	  return;
+	_Base_iterator __next = __first; ++__next;
+	while (__next != __last)
+	  {
+	    if (*__first == *__next)
+	      __next = _M_erase(__next);
+	    else
+	      __first = __next++;
+	  }
+      }
+
+      template<class _BinaryPredicate>
+        void
+        unique(_BinaryPredicate __binary_pred)
+        {
+	  _Base_iterator __first = _Base::begin();
+	  _Base_iterator __last = _Base::end();
+	  if (__first == __last)
+	    return;
+	  _Base_iterator __next = __first; ++__next;
+	  while (__next != __last)
+	    {
+	      if (__binary_pred(*__first, *__next))
+		__next = _M_erase(__next);
+	      else
+		__first = __next++;
+	    }
+	}
+
+      void
+#if __cplusplus >= 201103L
+      merge(list&& __x)
+#else
+      merge(list& __x)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 300. list::merge() specification incomplete
+	if (this != &__x)
+	  {
+	    __glibcxx_check_sorted(_Base::begin(), _Base::end());
+	    __glibcxx_check_sorted(__x.begin().base(), __x.end().base());
+	    this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
+	    _Base::merge(_GLIBCXX_MOVE(__x._M_base()));
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      void
+      merge(list& __x)
+      { merge(std::move(__x)); }
+#endif
+
+      template<class _Compare>
+        void
+#if __cplusplus >= 201103L
+        merge(list&& __x, _Compare __comp)
+#else
+        merge(list& __x, _Compare __comp)
+#endif
+        {
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 300. list::merge() specification incomplete
+	  if (this != &__x)
+	    {
+	      __glibcxx_check_sorted_pred(_Base::begin(), _Base::end(),
+					  __comp);
+	      __glibcxx_check_sorted_pred(__x.begin().base(), __x.end().base(),
+					  __comp);
+	      this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
+	      _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp);
+	    }
+	}
+
+#if __cplusplus >= 201103L
+      template<typename _Compare>
+        void
+        merge(list& __x, _Compare __comp)
+        { merge(std::move(__x), __comp); }
+#endif
+
+      void
+      sort() { _Base::sort(); }
+
+      template<typename _StrictWeakOrdering>
+        void
+        sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); }
+
+      using _Base::reverse;
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    private:
+      void
+      _M_invalidate_all()
+      {
+	this->_M_invalidate_if(_Not_equal(_Base::end()));
+      }
+    };
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const list<_Tp, _Alloc>& __lhs,
+	      const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const list<_Tp, _Alloc>& __lhs,
+	      const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __debug
+} // namespace std
+
+#ifndef _GLIBCXX_DEBUG_PEDANTIC
+namespace __gnu_debug
+{
+  template<class _Tp, class _Alloc>
+    struct _Insert_range_from_self_is_safe<std::__debug::list<_Tp, _Alloc> >
+    { enum { __value = 1 }; };
+}
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/macros.h b/gcc-4.9/libstdc++-v3/include/debug/macros.h
new file mode 100644
index 0000000..7ce374c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/macros.h
@@ -0,0 +1,364 @@
+// Debugging support implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/macros.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_MACROS_H
+#define _GLIBCXX_DEBUG_MACROS_H 1
+
+/**
+ * Macros used by the implementation to verify certain
+ * properties. These macros may only be used directly by the debug
+ * wrappers. Note that these are macros (instead of the more obviously
+ * @a correct choice of making them functions) because we need line and
+ * file information at the call site, to minimize the distance between
+ * the user error and where the error is reported.
+ *
+ */
+#define _GLIBCXX_DEBUG_VERIFY_AT(_Condition,_ErrorMessage,_File,_Line)	\
+  do									\
+  {									\
+    if (! (_Condition))							\
+      __gnu_debug::_Error_formatter::_M_at(_File, _Line)		\
+	  ._ErrorMessage._M_error();					\
+  } while (false)
+
+#define _GLIBCXX_DEBUG_VERIFY(_Condition,_ErrorMessage)			\
+  _GLIBCXX_DEBUG_VERIFY_AT(_Condition,_ErrorMessage,__FILE__,__LINE__)
+
+// Verify that [_First, _Last) forms a valid iterator range.
+#define __glibcxx_check_valid_range(_First,_Last)			\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__valid_range(_First, _Last),	\
+		      _M_message(__gnu_debug::__msg_valid_range)	\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last))
+
+// Verify that [_First, _Last) forms a non-empty iterator range.
+#define __glibcxx_check_non_empty_range(_First,_Last)			\
+_GLIBCXX_DEBUG_VERIFY(_First != _Last,					\
+		      _M_message(__gnu_debug::__msg_non_empty_range)	\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last))
+
+/** Verify that we can insert into *this with the iterator _Position.
+ *  Insertion into a container at a specific position requires that
+ *  the iterator be nonsingular, either dereferenceable or past-the-end,
+ *  and that it reference the sequence we are inserting into. Note that
+ *  this macro is only valid when the container is a_Safe_sequence and
+ *  the iterator is a _Safe_iterator.
+*/
+#define __glibcxx_check_insert(_Position)				\
+_GLIBCXX_DEBUG_VERIFY(!_Position._M_singular(),				\
+		      _M_message(__gnu_debug::__msg_insert_singular)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_Position, #_Position));		\
+_GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this),			\
+		      _M_message(__gnu_debug::__msg_insert_different)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_Position, #_Position))
+
+/** Verify that we can insert into *this after the iterator _Position.
+ *  Insertion into a container after a specific position requires that
+ *  the iterator be nonsingular, either dereferenceable or before-begin,
+ *  and that it reference the sequence we are inserting into. Note that
+ *  this macro is only valid when the container is a_Safe_sequence and
+ *  the iterator is a _Safe_iterator.
+*/
+#define __glibcxx_check_insert_after(_Position)				\
+__glibcxx_check_insert(_Position);					\
+_GLIBCXX_DEBUG_VERIFY(!_Position._M_is_end(),				\
+		      _M_message(__gnu_debug::__msg_insert_after_end)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_Position, #_Position))
+
+/** Verify that we can insert the values in the iterator range
+ *  [_First, _Last) into *this with the iterator _Position.  Insertion
+ *  into a container at a specific position requires that the iterator
+ *  be nonsingular (i.e., either dereferenceable or past-the-end),
+ *  that it reference the sequence we are inserting into, and that the
+ *  iterator range [_First, _Last) is a valid (possibly empty)
+ *  range which does not reference the sequence we are inserting into.
+ *  Note that this macro is only valid when the container is a
+ *  _Safe_sequence and the _Position iterator is a _Safe_iterator.
+*/
+#define __glibcxx_check_insert_range(_Position,_First,_Last)		\
+__glibcxx_check_valid_range(_First,_Last);				\
+__glibcxx_check_insert(_Position);					\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__foreign_iterator(_Position,_First,_Last),\
+		      _M_message(__gnu_debug::__msg_insert_range_from_self)\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_sequence(*this, "this"))
+
+/** Verify that we can insert the values in the iterator range
+ *  [_First, _Last) into *this after the iterator _Position.  Insertion
+ *  into a container after a specific position requires that the iterator
+ *  be nonsingular (i.e., either dereferenceable or past-the-end),
+ *  that it reference the sequence we are inserting into, and that the
+ *  iterator range [_First, _Last) is a valid (possibly empty)
+ *  range which does not reference the sequence we are inserting into.
+ *  Note that this macro is only valid when the container is a
+ *  _Safe_sequence and the _Position iterator is a _Safe_iterator.
+*/
+#define __glibcxx_check_insert_range_after(_Position,_First,_Last)	\
+__glibcxx_check_valid_range(_First,_Last);				\
+__glibcxx_check_insert_after(_Position);				\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__foreign_iterator(_Position,_First,_Last),\
+		      _M_message(__gnu_debug::__msg_insert_range_from_self)\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_sequence(*this, "this"))
+
+/** Verify that we can erase the element referenced by the iterator
+ * _Position. We can erase the element if the _Position iterator is
+ * dereferenceable and references this sequence.
+*/
+#define __glibcxx_check_erase(_Position)				\
+_GLIBCXX_DEBUG_VERIFY(_Position._M_dereferenceable(),			\
+		      _M_message(__gnu_debug::__msg_erase_bad)	        \
+                      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_Position, #_Position));		\
+_GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this),			\
+		      _M_message(__gnu_debug::__msg_erase_different)    \
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_Position, #_Position))
+
+/** Verify that we can erase the element after the iterator
+ * _Position. We can erase the element if the _Position iterator is
+ * before a dereferenceable one and references this sequence.
+*/
+#define __glibcxx_check_erase_after(_Position)				\
+_GLIBCXX_DEBUG_VERIFY(_Position._M_before_dereferenceable(),		\
+		      _M_message(__gnu_debug::__msg_erase_after_bad)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_Position, #_Position));		\
+_GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this),			\
+		      _M_message(__gnu_debug::__msg_erase_different)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_Position, #_Position))
+
+/** Verify that we can erase the elements in the iterator range
+ *  [_First, _Last). We can erase the elements if [_First, _Last) is a
+ *  valid iterator range within this sequence.
+*/
+#define __glibcxx_check_erase_range(_First,_Last)			\
+__glibcxx_check_valid_range(_First,_Last);				\
+_GLIBCXX_DEBUG_VERIFY(_First._M_attached_to(this),			\
+		      _M_message(__gnu_debug::__msg_erase_different)    \
+                      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last))
+
+/** Verify that we can erase the elements in the iterator range
+ *  (_First, _Last). We can erase the elements if (_First, _Last) is a
+ *  valid iterator range within this sequence.
+*/
+#define __glibcxx_check_erase_range_after(_First,_Last)			\
+_GLIBCXX_DEBUG_VERIFY(_First._M_can_compare(_Last),			\
+		      _M_message(__gnu_debug::__msg_erase_different)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last));			\
+_GLIBCXX_DEBUG_VERIFY(_First._M_attached_to(this),			\
+		      _M_message(__gnu_debug::__msg_erase_different)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_First, #_First));			\
+_GLIBCXX_DEBUG_VERIFY(_First != _Last,					\
+		      _M_message(__gnu_debug::__msg_valid_range2)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last));			\
+_GLIBCXX_DEBUG_VERIFY(_First._M_incrementable(),			\
+		      _M_message(__gnu_debug::__msg_valid_range2)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last));			\
+_GLIBCXX_DEBUG_VERIFY(!_Last._M_is_before_begin(),			\
+		      _M_message(__gnu_debug::__msg_valid_range2)	\
+		      ._M_sequence(*this, "this")			\
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last))			\
+
+// Verify that the subscript _N is less than the container's size.
+#define __glibcxx_check_subscript(_N)					\
+_GLIBCXX_DEBUG_VERIFY(_N < this->size(),				\
+		      _M_message(__gnu_debug::__msg_subscript_oob)	\
+                      ._M_sequence(*this, "this")			\
+		      ._M_integer(_N, #_N)				\
+		      ._M_integer(this->size(), "size"))
+
+// Verify that the bucket _N is less than the container's buckets count.
+#define __glibcxx_check_bucket_index(_N)				\
+_GLIBCXX_DEBUG_VERIFY(_N < this->bucket_count(),			\
+		      _M_message(__gnu_debug::__msg_bucket_index_oob)	\
+                      ._M_sequence(*this, "this")			\
+		      ._M_integer(_N, #_N)				\
+		      ._M_integer(this->bucket_count(), "size"))
+
+// Verify that the container is nonempty
+#define __glibcxx_check_nonempty()					\
+_GLIBCXX_DEBUG_VERIFY(! this->empty(),					\
+		      _M_message(__gnu_debug::__msg_empty)	        \
+                      ._M_sequence(*this, "this"))
+
+// Verify that the iterator range [_First, _Last) is sorted
+#define __glibcxx_check_sorted(_First,_Last)				\
+__glibcxx_check_valid_range(_First,_Last);				\
+ _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_sorted(			\
+			__gnu_debug::__base(_First),			\
+			__gnu_debug::__base(_Last)),			\
+		      _M_message(__gnu_debug::__msg_unsorted)	        \
+                      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last))
+
+/** Verify that the iterator range [_First, _Last) is sorted by the
+    predicate _Pred. */
+#define __glibcxx_check_sorted_pred(_First,_Last,_Pred)			\
+__glibcxx_check_valid_range(_First,_Last);				\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_sorted(			\
+			__gnu_debug::__base(_First),			\
+			__gnu_debug::__base(_Last), _Pred),		\
+		      _M_message(__gnu_debug::__msg_unsorted_pred)      \
+                      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_string(#_Pred))
+
+// Special variant for std::merge, std::includes, std::set_*
+#define __glibcxx_check_sorted_set(_First1,_Last1,_First2)		\
+__glibcxx_check_valid_range(_First1,_Last1);				\
+_GLIBCXX_DEBUG_VERIFY(                                                  \
+  __gnu_debug::__check_sorted_set(__gnu_debug::__base(_First1),		\
+				  __gnu_debug::__base(_Last1), _First2),\
+  _M_message(__gnu_debug::__msg_unsorted)				\
+  ._M_iterator(_First1, #_First1)					\
+  ._M_iterator(_Last1, #_Last1))
+
+// Likewise with a _Pred.
+#define __glibcxx_check_sorted_set_pred(_First1,_Last1,_First2,_Pred)	\
+__glibcxx_check_valid_range(_First1,_Last1);        			\
+_GLIBCXX_DEBUG_VERIFY(							\
+  __gnu_debug::__check_sorted_set(__gnu_debug::__base(_First1),		\
+				  __gnu_debug::__base(_Last1),		\
+				  _First2, _Pred),			\
+  _M_message(__gnu_debug::__msg_unsorted_pred)				\
+  ._M_iterator(_First1, #_First1)					\
+  ._M_iterator(_Last1, #_Last1)						\
+  ._M_string(#_Pred))
+
+/** Verify that the iterator range [_First, _Last) is partitioned
+    w.r.t. the value _Value. */
+#define __glibcxx_check_partitioned_lower(_First,_Last,_Value)		\
+__glibcxx_check_valid_range(_First,_Last);				\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(		\
+			__gnu_debug::__base(_First),			\
+			__gnu_debug::__base(_Last), _Value),		\
+		      _M_message(__gnu_debug::__msg_unpartitioned)      \
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_string(#_Value))
+
+#define __glibcxx_check_partitioned_upper(_First,_Last,_Value)		\
+__glibcxx_check_valid_range(_First,_Last);				\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(		\
+			__gnu_debug::__base(_First),			\
+			__gnu_debug::__base(_Last), _Value),		\
+		      _M_message(__gnu_debug::__msg_unpartitioned)      \
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_string(#_Value))
+
+/** Verify that the iterator range [_First, _Last) is partitioned
+    w.r.t. the value _Value and predicate _Pred. */
+#define __glibcxx_check_partitioned_lower_pred(_First,_Last,_Value,_Pred) \
+__glibcxx_check_valid_range(_First,_Last);				\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(		\
+			__gnu_debug::__base(_First),			\
+			__gnu_debug::__base(_Last), _Value, _Pred),	\
+		      _M_message(__gnu_debug::__msg_unpartitioned_pred) \
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_string(#_Pred)				\
+                      ._M_string(#_Value))
+
+/** Verify that the iterator range [_First, _Last) is partitioned
+    w.r.t. the value _Value and predicate _Pred. */
+#define __glibcxx_check_partitioned_upper_pred(_First,_Last,_Value,_Pred) \
+__glibcxx_check_valid_range(_First,_Last);				\
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(		\
+			__gnu_debug::__base(_First),			\
+			__gnu_debug::__base(_Last), _Value, _Pred),	\
+		      _M_message(__gnu_debug::__msg_unpartitioned_pred) \
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_string(#_Pred)				\
+                      ._M_string(#_Value))
+
+// Verify that the iterator range [_First, _Last) is a heap
+#define __glibcxx_check_heap(_First,_Last)				\
+  _GLIBCXX_DEBUG_VERIFY(std::__is_heap(__gnu_debug::__base(_First),	\
+				       __gnu_debug::__base(_Last)),	\
+		      _M_message(__gnu_debug::__msg_not_heap)	        \
+		      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last))
+
+/** Verify that the iterator range [_First, _Last) is a heap
+    w.r.t. the predicate _Pred. */
+#define __glibcxx_check_heap_pred(_First,_Last,_Pred)			\
+  _GLIBCXX_DEBUG_VERIFY(std::__is_heap(__gnu_debug::__base(_First),	\
+				       __gnu_debug::__base(_Last),	\
+				       _Pred),				\
+		      _M_message(__gnu_debug::__msg_not_heap_pred)      \
+                      ._M_iterator(_First, #_First)			\
+		      ._M_iterator(_Last, #_Last)			\
+		      ._M_string(#_Pred))
+
+// Verify that the container is not self move assigned
+#define __glibcxx_check_self_move_assign(_Other)			\
+_GLIBCXX_DEBUG_VERIFY(this != &_Other,					\
+		      _M_message(__gnu_debug::__msg_self_move_assign)	\
+                      ._M_sequence(*this, "this"))
+
+// Verify that load factor is positive
+#define __glibcxx_check_max_load_factor(_F)				\
+_GLIBCXX_DEBUG_VERIFY(_F > 0.0f,					\
+		      _M_message(__gnu_debug::__msg_valid_load_factor)	\
+                      ._M_sequence(*this, "this"))
+
+#define __glibcxx_check_equal_allocs(_Other)				\
+_GLIBCXX_DEBUG_VERIFY(this->get_allocator() == _Other.get_allocator(),	\
+		      _M_message(__gnu_debug::__msg_equal_allocs)	\
+		      ._M_sequence(*this, "this"))
+
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+#  define __glibcxx_check_string(_String) _GLIBCXX_DEBUG_ASSERT(_String != 0)
+#  define __glibcxx_check_string_len(_String,_Len) \
+       _GLIBCXX_DEBUG_ASSERT(_String != 0 || _Len == 0)
+#else
+#  define __glibcxx_check_string(_String)
+#  define __glibcxx_check_string_len(_String,_Len)
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/map b/gcc-4.9/libstdc++-v3/include/debug/map
new file mode 100644
index 0000000..bacb0d3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/map
@@ -0,0 +1,36 @@
+// Debugging map/multimap implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/map
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_MAP
+#define _GLIBCXX_DEBUG_MAP 1
+
+#include <map>
+#include <debug/map.h>
+#include <debug/multimap.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/map.h b/gcc-4.9/libstdc++-v3/include/debug/map.h
new file mode 100644
index 0000000..fda6ac1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/map.h
@@ -0,0 +1,532 @@
+// Debugging map implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/map.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_MAP_H
+#define _GLIBCXX_DEBUG_MAP_H 1
+
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::map with safety/checking/debug instrumentation.
+  template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
+    class map
+    : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>,
+      public __gnu_debug::_Safe_sequence<map<_Key, _Tp, _Compare, _Allocator> >
+    {
+      typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
+
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+#endif
+    public:
+      // types:
+      typedef _Key                                  key_type;
+      typedef _Tp                                   mapped_type;
+      typedef std::pair<const _Key, _Tp>            value_type;
+      typedef _Compare                              key_compare;
+      typedef _Allocator                            allocator_type;
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator, map>
+                                                    iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, map>
+                                                    const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      // 23.3.1.1 construct/copy/destroy:
+
+      map() : _Base() { }
+
+      explicit map(const _Compare& __comp,
+		   const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a) { }
+
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+	    const _Compare& __comp = _Compare(),
+	    const _Allocator& __a = _Allocator())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last),
+		__comp, __a) { }
+
+      map(const map& __x)
+      : _Base(__x) { }
+
+      map(const _Base& __x)
+      : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      map(map&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _Base(std::move(__x))
+      { this->_M_swap(__x); }
+
+      map(initializer_list<value_type> __l,
+	  const _Compare& __c = _Compare(),
+	  const allocator_type& __a = allocator_type())
+      : _Base(__l, __c, __a) { }
+
+      explicit
+      map(const allocator_type& __a)
+      : _Base(__a) { }
+
+      map(const map& __m, const allocator_type& __a)
+      : _Base(__m, __a) { }
+
+      map(map&& __m, const allocator_type& __a)
+      : _Base(std::move(__m._M_base()), __a) { }
+
+      map(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a) { }
+
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								       __last)),
+		  __gnu_debug::__base(__last), __a)
+	{ }
+#endif
+
+      ~map() _GLIBCXX_NOEXCEPT { }
+
+      map&
+      operator=(const map& __x)
+      {
+	_M_base() = __x;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      map&
+      operator=(map&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      map&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+#endif
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 133. map missing get_allocator()
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator 
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // 23.3.1.2 element access:
+      using _Base::operator[];
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 464. Suggestion for new member functions in standard containers.
+      using _Base::at;
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  auto __res = _Base::emplace(std::forward<_Args>(__args)...);
+	  return std::pair<iterator, bool>(iterator(__res.first, this),
+					   __res.second);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__pos);
+	  return iterator(_Base::emplace_hint(__pos.base(),
+					      std::forward<_Args>(__args)...),
+			  this);
+	}
+#endif
+
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      {
+	std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
+	return std::pair<iterator, bool>(iterator(__res.first, this),
+					 __res.second);
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        std::pair<iterator, bool>
+        insert(_Pair&& __x)
+        {
+	  std::pair<_Base_iterator, bool> __res
+	    = _Base::insert(std::forward<_Pair>(__x));
+	  return std::pair<iterator, bool>(iterator(__res.first, this),
+					   __res.second);
+	}
+#endif
+
+#if __cplusplus >= 201103L
+      void
+      insert(std::initializer_list<value_type> __list)
+      { _Base::insert(__list); }
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const value_type& __x)
+#else
+      insert(iterator __position, const value_type& __x)
+#endif
+      {
+	__glibcxx_check_insert(__position);
+	return iterator(_Base::insert(__position.base(), __x), this);
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        {
+	  __glibcxx_check_insert(__position);
+	  return iterator(_Base::insert(__position.base(),
+					std::forward<_Pair>(__x)), this);
+	}
+#endif
+
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	}
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	return iterator(_Base::erase(__position.base()), this);
+      }
+
+      iterator
+      erase(iterator __position)
+      { return erase(const_iterator(__position)); }
+#else
+      void
+      erase(iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	_Base::erase(__position.base());
+      }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	_Base_iterator __victim = _Base::find(__x);
+	if (__victim == _Base::end())
+	  return 0;
+	else
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	    _Base::erase(__victim);
+	    return 1;
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	return iterator(_Base::erase(__first.base(), __last.base()), this);
+      }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	_Base::erase(__first.base(), __last.base());
+      }
+#endif
+
+      void
+      swap(map& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      {
+#if __cplusplus >= 201103L
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+#endif
+	_Base::swap(__x);
+	this->_M_swap(__x);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_invalidate_all();
+	_Base::clear();
+      }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // 23.3.1.3 map operations:
+      iterator
+      find(const key_type& __x)
+      { return iterator(_Base::find(__x), this); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return const_iterator(_Base::find(__x), this); }
+
+      using _Base::count;
+
+      iterator
+      lower_bound(const key_type& __x)
+      { return iterator(_Base::lower_bound(__x), this); }
+
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return const_iterator(_Base::lower_bound(__x), this); }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return iterator(_Base::upper_bound(__x), this); }
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return const_iterator(_Base::upper_bound(__x), this); }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __res =
+	_Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+	_Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    private:
+      void
+      _M_invalidate_all()
+      {
+	typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
+	this->_M_invalidate_if(_Not_equal(_M_base().end()));
+      }
+    };
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline void
+    swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	 map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __debug
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/multimap.h b/gcc-4.9/libstdc++-v3/include/debug/multimap.h
new file mode 100644
index 0000000..4c3a3eb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/multimap.h
@@ -0,0 +1,516 @@
+// Debugging multimap implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/multimap.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_MULTIMAP_H
+#define _GLIBCXX_DEBUG_MULTIMAP_H 1
+
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::multimap with safety/checking/debug instrumentation.
+  template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
+    class multimap
+    : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>,
+      public __gnu_debug::_Safe_sequence<multimap<_Key, _Tp,
+						  _Compare, _Allocator> >
+    {
+      typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
+
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+#endif
+    public:
+      // types:
+      typedef _Key				     key_type;
+      typedef _Tp				     mapped_type;
+      typedef std::pair<const _Key, _Tp>             value_type;
+      typedef _Compare                               key_compare;
+      typedef _Allocator                             allocator_type;
+      typedef typename _Base::reference              reference;
+      typedef typename _Base::const_reference        const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator, multimap>
+                                                     iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
+                                           multimap> const_iterator;
+
+      typedef typename _Base::size_type              size_type;
+      typedef typename _Base::difference_type        difference_type;
+      typedef typename _Base::pointer                pointer;
+      typedef typename _Base::const_pointer          const_pointer;
+      typedef std::reverse_iterator<iterator>        reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
+
+      // 23.3.1.1 construct/copy/destroy:
+
+      multimap() : _Base() { }
+
+      explicit multimap(const _Compare& __comp,
+			const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a) { }
+
+      template<typename _InputIterator>
+      multimap(_InputIterator __first, _InputIterator __last,
+	       const _Compare& __comp = _Compare(),
+	       const _Allocator& __a = _Allocator())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last),
+	      __comp, __a) { }
+
+      multimap(const multimap& __x)
+      : _Base(__x) { }
+
+      multimap(const _Base& __x)
+      : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      multimap(multimap&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _Base(std::move(__x))
+      { this->_M_swap(__x); }
+
+      multimap(initializer_list<value_type> __l,
+	       const _Compare& __c = _Compare(),
+	       const allocator_type& __a = allocator_type())
+      : _Base(__l, __c, __a) { }
+
+      explicit
+      multimap(const allocator_type& __a)
+      : _Base(__a) { }
+
+      multimap(const multimap& __m, const allocator_type& __a)
+      : _Base(__m, __a) { }
+
+      multimap(multimap&& __m, const allocator_type& __a)
+      : _Base(std::move(__m._M_base()), __a) { }
+
+      multimap(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a)
+      { }
+
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+		 const allocator_type& __a)
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __a)
+      { }
+#endif
+
+      ~multimap() _GLIBCXX_NOEXCEPT { }
+
+      multimap&
+      operator=(const multimap& __x)
+      {
+	_M_base() = __x;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      multimap&
+      operator=(multimap&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{
+	  return iterator(_Base::emplace(std::forward<_Args>(__args)...), this);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__pos);
+	  return iterator(_Base::emplace_hint(__pos.base(),
+					      std::forward<_Args>(__args)...),
+			  this);
+	}
+#endif
+      
+      iterator
+      insert(const value_type& __x)
+      { return iterator(_Base::insert(__x), this); }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(_Pair&& __x)
+        { return iterator(_Base::insert(std::forward<_Pair>(__x)), this); }
+#endif
+
+#if __cplusplus >= 201103L
+      void
+      insert(std::initializer_list<value_type> __list)
+      { _Base::insert(__list); }
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const value_type& __x)
+#else
+      insert(iterator __position, const value_type& __x)
+#endif
+      {
+	__glibcxx_check_insert(__position);
+	return iterator(_Base::insert(__position.base(), __x), this);
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        {
+	  __glibcxx_check_insert(__position);
+	  return iterator(_Base::insert(__position.base(),
+					std::forward<_Pair>(__x)), this);
+	}
+#endif
+
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	}
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	return iterator(_Base::erase(__position.base()), this);
+      }
+
+      iterator
+      erase(iterator __position)
+      { return erase(const_iterator(__position)); }
+#else
+      void
+      erase(iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	_Base::erase(__position.base());
+      }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __victims =
+	  _Base::equal_range(__x);
+	size_type __count = 0;
+	_Base_iterator __victim = __victims.first;
+	while (__victim !=  __victims.second)
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	    _Base::erase(__victim++);
+	    ++__count;
+	  }
+	return __count;
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	return iterator(_Base::erase(__first.base(), __last.base()), this);
+      }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	_Base::erase(__first.base(), __last.base());
+      }
+#endif
+
+      void
+      swap(multimap& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      {
+#if __cplusplus >= 201103L
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+#endif
+	_Base::swap(__x);
+	this->_M_swap(__x);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_invalidate_all();
+	_Base::clear();
+      }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // 23.3.1.3 multimap operations:
+      iterator
+      find(const key_type& __x)
+      { return iterator(_Base::find(__x), this); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return const_iterator(_Base::find(__x), this); }
+
+      using _Base::count;
+
+      iterator
+      lower_bound(const key_type& __x)
+      { return iterator(_Base::lower_bound(__x), this); }
+
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return const_iterator(_Base::lower_bound(__x), this); }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return iterator(_Base::upper_bound(__x), this); }
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return const_iterator(_Base::upper_bound(__x), this); }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __res =
+	_Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+	  _Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    private:
+      void
+      _M_invalidate_all()
+      {
+	typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
+	this->_M_invalidate_if(_Not_equal(_Base::end()));
+      }
+    };
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline void
+    swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	 multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __debug
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/multiset.h b/gcc-4.9/libstdc++-v3/include/debug/multiset.h
new file mode 100644
index 0000000..ae62bf8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/multiset.h
@@ -0,0 +1,502 @@
+// Debugging multiset implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/multiset.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_MULTISET_H
+#define _GLIBCXX_DEBUG_MULTISET_H 1
+
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::multiset with safety/checking/debug instrumentation.
+  template<typename _Key, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<_Key> >
+    class multiset
+    : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>,
+      public __gnu_debug::_Safe_sequence<multiset<_Key, _Compare, _Allocator> >
+    {
+      typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
+
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+#endif
+    public:
+      // types:
+      typedef _Key				     key_type;
+      typedef _Key				     value_type;
+      typedef _Compare				     key_compare;
+      typedef _Compare				     value_compare;
+      typedef _Allocator			     allocator_type;
+      typedef typename _Base::reference	             reference;
+      typedef typename _Base::const_reference        const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator, multiset>
+      iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
+					  multiset> const_iterator;
+
+      typedef typename _Base::size_type              size_type;
+      typedef typename _Base::difference_type        difference_type;
+      typedef typename _Base::pointer                pointer;
+      typedef typename _Base::const_pointer          const_pointer;
+      typedef std::reverse_iterator<iterator>        reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
+
+      // 23.3.3.1 construct/copy/destroy:
+
+      multiset() : _Base() { }
+
+      explicit multiset(const _Compare& __comp,
+			const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a) { }
+
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last,
+		 const _Compare& __comp = _Compare(),
+		 const _Allocator& __a = _Allocator())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last),
+		__comp, __a) { }
+
+      multiset(const multiset& __x)
+      : _Base(__x) { }
+
+      multiset(const _Base& __x)
+      : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      multiset(multiset&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _Base(std::move(__x))
+      { this->_M_swap(__x); }
+
+      multiset(initializer_list<value_type> __l,
+	       const _Compare& __comp = _Compare(),
+	       const allocator_type& __a = allocator_type())
+      : _Base(__l, __comp, __a) { }
+
+      explicit
+      multiset(const allocator_type& __a)
+      : _Base(__a) { }
+
+      multiset(const multiset& __m, const allocator_type& __a)
+      : _Base(__m, __a) { }
+
+      multiset(multiset&& __m, const allocator_type& __a)
+      : _Base(std::move(__m._M_base()), __a) { }
+
+      multiset(initializer_list<value_type> __l, const allocator_type& __a)
+	: _Base(__l, __a)
+      { }
+
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last,
+		 const allocator_type& __a)
+	  : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								       __last)),
+		  __gnu_debug::__base(__last), __a)
+        { }
+#endif
+
+      ~multiset() _GLIBCXX_NOEXCEPT { }
+
+      multiset&
+      operator=(const multiset& __x)
+      {
+	_M_base() = __x;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      multiset&
+      operator=(multiset&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      multiset&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{
+	  return iterator(_Base::emplace(std::forward<_Args>(__args)...), this);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__pos);
+	  return iterator(_Base::emplace_hint(__pos.base(),
+					      std::forward<_Args>(__args)...),
+			  this);
+	}
+#endif
+
+      iterator
+      insert(const value_type& __x)
+      { return iterator(_Base::insert(__x), this); }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(value_type&& __x)
+      { return iterator(_Base::insert(std::move(__x)), this); }
+#endif
+
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      {
+	__glibcxx_check_insert(__position);
+	return iterator(_Base::insert(__position.base(), __x), this);
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      {
+	__glibcxx_check_insert(__position);
+	return iterator(_Base::insert(__position.base(), std::move(__x)),
+			this);
+      }
+#endif
+
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	}
+
+#if __cplusplus >= 201103L
+      void
+      insert(initializer_list<value_type> __l)
+      { _Base::insert(__l); }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	return iterator(_Base::erase(__position.base()), this);
+      }
+#else
+      void
+      erase(iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	_Base::erase(__position.base());
+      }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __victims =
+	  _Base::equal_range(__x);
+	size_type __count = 0;
+	_Base_iterator __victim = __victims.first;
+	while (__victim != __victims.second)
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	    _Base::erase(__victim++);
+	    ++__count;
+	  }
+	return __count;
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	return iterator(_Base::erase(__first.base(), __last.base()), this);
+      }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	_Base::erase(__first.base(), __last.base());
+      }
+#endif
+
+      void
+      swap(multiset& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      {
+#if __cplusplus >= 201103L
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+#endif
+	_Base::swap(__x);
+	this->_M_swap(__x);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_invalidate_all();
+	_Base::clear();
+      }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // multiset operations:
+      iterator
+      find(const key_type& __x)
+      { return iterator(_Base::find(__x), this); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      find(const key_type& __x) const
+      { return const_iterator(_Base::find(__x), this); }
+
+      using _Base::count;
+
+      iterator
+      lower_bound(const key_type& __x)
+      { return iterator(_Base::lower_bound(__x), this); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return const_iterator(_Base::lower_bound(__x), this); }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return iterator(_Base::upper_bound(__x), this); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return const_iterator(_Base::upper_bound(__x), this); }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __res =
+	  _Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+	  _Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    private:
+      void
+      _M_invalidate_all()
+      {
+	typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
+	this->_M_invalidate_if(_Not_equal(_Base::end()));
+      }
+    };
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	      const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	      const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    void
+    swap(multiset<_Key, _Compare, _Allocator>& __x,
+	 multiset<_Key, _Compare, _Allocator>& __y)
+    { return __x.swap(__y); }
+
+} // namespace __debug
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_base.h b/gcc-4.9/libstdc++-v3/include/debug/safe_base.h
new file mode 100644
index 0000000..631ac77
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_base.h
@@ -0,0 +1,263 @@
+// Safe sequence/iterator base implementation  -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_base.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_BASE_H
+#define _GLIBCXX_DEBUG_SAFE_BASE_H 1
+
+#include <ext/concurrence.h>
+
+namespace __gnu_debug
+{
+  class _Safe_sequence_base;
+
+  /** \brief Basic functionality for a @a safe iterator.
+   *
+   *  The %_Safe_iterator_base base class implements the functionality
+   *  of a safe iterator that is not specific to a particular iterator
+   *  type. It contains a pointer back to the sequence it references
+   *  along with iterator version information and pointers to form a
+   *  doubly-linked list of iterators referenced by the container.
+   *
+   *  This class must not perform any operations that can throw an
+   *  exception, or the exception guarantees of derived iterators will
+   *  be broken.
+   */
+  class _Safe_iterator_base
+  {
+  public:
+    /** The sequence this iterator references; may be NULL to indicate
+	a singular iterator. */
+    _Safe_sequence_base* _M_sequence;
+
+    /** The version number of this iterator. The sentinel value 0 is
+     *  used to indicate an invalidated iterator (i.e., one that is
+     *  singular because of an operation on the container). This
+     *  version number must equal the version number in the sequence
+     *  referenced by _M_sequence for the iterator to be
+     *  non-singular.
+     */
+    unsigned int         _M_version;
+
+    /** Pointer to the previous iterator in the sequence's list of
+	iterators. Only valid when _M_sequence != NULL. */
+    _Safe_iterator_base* _M_prior;
+
+    /** Pointer to the next iterator in the sequence's list of
+	iterators. Only valid when _M_sequence != NULL. */
+    _Safe_iterator_base* _M_next;
+
+  protected:
+    /** Initializes the iterator and makes it singular. */
+    _Safe_iterator_base()
+    : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
+    { }
+
+    /** Initialize the iterator to reference the sequence pointed to
+     *  by @p __seq. @p __constant is true when we are initializing a
+     *  constant iterator, and false if it is a mutable iterator. Note
+     *  that @p __seq may be NULL, in which case the iterator will be
+     *  singular. Otherwise, the iterator will reference @p __seq and
+     *  be nonsingular.
+     */
+    _Safe_iterator_base(const _Safe_sequence_base* __seq, bool __constant)
+    : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
+    { this->_M_attach(const_cast<_Safe_sequence_base*>(__seq), __constant); }
+
+    /** Initializes the iterator to reference the same sequence that
+	@p __x does. @p __constant is true if this is a constant
+	iterator, and false if it is mutable. */
+    _Safe_iterator_base(const _Safe_iterator_base& __x, bool __constant)
+    : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
+    { this->_M_attach(__x._M_sequence, __constant); }
+
+    _Safe_iterator_base&
+    operator=(const _Safe_iterator_base&);
+
+    explicit
+    _Safe_iterator_base(const _Safe_iterator_base&);
+
+    ~_Safe_iterator_base() { this->_M_detach(); }
+
+    /** For use in _Safe_iterator. */
+    __gnu_cxx::__mutex& _M_get_mutex() throw ();
+
+  public:
+    /** Attaches this iterator to the given sequence, detaching it
+     *	from whatever sequence it was attached to originally. If the
+     *	new sequence is the NULL pointer, the iterator is left
+     *	unattached.
+     */
+    void _M_attach(_Safe_sequence_base* __seq, bool __constant);
+
+    /** Likewise, but not thread-safe. */
+    void _M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw ();
+
+    /** Detach the iterator for whatever sequence it is attached to,
+     *	if any.
+    */
+    void _M_detach();
+
+    /** Likewise, but not thread-safe. */
+    void _M_detach_single() throw ();
+
+    /** Determines if we are attached to the given sequence. */
+    bool _M_attached_to(const _Safe_sequence_base* __seq) const
+    { return _M_sequence == __seq; }
+
+    /** Is this iterator singular? */
+    _GLIBCXX_PURE bool _M_singular() const throw ();
+
+    /** Can we compare this iterator to the given iterator @p __x?
+	Returns true if both iterators are nonsingular and reference
+	the same sequence. */
+    _GLIBCXX_PURE bool _M_can_compare(const _Safe_iterator_base& __x) const throw ();
+
+    /** Invalidate the iterator, making it singular. */
+    void
+    _M_invalidate()
+    { _M_version = 0; }
+
+    /** Reset all member variables */
+    void
+    _M_reset() throw ();
+
+    /** Unlink itself */
+    void
+    _M_unlink() throw ()
+    {
+      if (_M_prior)
+	_M_prior->_M_next = _M_next;
+      if (_M_next)
+	_M_next->_M_prior = _M_prior;
+    }
+  };
+
+  /**
+   * @brief Base class that supports tracking of iterators that
+   * reference a sequence.
+   *
+   * The %_Safe_sequence_base class provides basic support for
+   * tracking iterators into a sequence. Sequences that track
+   * iterators must derived from %_Safe_sequence_base publicly, so
+   * that safe iterators (which inherit _Safe_iterator_base) can
+   * attach to them. This class contains two linked lists of
+   * iterators, one for constant iterators and one for mutable
+   * iterators, and a version number that allows very fast
+   * invalidation of all iterators that reference the container.
+   *
+   * This class must ensure that no operation on it may throw an
+   * exception, otherwise @a safe sequences may fail to provide the
+   * exception-safety guarantees required by the C++ standard.
+   */
+  class _Safe_sequence_base
+  {
+  public:
+    /// The list of mutable iterators that reference this container
+    _Safe_iterator_base* _M_iterators;
+
+    /// The list of constant iterators that reference this container
+    _Safe_iterator_base* _M_const_iterators;
+
+    /// The container version number. This number may never be 0.
+    mutable unsigned int _M_version;
+
+  protected:
+    // Initialize with a version number of 1 and no iterators
+    _Safe_sequence_base()
+    : _M_iterators(0), _M_const_iterators(0), _M_version(1)
+    { }
+
+#if __cplusplus >= 201103L
+    _Safe_sequence_base(const _Safe_sequence_base&) noexcept
+      : _Safe_sequence_base() { }
+
+    _Safe_sequence_base(_Safe_sequence_base&& __x) noexcept
+      : _Safe_sequence_base()
+    { _M_swap(__x); }
+#endif
+
+    /** Notify all iterators that reference this sequence that the
+	sequence is being destroyed. */
+    ~_Safe_sequence_base()
+    { this->_M_detach_all(); }
+
+    /** Detach all iterators, leaving them singular. */
+    void
+    _M_detach_all();
+
+    /** Detach all singular iterators.
+     *  @post for all iterators i attached to this sequence,
+     *   i->_M_version == _M_version.
+     */
+    void
+    _M_detach_singular();
+
+    /** Revalidates all attached singular iterators.  This method may
+     *  be used to validate iterators that were invalidated before
+     *  (but for some reason, such as an exception, need to become
+     *  valid again).
+     */
+    void
+    _M_revalidate_singular();
+
+    /** Swap this sequence with the given sequence. This operation
+     *  also swaps ownership of the iterators, so that when the
+     *  operation is complete all iterators that originally referenced
+     *  one container now reference the other container.
+     */
+    void
+    _M_swap(_Safe_sequence_base& __x);
+
+    /** For use in _Safe_sequence. */
+    __gnu_cxx::__mutex& _M_get_mutex() throw ();
+
+  public:
+    /** Invalidates all iterators. */
+    void
+    _M_invalidate_all() const
+    { if (++_M_version == 0) _M_version = 1; }
+
+    /** Attach an iterator to this sequence. */
+    void
+    _M_attach(_Safe_iterator_base* __it, bool __constant);
+
+    /** Likewise but not thread safe. */
+    void
+    _M_attach_single(_Safe_iterator_base* __it, bool __constant) throw ();
+
+    /** Detach an iterator from this sequence */
+    void
+    _M_detach(_Safe_iterator_base* __it);
+
+    /** Likewise but not thread safe. */
+    void
+    _M_detach_single(_Safe_iterator_base* __it) throw ();
+  };
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_iterator.h b/gcc-4.9/libstdc++-v3/include/debug/safe_iterator.h
new file mode 100644
index 0000000..d563db0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_iterator.h
@@ -0,0 +1,731 @@
+// Safe iterator implementation  -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_iterator.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_H
+#define _GLIBCXX_DEBUG_SAFE_ITERATOR_H 1
+
+#include <debug/debug.h>
+#include <debug/macros.h>
+#include <debug/functions.h>
+#include <debug/safe_base.h>
+#include <bits/stl_pair.h>
+#include <ext/type_traits.h>
+
+namespace __gnu_debug
+{
+  /** Helper struct to deal with sequence offering a before_begin
+   *  iterator.
+   **/
+  template <typename _Sequence>
+    struct _BeforeBeginHelper
+    {
+      template<typename _Iterator>
+	static bool
+	_S_Is(const _Safe_iterator<_Iterator, _Sequence>&)
+	{ return false; }
+
+      template<typename _Iterator>
+	static bool
+	_S_Is_Beginnest(const _Safe_iterator<_Iterator, _Sequence>& __it)
+	{ return __it.base() == __it._M_get_sequence()->_M_base().begin(); }
+    };
+
+  /** Iterators that derive from _Safe_iterator_base can be determined singular
+   *  or non-singular.
+   **/
+  inline bool 
+  __check_singular_aux(const _Safe_iterator_base* __x)
+  { return __x->_M_singular(); }
+
+  /** The precision to which we can calculate the distance between
+   *  two iterators.
+   */
+  enum _Distance_precision
+    {
+      __dp_equality, //< Can compare iterator equality, only
+      __dp_sign,     //< Can determine equality and ordering
+      __dp_exact     //< Can determine distance precisely
+    };
+
+  /** Determine the distance between two iterators with some known
+   *	precision.
+  */
+  template<typename _Iterator>
+    inline std::pair<typename std::iterator_traits<_Iterator>::difference_type,
+		     _Distance_precision>
+    __get_distance(const _Iterator& __lhs, const _Iterator& __rhs,
+		   std::random_access_iterator_tag)
+    { return std::make_pair(__rhs - __lhs, __dp_exact); }
+
+  template<typename _Iterator>
+    inline std::pair<typename std::iterator_traits<_Iterator>::difference_type,
+		     _Distance_precision>
+    __get_distance(const _Iterator& __lhs, const _Iterator& __rhs,
+		   std::forward_iterator_tag)
+    { return std::make_pair(__lhs == __rhs? 0 : 1, __dp_equality); }
+
+  template<typename _Iterator>
+    inline std::pair<typename std::iterator_traits<_Iterator>::difference_type,
+		     _Distance_precision>
+    __get_distance(const _Iterator& __lhs, const _Iterator& __rhs)
+    {
+      typedef typename std::iterator_traits<_Iterator>::iterator_category
+	  _Category;
+      return __get_distance(__lhs, __rhs, _Category());
+    }
+
+  /** \brief Safe iterator wrapper.
+   *
+   *  The class template %_Safe_iterator is a wrapper around an
+   *  iterator that tracks the iterator's movement among sequences and
+   *  checks that operations performed on the "safe" iterator are
+   *  legal. In additional to the basic iterator operations (which are
+   *  validated, and then passed to the underlying iterator),
+   *  %_Safe_iterator has member functions for iterator invalidation,
+   *  attaching/detaching the iterator from sequences, and querying
+   *  the iterator's state.
+   */
+  template<typename _Iterator, typename _Sequence>
+    class _Safe_iterator : public _Safe_iterator_base
+    {
+      typedef _Safe_iterator _Self;
+      typedef typename _Sequence::const_iterator _Const_iterator;
+
+      /// The underlying iterator
+      _Iterator _M_current;
+
+      /// Determine if this is a constant iterator.
+      bool
+      _M_constant() const
+      { return std::__are_same<_Const_iterator, _Safe_iterator>::__value; }
+
+      typedef std::iterator_traits<_Iterator> _Traits;
+
+    public:
+      typedef _Iterator                           iterator_type;
+      typedef typename _Traits::iterator_category iterator_category;
+      typedef typename _Traits::value_type        value_type;
+      typedef typename _Traits::difference_type   difference_type;
+      typedef typename _Traits::reference         reference;
+      typedef typename _Traits::pointer           pointer;
+
+      /// @post the iterator is singular and unattached
+      _Safe_iterator() _GLIBCXX_NOEXCEPT : _M_current() { }
+
+      /**
+       * @brief Safe iterator construction from an unsafe iterator and
+       * its sequence.
+       *
+       * @pre @p seq is not NULL
+       * @post this is not singular
+       */
+      _Safe_iterator(const _Iterator& __i, const _Sequence* __seq)
+      _GLIBCXX_NOEXCEPT
+      : _Safe_iterator_base(__seq, _M_constant()), _M_current(__i)
+      {
+	_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
+			      _M_message(__msg_init_singular)
+			      ._M_iterator(*this, "this"));
+      }
+
+      /**
+       * @brief Copy construction.
+       */
+      _Safe_iterator(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT
+      : _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// DR 408. Is vector<reverse_iterator<char*> > forbidden?
+	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+			      || __x._M_current == _Iterator(),
+			      _M_message(__msg_init_copy_singular)
+			      ._M_iterator(*this, "this")
+			      ._M_iterator(__x, "other"));
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       * @brief Move construction.
+       * @post __x is singular and unattached
+       */
+      _Safe_iterator(_Safe_iterator&& __x) noexcept : _M_current()
+      {
+	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+			      || __x._M_current == _Iterator(),
+			      _M_message(__msg_init_copy_singular)
+			      ._M_iterator(*this, "this")
+			      ._M_iterator(__x, "other"));
+	std::swap(_M_current, __x._M_current);
+	this->_M_attach(__x._M_sequence);
+	__x._M_detach();
+      }
+#endif
+
+      /**
+       *  @brief Converting constructor from a mutable iterator to a
+       *  constant iterator.
+      */
+      template<typename _MutableIterator>
+        _Safe_iterator(
+          const _Safe_iterator<_MutableIterator,
+          typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator,
+                      typename _Sequence::iterator::iterator_type>::__value),
+                   _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT
+	: _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base())
+        {
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // DR 408. Is vector<reverse_iterator<char*> > forbidden?
+	  _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+				|| __x.base() == _Iterator(),
+				_M_message(__msg_init_const_singular)
+				._M_iterator(*this, "this")
+				._M_iterator(__x, "other"));
+	}
+
+      /**
+       * @brief Copy assignment.
+       */
+      _Safe_iterator&
+      operator=(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// DR 408. Is vector<reverse_iterator<char*> > forbidden?
+	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+			      || __x._M_current == _Iterator(),
+			      _M_message(__msg_copy_singular)
+			      ._M_iterator(*this, "this")
+			      ._M_iterator(__x, "other"));
+	_M_current = __x._M_current;
+	this->_M_attach(__x._M_sequence);
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       * @brief Move assignment.
+       * @post __x is singular and unattached
+       */
+      _Safe_iterator&
+      operator=(_Safe_iterator&& __x) noexcept
+      {
+	_GLIBCXX_DEBUG_VERIFY(this != &__x,
+			      _M_message(__msg_self_move_assign)
+			      ._M_iterator(*this, "this"));
+	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+			      || __x._M_current == _Iterator(),
+			      _M_message(__msg_copy_singular)
+			      ._M_iterator(*this, "this")
+			      ._M_iterator(__x, "other"));
+	_M_current = __x._M_current;
+	_M_attach(__x._M_sequence);
+	__x._M_detach();
+	__x._M_current = _Iterator();
+	return *this;
+      }
+#endif
+
+      /**
+       *  @brief Iterator dereference.
+       *  @pre iterator is dereferenceable
+       */
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
+			      _M_message(__msg_bad_deref)
+			      ._M_iterator(*this, "this"));
+	return *_M_current;
+      }
+
+      /**
+       *  @brief Iterator dereference.
+       *  @pre iterator is dereferenceable
+       *  @todo Make this correct w.r.t. iterators that return proxies
+       */
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
+			      _M_message(__msg_bad_deref)
+			      ._M_iterator(*this, "this"));
+	return std::__addressof(*_M_current);
+      }
+
+      // ------ Input iterator requirements ------
+      /**
+       *  @brief Iterator preincrement
+       *  @pre iterator is incrementable
+       */
+      _Safe_iterator&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
+			      _M_message(__msg_bad_inc)
+			      ._M_iterator(*this, "this"));
+	++_M_current;
+	return *this;
+      }
+
+      /**
+       *  @brief Iterator postincrement
+       *  @pre iterator is incrementable
+       */
+      _Safe_iterator
+      operator++(int) _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
+			      _M_message(__msg_bad_inc)
+			      ._M_iterator(*this, "this"));
+	_Safe_iterator __tmp(*this);
+	++_M_current;
+	return __tmp;
+      }
+
+      // ------ Bidirectional iterator requirements ------
+      /**
+       *  @brief Iterator predecrement
+       *  @pre iterator is decrementable
+       */
+      _Safe_iterator&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
+			      _M_message(__msg_bad_dec)
+			      ._M_iterator(*this, "this"));
+	--_M_current;
+	return *this;
+      }
+
+      /**
+       *  @brief Iterator postdecrement
+       *  @pre iterator is decrementable
+       */
+      _Safe_iterator
+      operator--(int) _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
+			      _M_message(__msg_bad_dec)
+			      ._M_iterator(*this, "this"));
+	_Safe_iterator __tmp(*this);
+	--_M_current;
+	return __tmp;
+      }
+
+      // ------ Random access iterator requirements ------
+      reference
+      operator[](const difference_type& __n) const _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
+			      && this->_M_can_advance(__n+1),
+			      _M_message(__msg_iter_subscript_oob)
+			      ._M_iterator(*this)._M_integer(__n));
+
+	return _M_current[__n];
+      }
+
+      _Safe_iterator&
+      operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n),
+			      _M_message(__msg_advance_oob)
+			      ._M_iterator(*this)._M_integer(__n));
+	_M_current += __n;
+	return *this;
+      }
+
+      _Safe_iterator
+      operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT
+      {
+	_Safe_iterator __tmp(*this);
+	__tmp += __n;
+	return __tmp;
+      }
+
+      _Safe_iterator&
+      operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n),
+			      _M_message(__msg_retreat_oob)
+			      ._M_iterator(*this)._M_integer(__n));
+	_M_current += -__n;
+	return *this;
+      }
+
+      _Safe_iterator
+      operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT
+      {
+	_Safe_iterator __tmp(*this);
+	__tmp -= __n;
+	return __tmp;
+      }
+
+      // ------ Utilities ------
+      /**
+       * @brief Return the underlying iterator
+       */
+      _Iterator
+      base() const _GLIBCXX_NOEXCEPT { return _M_current; }
+
+      /**
+       * @brief Conversion to underlying non-debug iterator to allow
+       * better interaction with non-debug containers.
+       */
+      operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }
+
+      /** Attach iterator to the given sequence. */
+      void
+      _M_attach(_Safe_sequence_base* __seq)
+      {
+	_Safe_iterator_base::_M_attach(__seq, _M_constant());
+      }
+
+      /** Likewise, but not thread-safe. */
+      void
+      _M_attach_single(_Safe_sequence_base* __seq)
+      {
+	_Safe_iterator_base::_M_attach_single(__seq, _M_constant());
+      }
+
+      /// Is the iterator dereferenceable?
+      bool
+      _M_dereferenceable() const
+      { return !this->_M_singular() && !_M_is_end() && !_M_is_before_begin(); }
+
+      /// Is the iterator before a dereferenceable one?
+      bool
+      _M_before_dereferenceable() const
+      {
+	if (this->_M_incrementable())
+	{
+	  _Iterator __base = base();
+	  return ++__base != _M_get_sequence()->_M_base().end();
+	}
+	return false;
+      }
+
+      /// Is the iterator incrementable?
+      bool
+      _M_incrementable() const
+      { return !this->_M_singular() && !_M_is_end(); }
+
+      // Is the iterator decrementable?
+      bool
+      _M_decrementable() const { return !_M_singular() && !_M_is_begin(); }
+
+      // Can we advance the iterator @p __n steps (@p __n may be negative)
+      bool
+      _M_can_advance(const difference_type& __n) const;
+
+      // Is the iterator range [*this, __rhs) valid?
+      bool
+      _M_valid_range(const _Safe_iterator& __rhs) const;
+
+      // The sequence this iterator references.
+      typename
+      __gnu_cxx::__conditional_type<std::__are_same<_Const_iterator,
+						    _Safe_iterator>::__value,
+				    const _Sequence*,
+				    _Sequence*>::__type
+      _M_get_sequence() const
+      { return static_cast<_Sequence*>(_M_sequence); }
+
+      /// Is this iterator equal to the sequence's begin() iterator?
+      bool
+      _M_is_begin() const
+      { return base() == _M_get_sequence()->_M_base().begin(); }
+
+      /// Is this iterator equal to the sequence's end() iterator?
+      bool
+      _M_is_end() const
+      { return base() == _M_get_sequence()->_M_base().end(); }
+
+      /// Is this iterator equal to the sequence's before_begin() iterator if
+      /// any?
+      bool
+      _M_is_before_begin() const
+      { return _BeforeBeginHelper<_Sequence>::_S_Is(*this); }
+
+      /// Is this iterator equal to the sequence's before_begin() iterator if
+      /// any or begin() otherwise?
+      bool
+      _M_is_beginnest() const
+      { return _BeforeBeginHelper<_Sequence>::_S_Is_Beginnest(*this); }
+    };
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
+	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() == __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
+               const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() == __rhs.base();
+    }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
+	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() != __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
+               const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() != __rhs.base();
+    }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
+	      const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() < __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
+	      const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() < __rhs.base();
+    }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
+	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() <= __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
+               const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() <= __rhs.base();
+    }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
+	      const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() > __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
+	      const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() > __rhs.base();
+    }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
+	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() >= __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
+               const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_order_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_order_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() >= __rhs.base();
+    }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // According to the resolution of DR179 not only the various comparison
+  // operators but also operator- must accept mixed iterator/const_iterator
+  // parameters.
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type
+    operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
+	      const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_distance_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_distance_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() - __rhs.base();
+    }
+
+   template<typename _Iterator, typename _Sequence>
+     inline typename _Safe_iterator<_Iterator, _Sequence>::difference_type
+     operator-(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
+	       const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+     {
+       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			     _M_message(__msg_distance_bad)
+			     ._M_iterator(__lhs, "lhs")
+			     ._M_iterator(__rhs, "rhs"));
+       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			     _M_message(__msg_distance_different)
+			     ._M_iterator(__lhs, "lhs")
+			     ._M_iterator(__rhs, "rhs"));
+       return __lhs.base() - __rhs.base();
+     }
+
+  template<typename _Iterator, typename _Sequence>
+    inline _Safe_iterator<_Iterator, _Sequence>
+    operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n,
+	      const _Safe_iterator<_Iterator, _Sequence>& __i) _GLIBCXX_NOEXCEPT
+    { return __i + __n; }
+} // namespace __gnu_debug
+
+#include <debug/safe_iterator.tcc>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_iterator.tcc b/gcc-4.9/libstdc++-v3/include/debug/safe_iterator.tcc
new file mode 100644
index 0000000..0402d7e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_iterator.tcc
@@ -0,0 +1,100 @@
+// Debugging iterator implementation (out of line) -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_iterator.tcc
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_TCC
+#define _GLIBCXX_DEBUG_SAFE_ITERATOR_TCC 1
+
+namespace __gnu_debug
+{
+  template<typename _Iterator, typename _Sequence>
+    bool
+    _Safe_iterator<_Iterator, _Sequence>::
+    _M_can_advance(const difference_type& __n) const
+    {
+      if (this->_M_singular())
+	return false;
+      if (__n == 0)
+	return true;
+      if (__n < 0)
+	{
+	  std::pair<difference_type, _Distance_precision> __dist =
+	    __get_distance(_M_get_sequence()->_M_base().begin(), base());
+	  bool __ok =  ((__dist.second == __dp_exact && __dist.first >= -__n)
+			|| (__dist.second != __dp_exact && __dist.first > 0));
+	  return __ok;
+	}
+      else
+	{
+	  std::pair<difference_type, _Distance_precision> __dist =
+	    __get_distance(base(), _M_get_sequence()->_M_base().end());
+	  bool __ok = ((__dist.second == __dp_exact && __dist.first >= __n)
+		       || (__dist.second != __dp_exact && __dist.first > 0));
+	  return __ok;
+	}
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    bool
+    _Safe_iterator<_Iterator, _Sequence>::
+    _M_valid_range(const _Safe_iterator& __rhs) const
+    {
+      if (!_M_can_compare(__rhs))
+	return false;
+
+      /* Determine if we can order the iterators without the help of
+	 the container */
+      std::pair<difference_type, _Distance_precision> __dist =
+	__get_distance(base(), __rhs.base());
+      switch (__dist.second) {
+      case __dp_equality:
+	if (__dist.first == 0)
+	  return true;
+	break;
+
+      case __dp_sign:
+      case __dp_exact:
+	return __dist.first >= 0;
+      }
+
+      /* We can only test for equality, but check if one of the
+	 iterators is at an extreme. */
+      /* Optim for classic [begin, it) or [it, end) ranges, limit checks
+       * when code is valid.  Note, for the special case of forward_list,
+       * before_begin replaces the role of begin.  */ 
+      if (_M_is_beginnest() || __rhs._M_is_end())
+	return true;
+      if (_M_is_end() || __rhs._M_is_beginnest())
+	return false;
+
+      // Assume that this is a valid range; we can't check anything else
+      return true;
+    }
+} // namespace __gnu_debug
+
+#endif
+
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_local_iterator.h b/gcc-4.9/libstdc++-v3/include/debug/safe_local_iterator.h
new file mode 100644
index 0000000..77552ce
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_local_iterator.h
@@ -0,0 +1,362 @@
+// Safe iterator implementation  -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_local_iterator.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_H
+#define _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_H 1
+
+#include <debug/debug.h>
+#include <debug/macros.h>
+#include <debug/functions.h>
+#include <debug/safe_unordered_base.h>
+#include <ext/type_traits.h>
+
+namespace __gnu_debug
+{
+  /** \brief Safe iterator wrapper.
+   *
+   *  The class template %_Safe_local_iterator is a wrapper around an
+   *  iterator that tracks the iterator's movement among sequences and
+   *  checks that operations performed on the "safe" iterator are
+   *  legal. In additional to the basic iterator operations (which are
+   *  validated, and then passed to the underlying iterator),
+   *  %_Safe_local_iterator has member functions for iterator invalidation,
+   *  attaching/detaching the iterator from sequences, and querying
+   *  the iterator's state.
+   */
+  template<typename _Iterator, typename _Sequence>
+    class _Safe_local_iterator : public _Safe_local_iterator_base
+    {
+      typedef _Safe_local_iterator _Self;
+      typedef typename _Sequence::const_local_iterator _Const_local_iterator;
+      typedef typename _Sequence::size_type size_type;
+
+      /// The underlying iterator
+      _Iterator _M_current;
+
+      /// Determine if this is a constant iterator.
+      bool
+      _M_constant() const
+      {
+	return std::__are_same<_Const_local_iterator,
+			       _Safe_local_iterator>::__value;
+      }
+
+      typedef std::iterator_traits<_Iterator> _Traits;
+
+    public:
+      typedef _Iterator                           iterator_type;
+      typedef typename _Traits::iterator_category iterator_category;
+      typedef typename _Traits::value_type        value_type;
+      typedef typename _Traits::difference_type   difference_type;
+      typedef typename _Traits::reference         reference;
+      typedef typename _Traits::pointer           pointer;
+
+      /// @post the iterator is singular and unattached
+      _Safe_local_iterator() : _M_current() { }
+
+      /**
+       * @brief Safe iterator construction from an unsafe iterator and
+       * its sequence.
+       *
+       * @pre @p seq is not NULL
+       * @post this is not singular
+       */
+      _Safe_local_iterator(const _Iterator& __i, const _Sequence* __seq)
+      : _Safe_local_iterator_base(__seq, _M_constant()), _M_current(__i)
+      {
+	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
+			      _M_message(__msg_init_singular)
+			      ._M_iterator(*this, "this"));
+      }
+
+      /**
+       * @brief Copy construction.
+       */
+      _Safe_local_iterator(const _Safe_local_iterator& __x)
+      : _Safe_local_iterator_base(__x, _M_constant()),
+	_M_current(__x._M_current)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// DR 408. Is vector<reverse_iterator<char*> > forbidden?
+	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+			      || __x.base() == _Iterator(),
+			      _M_message(__msg_init_copy_singular)
+			      ._M_iterator(*this, "this")
+			      ._M_iterator(__x, "other"));
+      }
+
+      /**
+       *  @brief Converting constructor from a mutable iterator to a
+       *  constant iterator.
+      */
+      template<typename _MutableIterator>
+	_Safe_local_iterator(
+	  const _Safe_local_iterator<_MutableIterator,
+	  typename __gnu_cxx::__enable_if<std::__are_same<
+	      _MutableIterator,
+	      typename _Sequence::local_iterator::iterator_type>::__value,
+					  _Sequence>::__type>& __x)
+	: _Safe_local_iterator_base(__x, _M_constant()),
+	  _M_current(__x.base())
+	{
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // DR 408. Is vector<reverse_iterator<char*> > forbidden?
+	  _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+				|| __x.base() == _Iterator(),
+				_M_message(__msg_init_const_singular)
+				._M_iterator(*this, "this")
+				._M_iterator(__x, "other"));
+	}
+
+      /**
+       * @brief Copy assignment.
+       */
+      _Safe_local_iterator&
+      operator=(const _Safe_local_iterator& __x)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// DR 408. Is vector<reverse_iterator<char*> > forbidden?
+	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+			      || __x.base() == _Iterator(),
+			      _M_message(__msg_copy_singular)
+			      ._M_iterator(*this, "this")
+			      ._M_iterator(__x, "other"));
+	_M_current = __x._M_current;
+	this->_M_attach(__x._M_sequence);
+	return *this;
+      }
+
+      /**
+       *  @brief Iterator dereference.
+       *  @pre iterator is dereferenceable
+       */
+      reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
+			      _M_message(__msg_bad_deref)
+			      ._M_iterator(*this, "this"));
+	return *_M_current;
+      }
+
+      /**
+       *  @brief Iterator dereference.
+       *  @pre iterator is dereferenceable
+       *  @todo Make this correct w.r.t. iterators that return proxies
+       */
+      pointer
+      operator->() const
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
+			      _M_message(__msg_bad_deref)
+			      ._M_iterator(*this, "this"));
+	return std::__addressof(*_M_current);
+      }
+
+      // ------ Input iterator requirements ------
+      /**
+       *  @brief Iterator preincrement
+       *  @pre iterator is incrementable
+       */
+      _Safe_local_iterator&
+      operator++()
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
+			      _M_message(__msg_bad_inc)
+			      ._M_iterator(*this, "this"));
+	++_M_current;
+	return *this;
+      }
+
+      /**
+       *  @brief Iterator postincrement
+       *  @pre iterator is incrementable
+       */
+      _Safe_local_iterator
+      operator++(int)
+      {
+	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
+			      _M_message(__msg_bad_inc)
+			      ._M_iterator(*this, "this"));
+	_Safe_local_iterator __tmp(*this);
+	++_M_current;
+	return __tmp;
+      }
+
+      // ------ Utilities ------
+      /**
+       * @brief Return the underlying iterator
+       */
+      _Iterator
+      base() const { return _M_current; }
+
+      /**
+       * @brief Return the bucket
+       */
+      size_type
+      bucket() const { return _M_current._M_get_bucket(); }
+
+      /**
+       * @brief Conversion to underlying non-debug iterator to allow
+       * better interaction with non-debug containers.
+       */
+      operator _Iterator() const { return _M_current; }
+
+      /** Attach iterator to the given sequence. */
+      void
+      _M_attach(_Safe_sequence_base* __seq)
+      { _Safe_iterator_base::_M_attach(__seq, _M_constant()); }
+
+      /** Likewise, but not thread-safe. */
+      void
+      _M_attach_single(_Safe_sequence_base* __seq)
+      { _Safe_iterator_base::_M_attach_single(__seq, _M_constant()); }
+
+      /// Is the iterator dereferenceable?
+      bool
+      _M_dereferenceable() const
+      { return !this->_M_singular() && !_M_is_end(); }
+
+      /// Is the iterator incrementable?
+      bool
+      _M_incrementable() const
+      { return !this->_M_singular() && !_M_is_end(); }
+
+      // Is the iterator range [*this, __rhs) valid?
+      bool
+      _M_valid_range(const _Safe_local_iterator& __rhs) const;
+
+      // The sequence this iterator references.
+      typename
+      __gnu_cxx::__conditional_type<std::__are_same<_Const_local_iterator,
+						    _Safe_local_iterator>::__value,
+				    const _Sequence*,
+				    _Sequence*>::__type
+      _M_get_sequence() const
+      { return static_cast<_Sequence*>(_M_sequence); }
+
+      /// Is this iterator equal to the sequence's begin(bucket) iterator?
+      bool _M_is_begin() const
+      { return base() == _M_get_sequence()->_M_base().begin(bucket()); }
+
+      /// Is this iterator equal to the sequence's end(bucket) iterator?
+      bool _M_is_end() const
+      { return base() == _M_get_sequence()->_M_base().end(bucket()); }
+
+      /// Is this iterator part of the same bucket as the other one?
+      template<typename _Other>
+	bool
+	_M_in_same_bucket(const _Safe_local_iterator<_Other,
+						     _Sequence>& __other) const
+	{ return bucket() == __other.bucket(); }
+    };
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator==(const _Safe_local_iterator<_IteratorL, _Sequence>& __lhs,
+	       const _Safe_local_iterator<_IteratorR, _Sequence>& __rhs)
+    {
+      _GLIBCXX_DEBUG_VERIFY(!__lhs._M_singular() && !__rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs),
+			    _M_message(__msg_local_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() == __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator==(const _Safe_local_iterator<_Iterator, _Sequence>& __lhs,
+	       const _Safe_local_iterator<_Iterator, _Sequence>& __rhs)
+    {
+      _GLIBCXX_DEBUG_VERIFY(!__lhs._M_singular() && !__rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs),
+			    _M_message(__msg_local_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() == __rhs.base();
+    }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator!=(const _Safe_local_iterator<_IteratorL, _Sequence>& __lhs,
+	       const _Safe_local_iterator<_IteratorR, _Sequence>& __rhs)
+    {
+      _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs),
+			    _M_message(__msg_local_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() != __rhs.base();
+    }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator!=(const _Safe_local_iterator<_Iterator, _Sequence>& __lhs,
+	       const _Safe_local_iterator<_Iterator, _Sequence>& __rhs)
+    {
+      _GLIBCXX_DEBUG_VERIFY(!__lhs._M_singular() && !__rhs._M_singular(),
+			    _M_message(__msg_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
+			    _M_message(__msg_compare_different)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs),
+			    _M_message(__msg_local_iter_compare_bad)
+			    ._M_iterator(__lhs, "lhs")
+			    ._M_iterator(__rhs, "rhs"));
+      return __lhs.base() != __rhs.base();
+    }
+} // namespace __gnu_debug
+
+#include <debug/safe_local_iterator.tcc>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_local_iterator.tcc b/gcc-4.9/libstdc++-v3/include/debug/safe_local_iterator.tcc
new file mode 100644
index 0000000..3f65f69
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_local_iterator.tcc
@@ -0,0 +1,74 @@
+// Debugging iterator implementation (out of line) -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_local_iterator.tcc
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_TCC
+#define _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_TCC 1
+
+namespace __gnu_debug
+{
+  template<typename _Iterator, typename _Sequence>
+    bool
+    _Safe_local_iterator<_Iterator, _Sequence>::
+    _M_valid_range(const _Safe_local_iterator& __rhs) const
+    {
+      if (!_M_can_compare(__rhs))
+	return false;
+      if (bucket() != __rhs.bucket())
+	return false;
+
+      /* Determine if we can order the iterators without the help of
+	 the container */
+      std::pair<difference_type, _Distance_precision> __dist =
+	__get_distance(base(), __rhs.base());
+      switch (__dist.second)
+	{
+	case __dp_equality:
+	  if (__dist.first == 0)
+	    return true;
+	  break;
+
+	case __dp_sign:
+	case __dp_exact:
+	  return __dist.first >= 0;
+	}
+
+      /* We can only test for equality, but check if one of the
+	 iterators is at an extreme. */
+      /* Optim for classic [begin, it) or [it, end) ranges, limit checks
+       * when code is valid. */
+      if (_M_is_begin() || __rhs._M_is_end())
+	return true;
+      if (_M_is_end() || __rhs._M_is_begin())
+	return false;
+
+      // Assume that this is a valid range; we can't check anything else
+      return true;
+    }
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_sequence.h b/gcc-4.9/libstdc++-v3/include/debug/safe_sequence.h
new file mode 100644
index 0000000..245d851
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_sequence.h
@@ -0,0 +1,134 @@
+// Safe sequence implementation  -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_sequence.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_SEQUENCE_H
+#define _GLIBCXX_DEBUG_SAFE_SEQUENCE_H 1
+
+#include <debug/debug.h>
+#include <debug/macros.h>
+#include <debug/functions.h>
+#include <debug/safe_base.h>
+
+namespace __gnu_debug
+{
+  template<typename _Iterator, typename _Sequence>
+    class _Safe_iterator;
+
+  /** A simple function object that returns true if the passed-in
+   *  value is not equal to the stored value. It saves typing over
+   *  using both bind1st and not_equal.
+   */
+  template<typename _Type>
+    class _Not_equal_to
+    {
+      _Type __value;
+
+    public:
+      explicit _Not_equal_to(const _Type& __v) : __value(__v) { }
+
+      bool
+      operator()(const _Type& __x) const
+      { return __value != __x; }
+    };
+
+  /** A simple function object that returns true if the passed-in
+   *  value is equal to the stored value. */
+  template <typename _Type>
+    class _Equal_to
+    {
+      _Type __value;
+
+    public:
+      explicit _Equal_to(const _Type& __v) : __value(__v) { }
+
+      bool
+      operator()(const _Type& __x) const
+      { return __value == __x; }
+    };
+
+  /** A function object that returns true when the given random access
+      iterator is at least @c n steps away from the given iterator. */
+  template<typename _Iterator>
+    class _After_nth_from
+    {
+      typedef typename std::iterator_traits<_Iterator>::difference_type
+      difference_type;
+
+      _Iterator _M_base;
+      difference_type _M_n;
+
+    public:
+      _After_nth_from(const difference_type& __n, const _Iterator& __base)
+      : _M_base(__base), _M_n(__n) { }
+
+      bool
+      operator()(const _Iterator& __x) const
+      { return __x - _M_base >= _M_n; }
+    };
+
+  /**
+   * @brief Base class for constructing a @a safe sequence type that
+   * tracks iterators that reference it.
+   *
+   * The class template %_Safe_sequence simplifies the construction of
+   * @a safe sequences that track the iterators that reference the
+   * sequence, so that the iterators are notified of changes in the
+   * sequence that may affect their operation, e.g., if the container
+   * invalidates its iterators or is destructed. This class template
+   * may only be used by deriving from it and passing the name of the
+   * derived class as its template parameter via the curiously
+   * recurring template pattern. The derived class must have @c
+   * iterator and @c const_iterator types that are instantiations of
+   * class template _Safe_iterator for this sequence. Iterators will
+   * then be tracked automatically.
+   */
+  template<typename _Sequence>
+    class _Safe_sequence : public _Safe_sequence_base
+    {
+    public:
+      /** Invalidates all iterators @c x that reference this sequence,
+	  are not singular, and for which @c __pred(x) returns @c
+	  true. @c __pred will be invoked with the normal iterators nested
+	  in the safe ones. */
+      template<typename _Predicate>
+        void
+        _M_invalidate_if(_Predicate __pred);
+
+      /** Transfers all iterators @c x that reference @c from sequence,
+	  are not singular, and for which @c __pred(x) returns @c
+	  true. @c __pred will be invoked with the normal iterators nested
+	  in the safe ones. */
+      template<typename _Predicate>
+        void
+        _M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred);
+    };
+} // namespace __gnu_debug
+
+#include <debug/safe_sequence.tcc>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_sequence.tcc b/gcc-4.9/libstdc++-v3/include/debug/safe_sequence.tcc
new file mode 100644
index 0000000..fad779c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_sequence.tcc
@@ -0,0 +1,150 @@
+// Safe sequence implementation  -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_sequence.tcc
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC
+#define _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC 1
+
+namespace __gnu_debug
+{
+  template<typename _Sequence>
+    template<typename _Predicate>
+      void
+      _Safe_sequence<_Sequence>::
+      _M_invalidate_if(_Predicate __pred)
+      {
+        typedef typename _Sequence::iterator iterator;
+        typedef typename _Sequence::const_iterator const_iterator;
+
+	__gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
+        for (_Safe_iterator_base* __iter = _M_iterators; __iter;)
+	  {
+	    iterator* __victim = static_cast<iterator*>(__iter);
+	    __iter = __iter->_M_next;
+	    if (!__victim->_M_singular() && __pred(__victim->base()))
+	      {
+		__victim->_M_invalidate();
+	      }
+	  }
+
+        for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;)
+	  {
+	    const_iterator* __victim = static_cast<const_iterator*>(__iter2);
+	    __iter2 = __iter2->_M_next;
+	    if (!__victim->_M_singular() && __pred(__victim->base()))
+	      {
+		__victim->_M_invalidate();
+	      }
+	  }
+      }
+
+  template<typename _Sequence>
+    template<typename _Predicate>
+      void
+      _Safe_sequence<_Sequence>::
+      _M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred)
+      {
+        typedef typename _Sequence::iterator iterator;
+        typedef typename _Sequence::const_iterator const_iterator;
+
+	_Safe_iterator_base* __transfered_iterators = 0;
+	_Safe_iterator_base* __transfered_const_iterators = 0;
+	_Safe_iterator_base* __last_iterator = 0;
+	_Safe_iterator_base* __last_const_iterator = 0;
+	{
+	  // We lock __from first and detach iterator(s) to transfer
+	  __gnu_cxx::__scoped_lock sentry(__from._M_get_mutex());
+
+          for (_Safe_iterator_base* __iter = __from._M_iterators; __iter;)
+	    {
+	      iterator* __victim = static_cast<iterator*>(__iter);
+	      __iter = __iter->_M_next;
+	      if (!__victim->_M_singular() && __pred(__victim->base()))
+		{
+		  __victim->_M_detach_single();
+		  if (__transfered_iterators)
+		    {
+		      __victim->_M_next = __transfered_iterators;
+		      __transfered_iterators->_M_prior = __victim;
+		    }
+		  else
+		    __last_iterator = __victim;
+		  __victim->_M_sequence = this;
+		  __victim->_M_version = this->_M_version;
+		  __transfered_iterators = __victim;
+		}
+	    }
+
+	  for (_Safe_iterator_base* __iter2 = __from._M_const_iterators;
+		 __iter2;)
+	    {
+	      const_iterator* __victim = static_cast<const_iterator*>(__iter2);
+	      __iter2 = __iter2->_M_next;
+	      if (!__victim->_M_singular() && __pred(__victim->base()))
+		{
+		  __victim->_M_detach_single();
+		  if (__transfered_const_iterators)
+		    {
+		      __victim->_M_next = __transfered_const_iterators;
+		      __transfered_const_iterators->_M_prior = __victim;
+		    }
+		  else
+		    __last_const_iterator = __victim;
+		  __victim->_M_sequence = this;
+		  __victim->_M_version = this->_M_version;
+		  __transfered_const_iterators = __victim;
+		}
+	    }
+	}
+
+	// Now we can lock *this and add the transfered iterators if any
+	if (__last_iterator || __last_const_iterator)
+	  {
+	    __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
+	    if (__last_iterator)
+	      {
+		if (this->_M_iterators)
+		  {
+		    this->_M_iterators->_M_prior = __last_iterator;
+		    __last_iterator->_M_next = this->_M_iterators;
+		  }
+		this->_M_iterators = __transfered_iterators;
+	      }
+	    if (__last_const_iterator)
+	      {
+		if (this->_M_const_iterators)
+		  {
+		    this->_M_const_iterators->_M_prior = __last_const_iterator;
+		    __last_const_iterator->_M_next = this->_M_const_iterators;
+		  }
+		this->_M_const_iterators = __transfered_const_iterators;
+	      }
+	  }
+      }
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_base.h b/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_base.h
new file mode 100644
index 0000000..bbb274f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_base.h
@@ -0,0 +1,185 @@
+// Safe container/iterator base implementation  -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_unordered_base.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_UNORDERED_BASE_H
+#define _GLIBCXX_DEBUG_SAFE_UNORDERED_BASE_H 1
+
+#include <debug/safe_base.h>
+
+namespace __gnu_debug
+{
+  class _Safe_unordered_container_base;
+
+  /** \brief Basic functionality for a @a safe iterator.
+   *
+   *  The %_Safe_local_iterator_base base class implements the functionality
+   *  of a safe local iterator that is not specific to a particular iterator
+   *  type. It contains a pointer back to the container it references
+   *  along with iterator version information and pointers to form a
+   *  doubly-linked list of local iterators referenced by the container.
+   *
+   *  This class must not perform any operations that can throw an
+   *  exception, or the exception guarantees of derived iterators will
+   *  be broken.
+   */
+  class _Safe_local_iterator_base : public _Safe_iterator_base
+  {
+  protected:
+    /** Initializes the iterator and makes it singular. */
+    _Safe_local_iterator_base()
+    { }
+
+    /** Initialize the iterator to reference the container pointed to
+     *  by @p __seq. @p __constant is true when we are initializing a
+     *  constant local iterator, and false if it is a mutable local iterator.
+     *  Note that @p __seq may be NULL, in which case the iterator will be
+     *  singular. Otherwise, the iterator will reference @p __seq and
+     *  be nonsingular.
+     */
+    _Safe_local_iterator_base(const _Safe_sequence_base* __seq, bool __constant)
+    { this->_M_attach(const_cast<_Safe_sequence_base*>(__seq), __constant); }
+
+    /** Initializes the iterator to reference the same container that
+	@p __x does. @p __constant is true if this is a constant
+	iterator, and false if it is mutable. */
+    _Safe_local_iterator_base(const _Safe_local_iterator_base& __x,
+			      bool __constant)
+    { this->_M_attach(__x._M_sequence, __constant); }
+
+    _Safe_local_iterator_base&
+    operator=(const _Safe_local_iterator_base&);
+
+    explicit
+    _Safe_local_iterator_base(const _Safe_local_iterator_base&);
+
+    ~_Safe_local_iterator_base() { this->_M_detach(); }
+
+    _Safe_unordered_container_base*
+    _M_get_container() const _GLIBCXX_NOEXCEPT;
+
+  public:
+    /** Attaches this iterator to the given container, detaching it
+     *	from whatever container it was attached to originally. If the
+     *	new container is the NULL pointer, the iterator is left
+     *	unattached.
+     */
+    void _M_attach(_Safe_sequence_base* __seq, bool __constant);
+
+    /** Likewise, but not thread-safe. */
+    void _M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw ();
+
+    /** Detach the iterator for whatever container it is attached to,
+     *	if any.
+    */
+    void _M_detach();
+
+    /** Likewise, but not thread-safe. */
+    void _M_detach_single() throw ();
+  };
+
+  /**
+   * @brief Base class that supports tracking of local iterators that
+   * reference an unordered container.
+   *
+   * The %_Safe_unordered_container_base class provides basic support for
+   * tracking iterators into an unordered container. Containers that track
+   * iterators must derived from %_Safe_unordered_container_base publicly, so
+   * that safe iterators (which inherit _Safe_iterator_base) can
+   * attach to them. This class contains four linked lists of
+   * iterators, one for constant iterators, one for mutable
+   * iterators, one for constant local iterators, one for mutable local
+   * iterators and a version number that allows very fast
+   * invalidation of all iterators that reference the container.
+   *
+   * This class must ensure that no operation on it may throw an
+   * exception, otherwise @a safe containers may fail to provide the
+   * exception-safety guarantees required by the C++ standard.
+   */
+  class _Safe_unordered_container_base : public _Safe_sequence_base
+  {
+    typedef _Safe_sequence_base _Base;
+  public:
+    /// The list of mutable local iterators that reference this container
+    _Safe_iterator_base* _M_local_iterators;
+
+    /// The list of constant local iterators that reference this container
+    _Safe_iterator_base* _M_const_local_iterators;
+
+  protected:
+    // Initialize with a version number of 1 and no iterators
+    _Safe_unordered_container_base()
+    : _M_local_iterators(nullptr), _M_const_local_iterators(nullptr)
+    { }
+
+    // Initialize with a version number of 1 and no iterators
+    _Safe_unordered_container_base(const _Safe_unordered_container_base&)
+    noexcept
+    : _Safe_unordered_container_base() { }
+
+    _Safe_unordered_container_base(_Safe_unordered_container_base&& __x)
+    noexcept
+    : _Safe_unordered_container_base()
+    { this->_M_swap(__x); }
+
+    /** Notify all iterators that reference this container that the
+	container is being destroyed. */
+    ~_Safe_unordered_container_base()
+    { this->_M_detach_all(); }
+
+    /** Detach all iterators, leaving them singular. */
+    void
+    _M_detach_all();
+
+    /** Swap this container with the given container. This operation
+     *  also swaps ownership of the iterators, so that when the
+     *  operation is complete all iterators that originally referenced
+     *  one container now reference the other container.
+     */
+    void
+    _M_swap(_Safe_unordered_container_base& __x);
+
+  public:
+    /** Attach an iterator to this container. */
+    void
+    _M_attach_local(_Safe_iterator_base* __it, bool __constant);
+
+    /** Likewise but not thread safe. */
+    void
+    _M_attach_local_single(_Safe_iterator_base* __it, bool __constant) throw ();
+
+    /** Detach an iterator from this container */
+    void
+    _M_detach_local(_Safe_iterator_base* __it);
+
+    /** Likewise but not thread safe. */
+    void
+    _M_detach_local_single(_Safe_iterator_base* __it) throw ();
+  };
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_container.h b/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_container.h
new file mode 100644
index 0000000..825dee9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_container.h
@@ -0,0 +1,81 @@
+// Safe container implementation  -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_unordered_container.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_H
+#define _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_H 1
+
+#include <debug/debug.h>
+#include <debug/macros.h>
+#include <debug/functions.h>
+#include <debug/safe_unordered_base.h>
+
+namespace __gnu_debug
+{
+  /**
+   * @brief Base class for constructing a @a safe unordered container type
+   * that tracks iterators that reference it.
+   *
+   * The class template %_Safe_unordered_container simplifies the
+   * construction of @a safe unordered containers that track the iterators
+   * that reference the container, so that the iterators are notified of
+   * changes in the container that may affect their operation, e.g., if
+   * the container invalidates its iterators or is destructed. This class
+   * template may only be used by deriving from it and passing the name
+   * of the derived class as its template parameter via the curiously
+   * recurring template pattern. The derived class must have @c
+   * iterator and @c const_iterator types that are instantiations of
+   * class template _Safe_iterator for this container and @c local_iterator
+   * and @c const_local_iterator types that are instantiations of class
+   * template _Safe_local_iterator for this container. Iterators will
+   * then be tracked automatically.
+   */
+  template<typename _Container>
+    class _Safe_unordered_container : public _Safe_unordered_container_base
+    {
+    public:
+      /** Invalidates all iterators @c x that reference this container,
+	  are not singular, and for which @c __pred(x) returns @c
+	  true. @c __pred will be invoked with the normal iterators nested
+	  in the safe ones. */
+      template<typename _Predicate>
+	void
+	_M_invalidate_if(_Predicate __pred);
+
+      /** Invalidates all local iterators @c x that reference this container,
+	  are not singular, and for which @c __pred(x) returns @c
+	  true. @c __pred will be invoked with the normal ilocal iterators
+	  nested in the safe ones. */
+      template<typename _Predicate>
+	void
+	_M_invalidate_local_if(_Predicate __pred);
+    };
+} // namespace __gnu_debug
+
+#include <debug/safe_unordered_container.tcc>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_container.tcc b/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_container.tcc
new file mode 100644
index 0000000..e2c237a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/safe_unordered_container.tcc
@@ -0,0 +1,100 @@
+// Safe container implementation  -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/safe_unordered_container.tcc
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_TCC
+#define _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_TCC 1
+
+namespace __gnu_debug
+{
+  template<typename _Container>
+    template<typename _Predicate>
+      void
+      _Safe_unordered_container<_Container>::
+      _M_invalidate_if(_Predicate __pred)
+      {
+	typedef typename _Container::iterator iterator;
+	typedef typename _Container::const_iterator const_iterator;
+
+	__gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
+	for (_Safe_iterator_base* __iter = _M_iterators; __iter;)
+	  {
+	    iterator* __victim = static_cast<iterator*>(__iter);
+	    __iter = __iter->_M_next;
+	    if (!__victim->_M_singular() && __pred(__victim->base()))
+	      {
+		__victim->_M_invalidate();
+	      }
+	  }
+
+	for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;)
+	  {
+	    const_iterator* __victim = static_cast<const_iterator*>(__iter2);
+	    __iter2 = __iter2->_M_next;
+	    if (!__victim->_M_singular() && __pred(__victim->base()))
+	      {
+		__victim->_M_invalidate();
+	      }
+	  }
+      }
+
+
+  template<typename _Container>
+    template<typename _Predicate>
+      void
+      _Safe_unordered_container<_Container>::
+      _M_invalidate_local_if(_Predicate __pred)
+      {
+	typedef typename _Container::local_iterator local_iterator;
+	typedef typename _Container::const_local_iterator const_local_iterator;
+
+	__gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
+	for (_Safe_iterator_base* __iter = _M_local_iterators; __iter;)
+	  {
+	    local_iterator* __victim = static_cast<local_iterator*>(__iter);
+	    __iter = __iter->_M_next;
+	    if (!__victim->_M_singular() && __pred(__victim->base()))
+	      {
+		__victim->_M_invalidate();
+	      }
+	  }
+
+	for (_Safe_iterator_base* __iter2 = _M_const_local_iterators; __iter2;)
+	  {
+	    const_local_iterator* __victim =
+	      static_cast<const_local_iterator*>(__iter2);
+	    __iter2 = __iter2->_M_next;
+	    if (!__victim->_M_singular() && __pred(__victim->base()))
+	      {
+		__victim->_M_invalidate();
+	      }
+	  }
+      }
+
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/set b/gcc-4.9/libstdc++-v3/include/debug/set
new file mode 100644
index 0000000..d178b94
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/set
@@ -0,0 +1,36 @@
+// Debugging set/multiset implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/set
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SET
+#define _GLIBCXX_DEBUG_SET 1
+
+#include <set>
+#include <debug/set.h>
+#include <debug/multiset.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/set.h b/gcc-4.9/libstdc++-v3/include/debug/set.h
new file mode 100644
index 0000000..c83e2af
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/set.h
@@ -0,0 +1,510 @@
+// Debugging set implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/set.h
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SET_H
+#define _GLIBCXX_DEBUG_SET_H 1
+
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default) 
+{
+namespace __debug
+{
+  /// Class std::set with safety/checking/debug instrumentation.
+  template<typename _Key, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<_Key> >
+    class set
+    : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>,
+      public __gnu_debug::_Safe_sequence<set<_Key, _Compare, _Allocator> >
+    {
+      typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
+
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+#endif
+    public:
+      // types:
+      typedef _Key				    key_type;
+      typedef _Key				    value_type;
+      typedef _Compare				    key_compare;
+      typedef _Compare				    value_compare;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator, set>
+                                                    iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, set>
+                                                    const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      // 23.3.3.1 construct/copy/destroy:
+
+      set() : _Base() { }
+
+      explicit set(const _Compare& __comp,
+		   const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a) { }
+
+      template<typename _InputIterator>
+        set(_InputIterator __first, _InputIterator __last,
+	    const _Compare& __comp = _Compare(),
+	    const _Allocator& __a = _Allocator())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last),
+		__comp, __a) { }
+
+      set(const set& __x)
+      : _Base(__x) { }
+
+      set(const _Base& __x)
+      : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      set(set&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _Base(std::move(__x))
+      { this->_M_swap(__x); }
+
+      set(initializer_list<value_type> __l,
+	  const _Compare& __comp = _Compare(),
+	  const allocator_type& __a = allocator_type())
+      : _Base(__l, __comp, __a) { }
+
+      explicit
+      set(const allocator_type& __a)
+      : _Base(__a) { }
+
+      set(const set& __x, const allocator_type& __a)
+      : _Base(__x, __a) { }
+
+      set(set&& __x, const allocator_type& __a)
+      : _Base(std::move(__x._M_base()), __a) { }
+
+      set(initializer_list<value_type> __l, const allocator_type& __a)
+	: _Base(__l, __a)
+      { }
+
+      template<typename _InputIterator>
+        set(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __a)
+        { }
+#endif
+
+      ~set() _GLIBCXX_NOEXCEPT { }
+
+      set&
+      operator=(const set& __x)
+      {
+	_M_base() = __x;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      set&
+      operator=(set&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      set&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  auto __res = _Base::emplace(std::forward<_Args>(__args)...);
+	  return std::pair<iterator, bool>(iterator(__res.first, this),
+					   __res.second);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__pos);
+	  return iterator(_Base::emplace_hint(__pos.base(),
+					      std::forward<_Args>(__args)...),
+			  this);
+	}
+#endif
+
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      {
+	std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
+	return std::pair<iterator, bool>(iterator(__res.first, this),
+					 __res.second);
+      }
+
+#if __cplusplus >= 201103L
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      {
+	std::pair<_Base_iterator, bool> __res
+	  = _Base::insert(std::move(__x));
+	return std::pair<iterator, bool>(iterator(__res.first, this),
+					 __res.second);
+      }
+#endif
+
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      {
+	__glibcxx_check_insert(__position);
+	return iterator(_Base::insert(__position.base(), __x), this);
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      {
+	__glibcxx_check_insert(__position);
+	return iterator(_Base::insert(__position.base(), std::move(__x)),
+			this);
+      }
+#endif
+
+      template <typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	}
+
+#if __cplusplus >= 201103L
+      void
+      insert(initializer_list<value_type> __l)
+      { _Base::insert(__l); }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	return iterator(_Base::erase(__position.base()), this);
+      }
+#else
+      void
+      erase(iterator __position)
+      {
+	__glibcxx_check_erase(__position);
+	this->_M_invalidate_if(_Equal(__position.base()));
+	_Base::erase(__position.base());
+      }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	_Base_iterator __victim = _Base::find(__x);
+	if (__victim == _Base::end())
+          return 0;
+	else
+	  {
+	    this->_M_invalidate_if(_Equal(__victim));
+	    _Base::erase(__victim);
+	    return 1;
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	return iterator(_Base::erase(__first.base(), __last.base()), this);
+      }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_iterator __victim = __first.base();
+	     __victim != __last.base(); ++__victim)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(_Equal(__victim));
+	  }
+	_Base::erase(__first.base(), __last.base());
+      }
+#endif
+
+      void
+      swap(set& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      {
+#if __cplusplus >= 201103L
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+#endif
+	_Base::swap(__x);
+	this->_M_swap(__x);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_invalidate_all();
+	_Base::clear();
+      }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // set operations:
+      iterator
+      find(const key_type& __x)
+      { return iterator(_Base::find(__x), this); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      find(const key_type& __x) const
+      { return const_iterator(_Base::find(__x), this); }
+
+      using _Base::count;
+
+      iterator
+      lower_bound(const key_type& __x)
+      { return iterator(_Base::lower_bound(__x), this); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return const_iterator(_Base::lower_bound(__x), this); }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return iterator(_Base::upper_bound(__x), this); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return const_iterator(_Base::upper_bound(__x), this); }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __res =
+        _Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+	std::pair<_Base_iterator, _Base_iterator> __res =
+        _Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    private:
+      void
+      _M_invalidate_all()
+      {
+	typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
+	this->_M_invalidate_if(_Not_equal(_M_base().end()));
+      }
+    };
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const set<_Key, _Compare, _Allocator>& __lhs,
+	      const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const set<_Key, _Compare, _Allocator>& __lhs,
+	      const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    void
+    swap(set<_Key, _Compare, _Allocator>& __x,
+	 set<_Key, _Compare, _Allocator>& __y)
+    { return __x.swap(__y); }
+
+} // namespace __debug
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/string b/gcc-4.9/libstdc++-v3/include/debug/string
new file mode 100644
index 0000000..8edc9c4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/string
@@ -0,0 +1,1167 @@
+// Debugging string implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/string
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_STRING
+#define _GLIBCXX_DEBUG_STRING 1
+
+#include <string>
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+
+namespace __gnu_debug
+{
+  /// Class std::basic_string with safety/checking/debug instrumentation.
+  template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
+            typename _Allocator = std::allocator<_CharT> >
+    class basic_string
+    : public std::basic_string<_CharT, _Traits, _Allocator>,
+      public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
+						      _Allocator> >
+    {
+      typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
+      typedef __gnu_debug::_Safe_sequence<basic_string>     _Safe_base;
+
+  public:
+    // types:
+    typedef _Traits				       traits_type;
+    typedef typename _Traits::char_type		       value_type;
+    typedef _Allocator				       allocator_type;
+    typedef typename _Base::size_type                  size_type;
+    typedef typename _Base::difference_type            difference_type;
+    typedef typename _Base::reference                  reference;
+    typedef typename _Base::const_reference            const_reference;
+    typedef typename _Base::pointer                    pointer;
+    typedef typename _Base::const_pointer              const_pointer;
+
+    typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string>
+                                                       iterator;
+    typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+                                         basic_string> const_iterator;
+
+    typedef std::reverse_iterator<iterator>            reverse_iterator;
+    typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
+
+    using _Base::npos;
+
+    // 21.3.1 construct/copy/destroy:
+    explicit basic_string(const _Allocator& __a = _Allocator())
+    // _GLIBCXX_NOEXCEPT
+    : _Base(__a)
+    { }
+
+    // Provides conversion from a release-mode string to a debug-mode string
+    basic_string(const _Base& __base) : _Base(__base) { }
+
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 42. string ctors specify wrong default allocator
+    basic_string(const basic_string& __str)
+    : _Base(__str, 0, _Base::npos, __str.get_allocator())
+    { }
+
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 42. string ctors specify wrong default allocator
+    basic_string(const basic_string& __str, size_type __pos,
+		   size_type __n = _Base::npos,
+		   const _Allocator& __a = _Allocator())
+    : _Base(__str, __pos, __n, __a)
+    { }
+
+    basic_string(const _CharT* __s, size_type __n,
+		   const _Allocator& __a = _Allocator())
+    : _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
+    { }
+
+    basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
+    : _Base(__gnu_debug::__check_string(__s), __a)
+    { this->assign(__s); }
+
+    basic_string(size_type __n, _CharT __c,
+		   const _Allocator& __a = _Allocator())
+    : _Base(__n, __c, __a)
+    { }
+
+    template<typename _InputIterator>
+      basic_string(_InputIterator __begin, _InputIterator __end,
+		   const _Allocator& __a = _Allocator())
+      : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__begin,
+								   __end)),
+	      __gnu_debug::__base(__end), __a)
+      { }
+
+#if __cplusplus >= 201103L
+    basic_string(basic_string&& __str) // noexcept
+    : _Base(std::move(__str))
+    { }
+
+    basic_string(std::initializer_list<_CharT> __l,
+		 const _Allocator& __a = _Allocator())
+    : _Base(__l, __a)
+    { }
+#endif // C++11
+
+    ~basic_string() _GLIBCXX_NOEXCEPT { }
+
+    basic_string&
+    operator=(const basic_string& __str)
+    {
+      *static_cast<_Base*>(this) = __str;
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    operator=(const _CharT* __s)
+    {
+      __glibcxx_check_string(__s);
+      *static_cast<_Base*>(this) = __s;
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    operator=(_CharT __c)
+    {
+      *static_cast<_Base*>(this) = __c;
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+    basic_string&
+    operator=(basic_string&& __str)
+    {
+      __glibcxx_check_self_move_assign(__str);
+      *static_cast<_Base*>(this) = std::move(__str);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    operator=(std::initializer_list<_CharT> __l)
+    {
+      *static_cast<_Base*>(this) = __l;
+      this->_M_invalidate_all();
+      return *this;
+    }
+#endif // C++11
+
+    // 21.3.2 iterators:
+    iterator
+    begin() // _GLIBCXX_NOEXCEPT
+    { return iterator(_Base::begin(), this); }
+
+    const_iterator
+    begin() const _GLIBCXX_NOEXCEPT
+    { return const_iterator(_Base::begin(), this); }
+
+    iterator
+    end() // _GLIBCXX_NOEXCEPT
+    { return iterator(_Base::end(), this); }
+
+    const_iterator
+    end() const _GLIBCXX_NOEXCEPT
+    { return const_iterator(_Base::end(), this); }
+
+    reverse_iterator
+    rbegin() // _GLIBCXX_NOEXCEPT
+    { return reverse_iterator(end()); }
+
+    const_reverse_iterator
+    rbegin() const _GLIBCXX_NOEXCEPT
+    { return const_reverse_iterator(end()); }
+
+    reverse_iterator
+    rend() // _GLIBCXX_NOEXCEPT
+    { return reverse_iterator(begin()); }
+
+    const_reverse_iterator
+    rend() const _GLIBCXX_NOEXCEPT
+    { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+    const_iterator
+    cbegin() const noexcept
+    { return const_iterator(_Base::begin(), this); }
+
+    const_iterator
+    cend() const noexcept
+    { return const_iterator(_Base::end(), this); }
+
+    const_reverse_iterator
+    crbegin() const noexcept
+    { return const_reverse_iterator(end()); }
+
+    const_reverse_iterator
+    crend() const noexcept
+    { return const_reverse_iterator(begin()); }
+#endif
+
+    // 21.3.3 capacity:
+    using _Base::size;
+    using _Base::length;
+    using _Base::max_size;
+
+    void
+    resize(size_type __n, _CharT __c)
+    {
+      _Base::resize(__n, __c);
+      this->_M_invalidate_all();
+    }
+
+    void
+    resize(size_type __n)
+    { this->resize(__n, _CharT()); }
+
+#if __cplusplus >= 201103L
+    void
+    shrink_to_fit() noexcept
+    {
+      if (capacity() > size())
+	{
+	  __try
+	    {
+	      reserve(0);
+	      this->_M_invalidate_all();
+	    }
+	  __catch(...)
+	    { }
+	}
+    }
+#endif
+
+    using _Base::capacity;
+    using _Base::reserve;
+
+    void
+    clear() // _GLIBCXX_NOEXCEPT
+    {
+      _Base::clear();
+      this->_M_invalidate_all();
+    }
+
+    using _Base::empty;
+
+    // 21.3.4 element access:
+    const_reference
+    operator[](size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
+			    _M_message(__gnu_debug::__msg_subscript_oob)
+			    ._M_sequence(*this, "this")
+			    ._M_integer(__pos, "__pos")
+			    ._M_integer(this->size(), "size"));
+      return _M_base()[__pos];
+    }
+
+    reference
+    operator[](size_type __pos) // _GLIBCXX_NOEXCEPT
+    {
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+      __glibcxx_check_subscript(__pos);
+#else
+      // as an extension v3 allows s[s.size()] when s is non-const.
+      _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
+			    _M_message(__gnu_debug::__msg_subscript_oob)
+			    ._M_sequence(*this, "this")
+			    ._M_integer(__pos, "__pos")
+			    ._M_integer(this->size(), "size"));
+#endif
+      return _M_base()[__pos];
+    }
+
+    using _Base::at;
+
+#if __cplusplus >= 201103L
+    using _Base::front;
+    using _Base::back;
+#endif
+
+    // 21.3.5 modifiers:
+    basic_string&
+    operator+=(const basic_string& __str)
+    {
+      _M_base() += __str;
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    operator+=(const _CharT* __s)
+    {
+      __glibcxx_check_string(__s);
+      _M_base() += __s;
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    operator+=(_CharT __c)
+    {
+      _M_base() += __c;
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+    basic_string&
+    operator+=(std::initializer_list<_CharT> __l)
+    {
+      _M_base() += __l;
+      this->_M_invalidate_all();
+      return *this;
+    }
+#endif // C++11
+
+    basic_string&
+    append(const basic_string& __str)
+    {
+      _Base::append(__str);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    append(const basic_string& __str, size_type __pos, size_type __n)
+    {
+      _Base::append(__str, __pos, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    append(const _CharT* __s, size_type __n)
+    {
+      __glibcxx_check_string_len(__s, __n);
+      _Base::append(__s, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    append(const _CharT* __s)
+    {
+      __glibcxx_check_string(__s);
+      _Base::append(__s);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    append(size_type __n, _CharT __c)
+    {
+      _Base::append(__n, __c);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    template<typename _InputIterator>
+      basic_string&
+      append(_InputIterator __first, _InputIterator __last)
+      {
+	__glibcxx_check_valid_range(__first, __last);
+	_Base::append(__gnu_debug::__base(__first),
+		      __gnu_debug::__base(__last));
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 7. string clause minor problems
+    void
+    push_back(_CharT __c)
+    {
+      _Base::push_back(__c);
+      this->_M_invalidate_all();
+    }
+
+    basic_string&
+    assign(const basic_string& __x)
+    {
+      _Base::assign(__x);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+    basic_string&
+    assign(basic_string&& __x)
+    {
+      _Base::assign(std::move(__x));
+      this->_M_invalidate_all();
+      return *this;
+    }
+#endif // C++11
+
+    basic_string&
+    assign(const basic_string& __str, size_type __pos, size_type __n)
+    {
+      _Base::assign(__str, __pos, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    assign(const _CharT* __s, size_type __n)
+    {
+      __glibcxx_check_string_len(__s, __n);
+      _Base::assign(__s, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    assign(const _CharT* __s)
+    {
+      __glibcxx_check_string(__s);
+      _Base::assign(__s);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    assign(size_type __n, _CharT __c)
+    {
+      _Base::assign(__n, __c);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    template<typename _InputIterator>
+      basic_string&
+      assign(_InputIterator __first, _InputIterator __last)
+      {
+	__glibcxx_check_valid_range(__first, __last);
+	_Base::assign(__gnu_debug::__base(__first),
+		      __gnu_debug::__base(__last));
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+    basic_string&
+    assign(std::initializer_list<_CharT> __l)
+    {
+      _Base::assign(__l);
+      this->_M_invalidate_all();
+      return *this;
+    }
+#endif // C++11
+
+    basic_string&
+    insert(size_type __pos1, const basic_string& __str)
+    {
+      _Base::insert(__pos1, __str);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    insert(size_type __pos1, const basic_string& __str,
+	   size_type __pos2, size_type __n)
+    {
+      _Base::insert(__pos1, __str, __pos2, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    insert(size_type __pos, const _CharT* __s, size_type __n)
+    {
+      __glibcxx_check_string(__s);
+      _Base::insert(__pos, __s, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    insert(size_type __pos, const _CharT* __s)
+    {
+      __glibcxx_check_string(__s);
+      _Base::insert(__pos, __s);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    insert(size_type __pos, size_type __n, _CharT __c)
+    {
+      _Base::insert(__pos, __n, __c);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    iterator
+    insert(iterator __p, _CharT __c)
+    {
+      __glibcxx_check_insert(__p);
+      typename _Base::iterator __res = _Base::insert(__p.base(), __c);
+      this->_M_invalidate_all();
+      return iterator(__res, this);
+    }
+
+    void
+    insert(iterator __p, size_type __n, _CharT __c)
+    {
+      __glibcxx_check_insert(__p);
+      _Base::insert(__p.base(), __n, __c);
+      this->_M_invalidate_all();
+    }
+
+    template<typename _InputIterator>
+      void
+      insert(iterator __p, _InputIterator __first, _InputIterator __last)
+      {
+	__glibcxx_check_insert_range(__p, __first, __last);
+	_Base::insert(__p.base(), __gnu_debug::__base(__first),
+				  __gnu_debug::__base(__last));
+	this->_M_invalidate_all();
+      }
+
+#if __cplusplus >= 201103L
+    void
+    insert(iterator __p, std::initializer_list<_CharT> __l)
+    {
+      __glibcxx_check_insert(__p);
+      _Base::insert(__p.base(), __l);
+      this->_M_invalidate_all();
+    }
+#endif // C++11
+
+    basic_string&
+    erase(size_type __pos = 0, size_type __n = _Base::npos)
+    {
+      _Base::erase(__pos, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    iterator
+    erase(iterator __position)
+    {
+      __glibcxx_check_erase(__position);
+      typename _Base::iterator __res = _Base::erase(__position.base());
+      this->_M_invalidate_all();
+      return iterator(__res, this);
+    }
+
+    iterator
+    erase(iterator __first, iterator __last)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 151. can't currently clear() empty container
+      __glibcxx_check_erase_range(__first, __last);
+      typename _Base::iterator __res = _Base::erase(__first.base(),
+						       __last.base());
+      this->_M_invalidate_all();
+      return iterator(__res, this);
+    }
+
+#if __cplusplus >= 201103L
+    void
+    pop_back() // noexcept
+    {
+      __glibcxx_check_nonempty();
+      _Base::pop_back();
+      this->_M_invalidate_all();
+    }
+#endif // C++11
+
+    basic_string&
+    replace(size_type __pos1, size_type __n1, const basic_string& __str)
+    {
+      _Base::replace(__pos1, __n1, __str);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(size_type __pos1, size_type __n1, const basic_string& __str,
+	    size_type __pos2, size_type __n2)
+    {
+      _Base::replace(__pos1, __n1, __str, __pos2, __n2);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(size_type __pos, size_type __n1, const _CharT* __s,
+	    size_type __n2)
+    {
+      __glibcxx_check_string_len(__s, __n2);
+      _Base::replace(__pos, __n1, __s, __n2);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(size_type __pos, size_type __n1, const _CharT* __s)
+    {
+      __glibcxx_check_string(__s);
+      _Base::replace(__pos, __n1, __s);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+    {
+      _Base::replace(__pos, __n1, __n2, __c);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(iterator __i1, iterator __i2, const basic_string& __str)
+    {
+      __glibcxx_check_erase_range(__i1, __i2);
+      _Base::replace(__i1.base(), __i2.base(), __str);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
+    {
+      __glibcxx_check_erase_range(__i1, __i2);
+      __glibcxx_check_string_len(__s, __n);
+      _Base::replace(__i1.base(), __i2.base(), __s, __n);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(iterator __i1, iterator __i2, const _CharT* __s)
+    {
+      __glibcxx_check_erase_range(__i1, __i2);
+      __glibcxx_check_string(__s);
+      _Base::replace(__i1.base(), __i2.base(), __s);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    basic_string&
+    replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
+    {
+      __glibcxx_check_erase_range(__i1, __i2);
+      _Base::replace(__i1.base(), __i2.base(), __n, __c);
+      this->_M_invalidate_all();
+      return *this;
+    }
+
+    template<typename _InputIterator>
+      basic_string&
+      replace(iterator __i1, iterator __i2,
+	      _InputIterator __j1, _InputIterator __j2)
+      {
+	__glibcxx_check_erase_range(__i1, __i2);
+	__glibcxx_check_valid_range(__j1, __j2);
+	_Base::replace(__i1.base(), __i2.base(), __j1, __j2);
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      basic_string& replace(iterator __i1, iterator __i2,
+			    std::initializer_list<_CharT> __l)
+      {
+	__glibcxx_check_erase_range(__i1, __i2);
+	_Base::replace(__i1.base(), __i2.base(), __l);
+	this->_M_invalidate_all();
+	return *this;
+      }
+#endif // C++11
+
+    size_type
+    copy(_CharT* __s, size_type __n, size_type __pos = 0) const
+    {
+      __glibcxx_check_string_len(__s, __n);
+      return _Base::copy(__s, __n, __pos);
+    }
+
+    void
+    swap(basic_string<_CharT,_Traits,_Allocator>& __x)
+    {
+      _Base::swap(__x);
+      this->_M_swap(__x);
+      this->_M_invalidate_all();
+      __x._M_invalidate_all();
+    }
+
+    // 21.3.6 string operations:
+    const _CharT*
+    c_str() const _GLIBCXX_NOEXCEPT
+    {
+      const _CharT* __res = _Base::c_str();
+      this->_M_invalidate_all();
+      return __res;
+    }
+
+    const _CharT*
+    data() const _GLIBCXX_NOEXCEPT
+    {
+      const _CharT* __res = _Base::data();
+      this->_M_invalidate_all();
+      return __res;
+    }
+
+    using _Base::get_allocator;
+
+    size_type
+    find(const basic_string& __str, size_type __pos = 0) const
+      _GLIBCXX_NOEXCEPT
+    { return _Base::find(__str, __pos); }
+
+    size_type
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find(__s, __pos, __n);
+    }
+
+    size_type
+    find(const _CharT* __s, size_type __pos = 0) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find(__s, __pos);
+    }
+
+    size_type
+    find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
+    { return _Base::find(__c, __pos); }
+
+    size_type
+    rfind(const basic_string& __str, size_type __pos = _Base::npos) const
+      _GLIBCXX_NOEXCEPT
+    { return _Base::rfind(__str, __pos); }
+
+    size_type
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_check_string_len(__s, __n);
+      return _Base::rfind(__s, __pos, __n);
+    }
+
+    size_type
+    rfind(const _CharT* __s, size_type __pos = _Base::npos) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::rfind(__s, __pos);
+    }
+
+    size_type
+    rfind(_CharT __c, size_type __pos = _Base::npos) const _GLIBCXX_NOEXCEPT
+    { return _Base::rfind(__c, __pos); }
+
+    size_type
+    find_first_of(const basic_string& __str, size_type __pos = 0) const
+      _GLIBCXX_NOEXCEPT
+    { return _Base::find_first_of(__str, __pos); }
+
+    size_type
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find_first_of(__s, __pos, __n);
+    }
+
+    size_type
+    find_first_of(const _CharT* __s, size_type __pos = 0) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find_first_of(__s, __pos);
+    }
+
+    size_type
+    find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
+    { return _Base::find_first_of(__c, __pos); }
+
+    size_type
+    find_last_of(const basic_string& __str, 
+		 size_type __pos = _Base::npos) const _GLIBCXX_NOEXCEPT
+    { return _Base::find_last_of(__str, __pos); }
+
+    size_type
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find_last_of(__s, __pos, __n);
+    }
+
+    size_type
+    find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find_last_of(__s, __pos);
+    }
+
+    size_type
+    find_last_of(_CharT __c, size_type __pos = _Base::npos) const
+      _GLIBCXX_NOEXCEPT
+    { return _Base::find_last_of(__c, __pos); }
+
+    size_type
+    find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+      _GLIBCXX_NOEXCEPT
+    { return _Base::find_first_not_of(__str, __pos); }
+
+    size_type
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_check_string_len(__s, __n);
+      return _Base::find_first_not_of(__s, __pos, __n);
+    }
+
+    size_type
+    find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find_first_not_of(__s, __pos);
+    }
+
+    size_type
+    find_first_not_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
+    { return _Base::find_first_not_of(__c, __pos); }
+
+    size_type
+    find_last_not_of(const basic_string& __str,
+				  size_type __pos = _Base::npos) const
+      _GLIBCXX_NOEXCEPT
+    { return _Base::find_last_not_of(__str, __pos); }
+
+    size_type
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find_last_not_of(__s, __pos, __n);
+    }
+
+    size_type
+    find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::find_last_not_of(__s, __pos);
+    }
+
+    size_type
+    find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const
+      _GLIBCXX_NOEXCEPT
+    { return _Base::find_last_not_of(__c, __pos); }
+
+    basic_string
+    substr(size_type __pos = 0, size_type __n = _Base::npos) const
+    { return basic_string(_Base::substr(__pos, __n)); }
+
+    int
+    compare(const basic_string& __str) const
+    { return _Base::compare(__str); }
+
+    int
+    compare(size_type __pos1, size_type __n1,
+		  const basic_string& __str) const
+    { return _Base::compare(__pos1, __n1, __str); }
+
+    int
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+	      size_type __pos2, size_type __n2) const
+    { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
+
+    int
+    compare(const _CharT* __s) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::compare(__s);
+    }
+
+    //  _GLIBCXX_RESOLVE_LIB_DEFECTS
+    //  5. string::compare specification questionable
+    int
+    compare(size_type __pos1, size_type __n1, const _CharT* __s) const
+    {
+      __glibcxx_check_string(__s);
+      return _Base::compare(__pos1, __n1, __s);
+    }
+
+    //  _GLIBCXX_RESOLVE_LIB_DEFECTS
+    //  5. string::compare specification questionable
+    int
+    compare(size_type __pos1, size_type __n1,const _CharT* __s,
+	      size_type __n2) const
+    {
+      __glibcxx_check_string_len(__s, __n2);
+      return _Base::compare(__pos1, __n1, __s, __n2);
+    }
+
+    _Base&
+    _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+    const _Base&
+    _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    using _Safe_base::_M_invalidate_all;
+  };
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline basic_string<_CharT,_Traits,_Allocator>
+    operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	      const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline basic_string<_CharT,_Traits,_Allocator>
+    operator+(const _CharT* __lhs,
+	      const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    {
+      __glibcxx_check_string(__lhs);
+      return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline basic_string<_CharT,_Traits,_Allocator>
+    operator+(_CharT __lhs,
+	      const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline basic_string<_CharT,_Traits,_Allocator>
+    operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	      const _CharT* __rhs)
+    {
+      __glibcxx_check_string(__rhs);
+      return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline basic_string<_CharT,_Traits,_Allocator>
+    operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	      _CharT __rhs)
+    { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator==(const _CharT* __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    {
+      __glibcxx_check_string(__lhs);
+      return __lhs == __rhs._M_base();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const _CharT* __rhs)
+    {
+      __glibcxx_check_string(__rhs);
+      return __lhs._M_base() == __rhs;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator!=(const _CharT* __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    {
+      __glibcxx_check_string(__lhs);
+      return __lhs != __rhs._M_base();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const _CharT* __rhs)
+    {
+      __glibcxx_check_string(__rhs);
+      return __lhs._M_base() != __rhs;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	      const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator<(const _CharT* __lhs,
+	      const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    {
+      __glibcxx_check_string(__lhs);
+      return __lhs < __rhs._M_base();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	      const _CharT* __rhs)
+    {
+      __glibcxx_check_string(__rhs);
+      return __lhs._M_base() < __rhs;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator<=(const _CharT* __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    {
+      __glibcxx_check_string(__lhs);
+      return __lhs <= __rhs._M_base();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const _CharT* __rhs)
+    {
+      __glibcxx_check_string(__rhs);
+      return __lhs._M_base() <= __rhs;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator>=(const _CharT* __lhs,
+	       const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    {
+      __glibcxx_check_string(__lhs);
+      return __lhs >= __rhs._M_base();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	       const _CharT* __rhs)
+    {
+      __glibcxx_check_string(__rhs);
+      return __lhs._M_base() >= __rhs;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	      const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator>(const _CharT* __lhs,
+	      const basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    {
+      __glibcxx_check_string(__lhs);
+      return __lhs > __rhs._M_base();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline bool
+    operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	      const _CharT* __rhs)
+    {
+      __glibcxx_check_string(__rhs);
+      return __lhs._M_base() > __rhs;
+    }
+
+  // 21.3.7.8:
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    inline void
+    swap(basic_string<_CharT,_Traits,_Allocator>& __lhs,
+	 basic_string<_CharT,_Traits,_Allocator>& __rhs)
+    { __lhs.swap(__rhs); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const basic_string<_CharT, _Traits, _Allocator>& __str)
+    { return __os << __str._M_base(); }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    std::basic_istream<_CharT,_Traits>&
+    operator>>(std::basic_istream<_CharT,_Traits>& __is,
+	       basic_string<_CharT,_Traits,_Allocator>& __str)
+    {
+      std::basic_istream<_CharT,_Traits>& __res = __is >> __str._M_base();
+      __str._M_invalidate_all();
+      return __res;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    std::basic_istream<_CharT,_Traits>&
+    getline(std::basic_istream<_CharT,_Traits>& __is,
+	    basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim)
+    {
+      std::basic_istream<_CharT,_Traits>& __res = getline(__is,
+							  __str._M_base(),
+							__delim);
+      __str._M_invalidate_all();
+      return __res;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    std::basic_istream<_CharT,_Traits>&
+    getline(std::basic_istream<_CharT,_Traits>& __is,
+	    basic_string<_CharT,_Traits,_Allocator>& __str)
+    {
+      std::basic_istream<_CharT,_Traits>& __res = getline(__is,
+							  __str._M_base());
+      __str._M_invalidate_all();
+      return __res;
+    }
+
+  typedef basic_string<char>    string;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef basic_string<wchar_t> wstring;
+#endif
+
+  template<typename _CharT, typename _Traits, typename _Allocator>
+    struct _Insert_range_from_self_is_safe<
+      __gnu_debug::basic_string<_CharT, _Traits, _Allocator> >
+      { enum { __value = 1 }; };
+
+} // namespace __gnu_debug
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/unordered_map b/gcc-4.9/libstdc++-v3/include/debug/unordered_map
new file mode 100644
index 0000000..626beba
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/unordered_map
@@ -0,0 +1,955 @@
+// Debugging unordered_map/unordered_multimap implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/unordered_map
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_UNORDERED_MAP
+#define _GLIBCXX_DEBUG_UNORDERED_MAP 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+# include <unordered_map>
+
+#include <debug/safe_unordered_container.h>
+#include <debug/safe_iterator.h>
+#include <debug/safe_local_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::unordered_map with safety/checking/debug instrumentation.
+  template<typename _Key, typename _Tp,
+	   typename _Hash = std::hash<_Key>,
+	   typename _Pred = std::equal_to<_Key>,
+	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_map
+    : public _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
+      public __gnu_debug::_Safe_unordered_container<unordered_map<_Key, _Tp,
+							_Hash, _Pred, _Alloc> >
+    {
+      typedef _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash,
+					    _Pred, _Alloc> _Base;
+      typedef __gnu_debug::_Safe_unordered_container<unordered_map> _Safe_base;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef typename _Base::const_local_iterator _Base_const_local_iterator;
+      typedef typename _Base::local_iterator _Base_local_iterator;
+
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator,
+					  unordered_map> iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
+					  unordered_map> const_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<_Base_local_iterator,
+					  unordered_map> local_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<_Base_const_local_iterator,
+					  unordered_map> const_local_iterator;
+
+      explicit
+      unordered_map(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a) { }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __first, _InputIterator __last, 
+		      size_type __n = 0,
+		      const hasher& __hf = hasher(), 
+		      const key_equal& __eql = key_equal(), 
+		      const allocator_type& __a = allocator_type())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __n,
+		__hf, __eql, __a) { }
+
+      unordered_map(const unordered_map&) = default;
+
+      unordered_map(const _Base& __x)
+      : _Base(__x) { }
+
+      unordered_map(unordered_map&&) = default;
+
+      explicit
+      unordered_map(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_map(const unordered_map& __umap,
+		    const allocator_type& __a)
+	: _Base(__umap._M_base(), __a)
+      { }
+
+      unordered_map(unordered_map&& __umap,
+		    const allocator_type& __a)
+	: _Base(std::move(__umap._M_base()), __a)
+      { }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n = 0,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__l, __n, __hf, __eql, __a) { }
+
+      ~unordered_map() noexcept { }
+
+      unordered_map&
+      operator=(const unordered_map& __x)
+      {
+	_M_base() = __x._M_base();
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      unordered_map&
+      operator=(unordered_map&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());	
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      unordered_map&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      void
+      swap(unordered_map& __x)
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+      {
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+	_Base::swap(__x);
+	_Safe_base::_M_swap(__x);
+      }
+
+      void
+      clear() noexcept
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+      }
+
+      iterator 
+      begin() noexcept
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() noexcept
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      // local versions
+      local_iterator
+      begin(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::begin(__b), this);
+      }
+
+      local_iterator
+      end(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      begin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::begin(__b), this);
+      }
+
+      const_local_iterator
+      end(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      cbegin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cbegin(__b), this);
+      }
+
+      const_local_iterator
+      cend(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cend(__b), this);
+      }
+
+      size_type
+      bucket_size(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return _Base::bucket_size(__b);
+      }
+
+      float
+      max_load_factor() const noexcept
+      { return _Base::max_load_factor(); }
+
+      void
+      max_load_factor(float __f)
+      {
+	__glibcxx_check_max_load_factor(__f);
+	_Base::max_load_factor(__f);
+      }
+
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  size_type __bucket_count = this->bucket_count();
+	  std::pair<_Base_iterator, bool> __res
+	    = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return std::make_pair(iterator(__res.first, this), __res.second);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __hint, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__hint);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it = _Base::emplace_hint(__hint.base(),
+					std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      std::pair<iterator, bool>
+      insert(const value_type& __obj)
+      {
+	size_type __bucket_count = this->bucket_count();
+	std::pair<_Base_iterator, bool> __res = _Base::insert(__obj);
+	_M_check_rehashed(__bucket_count);
+	return std::make_pair(iterator(__res.first, this), __res.second);
+      }
+
+      iterator
+      insert(const_iterator __hint, const value_type& __obj)
+      {
+	__glibcxx_check_insert(__hint);
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__hint.base(), __obj); 
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	std::pair<iterator, bool>
+	insert(_Pair&& __obj)
+	{
+	  size_type __bucket_count = this->bucket_count();
+	  std::pair<_Base_iterator, bool> __res =
+	    _Base::insert(std::forward<_Pair>(__obj));
+	  _M_check_rehashed(__bucket_count);
+	  return std::make_pair(iterator(__res.first, this), __res.second);
+	}
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	iterator
+	insert(const_iterator __hint, _Pair&& __obj)
+	{
+	  __glibcxx_check_insert(__hint);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it =
+	    _Base::insert(__hint.base(), std::forward<_Pair>(__obj));
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      {
+	size_type __bucket_count = this->bucket_count();
+	_Base::insert(__l);
+	_M_check_rehashed(__bucket_count);
+      }
+
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{
+	  __glibcxx_check_valid_range(__first, __last);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  _M_check_rehashed(__bucket_count);
+	}
+
+      iterator
+      find(const key_type& __key)
+      { return iterator(_Base::find(__key), this); }
+
+      const_iterator
+      find(const key_type& __key) const
+      { return const_iterator(_Base::find(__key), this); }
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __key)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __res =
+	  _Base::equal_range(__key);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __key) const
+      {
+	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+	  _Base::equal_range(__key);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      size_type
+      erase(const key_type& __key)
+      {
+	size_type __ret(0);
+	_Base_iterator __victim(_Base::find(__key));
+	if (__victim != _Base::end())
+	  {
+	    this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+			    { return __it == __victim; });
+	    this->_M_invalidate_local_if(
+			    [__victim](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __victim._M_cur; });
+	    size_type __bucket_count = this->bucket_count();
+	    _Base::erase(__victim);
+	    _M_check_rehashed(__bucket_count);
+	    __ret = 1;
+	  }
+	return __ret;
+      }
+
+      iterator
+      erase(const_iterator __it)
+      {
+	__glibcxx_check_erase(__it);
+	_Base_const_iterator __victim = __it.base();
+	this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+			{ return __it == __victim; });
+	this->_M_invalidate_local_if(
+			[__victim](_Base_const_local_iterator __it)
+			{ return __it._M_curr() == __victim._M_cur; });
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __next = _Base::erase(__it.base()); 
+	_M_check_rehashed(__bucket_count);
+	return iterator(__next, this);
+      }
+
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __tmp = __first.base();
+	     __tmp != __last.base(); ++__tmp)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if([__tmp](_Base_const_iterator __it)
+			    { return __it == __tmp; });
+	    this->_M_invalidate_local_if(
+			    [__tmp](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __tmp._M_cur; });
+	  }
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __next = _Base::erase(__first.base(), __last.base());
+	_M_check_rehashed(__bucket_count);
+	return iterator(__next, this);
+      }
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    private:
+      void
+      _M_invalidate_locals()
+      {
+	_Base_local_iterator __local_end = _Base::end(0);
+	this->_M_invalidate_local_if(
+			[__local_end](_Base_const_local_iterator __it)
+			{ return __it != __local_end; });
+      }
+
+      void
+      _M_invalidate_all()
+      {
+	_Base_iterator __end = _Base::end();
+	this->_M_invalidate_if([__end](_Base_const_iterator __it)
+			{ return __it != __end; });
+	_M_invalidate_locals();
+      }
+
+      void
+      _M_check_rehashed(size_type __prev_count)
+      {
+	if (__prev_count != this->bucket_count())
+	  _M_invalidate_locals();
+      }
+    };
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_base() == __y._M_base(); }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  /// Class std::unordered_multimap with safety/checking/debug instrumentation.
+  template<typename _Key, typename _Tp,
+	   typename _Hash = std::hash<_Key>,
+	   typename _Pred = std::equal_to<_Key>,
+	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_multimap
+    : public _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
+						_Pred, _Alloc>,
+      public __gnu_debug::_Safe_unordered_container<unordered_multimap<_Key,
+						_Tp, _Hash, _Pred, _Alloc> >
+    {
+      typedef _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
+						 _Pred, _Alloc> _Base;
+      typedef __gnu_debug::_Safe_unordered_container<unordered_multimap>
+	_Safe_base;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef typename _Base::const_local_iterator _Base_const_local_iterator;
+      typedef typename _Base::local_iterator _Base_local_iterator;
+
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator,
+					  unordered_multimap> iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
+					  unordered_multimap> const_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<
+	_Base_local_iterator, unordered_multimap> local_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<
+	_Base_const_local_iterator, unordered_multimap> const_local_iterator;
+
+      explicit
+      unordered_multimap(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a) { }
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __first, _InputIterator __last, 
+			   size_type __n = 0,
+			   const hasher& __hf = hasher(), 
+			   const key_equal& __eql = key_equal(), 
+			   const allocator_type& __a = allocator_type())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __n,
+		__hf, __eql, __a) { }
+
+      unordered_multimap(const unordered_multimap&) = default;
+
+      unordered_multimap(const _Base& __x) 
+      : _Base(__x) { }
+
+      unordered_multimap(unordered_multimap&&) = default;
+
+      explicit
+      unordered_multimap(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_multimap(const unordered_multimap& __umap,
+			 const allocator_type& __a)
+	: _Base(__umap._M_base(), __a)
+      { }
+
+      unordered_multimap(unordered_multimap&& __umap,
+			 const allocator_type& __a)
+	: _Base(std::move(__umap._M_base()), __a)
+      { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n = 0,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__l, __n, __hf, __eql, __a) { }
+
+      ~unordered_multimap() noexcept { }
+
+      unordered_multimap&
+      operator=(const unordered_multimap& __x)
+      {
+	_M_base() = __x._M_base();
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      unordered_multimap&
+      operator=(unordered_multimap&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      unordered_multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      void
+      swap(unordered_multimap& __x)
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+      {
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+	_Base::swap(__x);
+	_Safe_base::_M_swap(__x);
+      }
+
+      void
+      clear() noexcept
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+      }
+
+      iterator 
+      begin() noexcept
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() noexcept
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      // local versions
+      local_iterator
+      begin(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::begin(__b), this);
+      }
+
+      local_iterator
+      end(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      begin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::begin(__b), this);
+      }
+
+      const_local_iterator
+      end(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      cbegin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cbegin(__b), this);
+      }
+
+      const_local_iterator
+      cend(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cend(__b), this);
+      }
+
+      size_type
+      bucket_size(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return _Base::bucket_size(__b);
+      }
+
+      float
+      max_load_factor() const noexcept
+      { return _Base::max_load_factor(); }
+
+      void
+      max_load_factor(float __f)
+      {
+	__glibcxx_check_max_load_factor(__f);
+	_Base::max_load_factor(__f);
+      }
+
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it
+	    = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __hint, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__hint);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it = _Base::emplace_hint(__hint.base(),
+					std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      iterator
+      insert(const value_type& __obj)
+      {
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__obj);
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      iterator
+      insert(const_iterator __hint, const value_type& __obj)
+      {
+	__glibcxx_check_insert(__hint);
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__hint.base(), __obj);
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	iterator
+	insert(_Pair&& __obj)
+	{
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it = _Base::insert(std::forward<_Pair>(__obj));
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+	iterator
+	insert(const_iterator __hint, _Pair&& __obj)
+	{
+	  __glibcxx_check_insert(__hint);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it =
+	    _Base::insert(__hint.base(), std::forward<_Pair>(__obj));
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      { _Base::insert(__l); }
+
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{
+	  __glibcxx_check_valid_range(__first, __last);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  _M_check_rehashed(__bucket_count);
+	}
+
+      iterator
+      find(const key_type& __key)
+      { return iterator(_Base::find(__key), this); }
+
+      const_iterator
+      find(const key_type& __key) const
+      { return const_iterator(_Base::find(__key), this); }
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __key)
+      {
+	std::pair<_Base_iterator, _Base_iterator> __res =
+	  _Base::equal_range(__key);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __key) const
+      {
+	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+	  _Base::equal_range(__key);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      size_type
+      erase(const key_type& __key)
+      {
+	size_type __ret(0);
+	size_type __bucket_count = this->bucket_count();
+	std::pair<_Base_iterator, _Base_iterator> __pair =
+	  _Base::equal_range(__key);
+	for (_Base_iterator __victim = __pair.first; __victim != __pair.second;)
+	  {
+	    this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+			    { return __it == __victim; });
+	    this->_M_invalidate_local_if(
+			    [__victim](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __victim._M_cur; });
+	    _Base::erase(__victim++);
+	    ++__ret;
+	  }
+	_M_check_rehashed(__bucket_count);
+	return __ret;
+      }
+
+      iterator
+      erase(const_iterator __it)
+      {
+	__glibcxx_check_erase(__it);
+	_Base_const_iterator __victim = __it.base();
+	this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+			{ return __it == __victim; });
+	this->_M_invalidate_local_if(
+			[__victim](_Base_const_local_iterator __it)
+			{ return __it._M_curr() == __victim._M_cur; });
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __next = _Base::erase(__it.base());
+	_M_check_rehashed(__bucket_count);
+	return iterator(__next, this);
+      }
+
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __tmp = __first.base();
+	     __tmp != __last.base(); ++__tmp)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if([__tmp](_Base_const_iterator __it)
+			    { return __it == __tmp; });
+	    this->_M_invalidate_local_if(
+			    [__tmp](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __tmp._M_cur; });
+	  }
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __next = _Base::erase(__first.base(), __last.base());
+	_M_check_rehashed(__bucket_count);
+	return iterator(__next, this);
+      }
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    private:
+      void
+      _M_invalidate_locals()
+      {
+	_Base_local_iterator __local_end = _Base::end(0);
+	this->_M_invalidate_local_if(
+			[__local_end](_Base_const_local_iterator __it)
+			{ return __it != __local_end; });
+      }
+
+      void
+      _M_invalidate_all()
+      {
+	_Base_iterator __end = _Base::end();
+	this->_M_invalidate_if([__end](_Base_const_iterator __it)
+			{ return __it != __end; });
+	_M_invalidate_locals();
+      }
+
+      void
+      _M_check_rehashed(size_type __prev_count)
+      {
+	if (__prev_count != this->bucket_count())
+	  _M_invalidate_locals();
+      }
+    };
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_base() == __y._M_base(); }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+} // namespace __debug
+} // namespace std
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/unordered_set b/gcc-4.9/libstdc++-v3/include/debug/unordered_set
new file mode 100644
index 0000000..a17efd0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/unordered_set
@@ -0,0 +1,936 @@
+// Debugging unordered_set/unordered_multiset implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/unordered_set
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_UNORDERED_SET
+#define _GLIBCXX_DEBUG_UNORDERED_SET 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+# include <unordered_set>
+
+#include <debug/safe_unordered_container.h>
+#include <debug/safe_iterator.h>
+#include <debug/safe_local_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::unordered_set with safety/checking/debug instrumentation.
+  template<typename _Value,
+	   typename _Hash = std::hash<_Value>,
+	   typename _Pred = std::equal_to<_Value>,
+	   typename _Alloc = std::allocator<_Value> >
+    class unordered_set
+    : public _GLIBCXX_STD_C::unordered_set<_Value, _Hash, _Pred, _Alloc>,
+      public __gnu_debug::_Safe_unordered_container<unordered_set<_Value, _Hash,
+						       _Pred, _Alloc> >
+    {
+      typedef _GLIBCXX_STD_C::unordered_set<_Value, _Hash,
+					    _Pred, _Alloc> _Base;
+      typedef __gnu_debug::_Safe_unordered_container<unordered_set> _Safe_base;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef typename _Base::const_local_iterator _Base_const_local_iterator;
+      typedef typename _Base::local_iterator _Base_local_iterator;
+
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator,
+					  unordered_set> iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
+					  unordered_set> const_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<_Base_local_iterator,
+					  unordered_set> local_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<_Base_const_local_iterator,
+					  unordered_set> const_local_iterator;
+
+      explicit
+      unordered_set(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a) { }
+
+      template<typename _InputIterator>
+        unordered_set(_InputIterator __first, _InputIterator __last, 
+		      size_type __n = 0,
+		      const hasher& __hf = hasher(), 
+		      const key_equal& __eql = key_equal(), 
+		      const allocator_type& __a = allocator_type())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __n,
+		__hf, __eql, __a) { }
+
+      unordered_set(const unordered_set&) = default;
+
+      unordered_set(const _Base& __x)
+	: _Base(__x) { }
+
+      unordered_set(unordered_set&&) = default;
+
+      explicit
+      unordered_set(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_set(const unordered_set& __uset,
+		    const allocator_type& __a)
+	: _Base(__uset._M_base(), __a)
+      { }
+
+      unordered_set(unordered_set&& __uset,
+		    const allocator_type& __a)
+	: _Base(std::move(__uset._M_base()), __a)
+      { }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n = 0,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__l, __n, __hf, __eql, __a) { }
+
+      ~unordered_set() noexcept { }
+
+      unordered_set&
+      operator=(const unordered_set& __x)
+      {
+	_M_base() = __x._M_base();
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      unordered_set&
+      operator=(unordered_set&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      unordered_set&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      void
+      swap(unordered_set& __x)
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+      {
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+	_Base::swap(__x);
+	_Safe_base::_M_swap(__x);
+      }
+
+      void
+      clear() noexcept
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+      }
+
+      iterator 
+      begin() noexcept
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() noexcept
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      // local versions
+      local_iterator
+      begin(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::begin(__b), this);
+      }
+
+      local_iterator
+      end(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      begin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::begin(__b), this);
+      }
+
+      const_local_iterator
+      end(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      cbegin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cbegin(__b), this);
+      }
+
+      const_local_iterator
+      cend(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cend(__b), this);
+      }
+
+      size_type
+      bucket_size(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return _Base::bucket_size(__b);
+      }
+
+      float
+      max_load_factor() const noexcept
+      { return _Base::max_load_factor(); }
+
+      void
+      max_load_factor(float __f)
+      {
+	__glibcxx_check_max_load_factor(__f);
+	_Base::max_load_factor(__f);
+      }
+
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  size_type __bucket_count = this->bucket_count();
+	  std::pair<_Base_iterator, bool> __res
+	    = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return std::make_pair(iterator(__res.first, this), __res.second);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __hint, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__hint);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it = _Base::emplace_hint(__hint.base(),
+					std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      std::pair<iterator, bool>
+      insert(const value_type& __obj)
+      {
+	size_type __bucket_count = this->bucket_count();
+	typedef std::pair<_Base_iterator, bool> __pair_type;
+	  __pair_type __res = _Base::insert(__obj);
+	_M_check_rehashed(__bucket_count);
+	return std::make_pair(iterator(__res.first, this), __res.second);
+      }
+
+      iterator
+      insert(const_iterator __hint, const value_type& __obj)
+      {
+	__glibcxx_check_insert(__hint);
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__hint.base(), __obj);
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      std::pair<iterator, bool>
+      insert(value_type&& __obj)
+      {
+	size_type __bucket_count = this->bucket_count();
+	typedef std::pair<typename _Base::iterator, bool> __pair_type;
+	  __pair_type __res = _Base::insert(std::move(__obj));
+	_M_check_rehashed(__bucket_count);
+	return std::make_pair(iterator(__res.first, this), __res.second);
+      }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __obj)
+      {
+	__glibcxx_check_insert(__hint);
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__hint.base(), std::move(__obj));
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      {
+	size_type __bucket_count = this->bucket_count();
+	_Base::insert(__l);
+	_M_check_rehashed(__bucket_count);
+      }
+
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{
+	  __glibcxx_check_valid_range(__first, __last);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  _M_check_rehashed(__bucket_count);
+	}
+
+      iterator
+      find(const key_type& __key)
+      { return iterator(_Base::find(__key), this); }
+
+      const_iterator
+      find(const key_type& __key) const
+      { return const_iterator(_Base::find(__key), this); }
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __key)
+      {
+	typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
+	__pair_type __res = _Base::equal_range(__key);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __key) const
+      {
+	std::pair<_Base_const_iterator, _Base_const_iterator>
+	  __res = _Base::equal_range(__key);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      size_type
+      erase(const key_type& __key)
+      {
+	size_type __ret(0);
+	_Base_iterator __victim(_Base::find(__key));
+	if (__victim != _Base::end())
+	  {
+	    this->_M_invalidate_if(
+			    [__victim](_Base_const_iterator __it)
+			    { return __it == __victim; });
+	    this->_M_invalidate_local_if(
+			    [__victim](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __victim._M_cur; });
+	    size_type __bucket_count = this->bucket_count();
+	    _Base::erase(__victim);
+	    _M_check_rehashed(__bucket_count);
+	    __ret = 1;
+	  }
+	return __ret;
+      }
+
+      iterator
+      erase(const_iterator __it)
+      {
+	__glibcxx_check_erase(__it);
+	_Base_const_iterator __victim = __it.base();
+	this->_M_invalidate_if(
+			[__victim](_Base_const_iterator __it)
+			{ return __it == __victim; });
+	this->_M_invalidate_local_if(
+			[__victim](_Base_const_local_iterator __it)
+			{ return __it._M_curr() == __victim._M_cur; });
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __next = _Base::erase(__it.base());
+	_M_check_rehashed(__bucket_count);
+	return iterator(__next, this);
+      }
+
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __tmp = __first.base();
+	     __tmp != __last.base(); ++__tmp)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if(
+			    [__tmp](_Base_const_iterator __it)
+			    { return __it == __tmp; });
+	    this->_M_invalidate_local_if(
+			    [__tmp](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __tmp._M_cur; });
+	  }
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __next = _Base::erase(__first.base(),
+					     __last.base());
+	_M_check_rehashed(__bucket_count);
+	return iterator(__next, this);
+      }
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    private:
+      void
+      _M_invalidate_locals()
+      {
+	_Base_local_iterator __local_end = _Base::end(0);
+	this->_M_invalidate_local_if(
+			[__local_end](_Base_const_local_iterator __it)
+			{ return __it != __local_end; });
+      }
+
+      void
+      _M_invalidate_all()
+      {
+	_Base_iterator __end = _Base::end();
+	this->_M_invalidate_if(
+			[__end](_Base_const_iterator __it)
+			{ return __it != __end; });
+	_M_invalidate_locals();
+      }
+
+      void
+      _M_check_rehashed(size_type __prev_count)
+      {
+	if (__prev_count != this->bucket_count())
+	  _M_invalidate_locals();
+      }
+    };
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+	 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_base() == __y._M_base(); }
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  /// Class std::unordered_multiset with safety/checking/debug instrumentation.
+  template<typename _Value,
+	   typename _Hash = std::hash<_Value>,
+	   typename _Pred = std::equal_to<_Value>,
+	   typename _Alloc = std::allocator<_Value> >
+    class unordered_multiset
+    : public _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash, _Pred, _Alloc>,
+      public __gnu_debug::_Safe_unordered_container<
+		unordered_multiset<_Value, _Hash, _Pred, _Alloc> >
+    {
+      typedef _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash,
+						 _Pred, _Alloc> _Base;
+      typedef __gnu_debug::_Safe_unordered_container<unordered_multiset>
+		_Safe_base;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef typename _Base::iterator _Base_iterator;
+      typedef typename _Base::const_local_iterator _Base_const_local_iterator;
+      typedef typename _Base::local_iterator _Base_local_iterator;
+
+      typedef __gnu_cxx::__alloc_traits<typename
+					_Base::allocator_type> _Alloc_traits;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator,
+					  unordered_multiset> iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
+					  unordered_multiset> const_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<
+	_Base_local_iterator, unordered_multiset> local_iterator;
+      typedef __gnu_debug::_Safe_local_iterator<
+	_Base_const_local_iterator, unordered_multiset> const_local_iterator;
+
+      explicit
+      unordered_multiset(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a) { }
+
+      template<typename _InputIterator>
+        unordered_multiset(_InputIterator __first, _InputIterator __last, 
+			   size_type __n = 0,
+			   const hasher& __hf = hasher(), 
+			   const key_equal& __eql = key_equal(), 
+			   const allocator_type& __a = allocator_type())
+	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __n,
+		__hf, __eql, __a) { }
+
+      unordered_multiset(const unordered_multiset&) = default;
+
+      unordered_multiset(const _Base& __x) 
+      : _Base(__x) { }
+
+      unordered_multiset(unordered_multiset&&) = default;
+
+      explicit
+      unordered_multiset(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_multiset(const unordered_multiset& __uset,
+			 const allocator_type& __a)
+	: _Base(__uset._M_base(), __a)
+      { }
+      
+      unordered_multiset(unordered_multiset&& __uset,
+			 const allocator_type& __a)
+	: _Base(std::move(__uset._M_base()), __a)
+      { }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n = 0,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__l, __n, __hf, __eql, __a) { }
+
+      ~unordered_multiset() noexcept { }
+
+      unordered_multiset&
+      operator=(const unordered_multiset& __x)
+      {
+	_M_base() = __x._M_base();
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      unordered_multiset&
+      operator=(unordered_multiset&& __x)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	__x._M_invalidate_all();
+	return *this;
+      }
+
+      unordered_multiset&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	return *this;
+      }
+
+      void
+      swap(unordered_multiset& __x)
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+      {
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+	_Base::swap(__x);
+	_Safe_base::_M_swap(__x);
+      }
+
+      void
+      clear() noexcept
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+      }
+
+      iterator
+      begin() noexcept
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() noexcept
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      // local versions
+      local_iterator
+      begin(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::begin(__b), this);
+      }
+
+      local_iterator
+      end(size_type __b)
+      {
+	__glibcxx_check_bucket_index(__b);
+	return local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      begin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::begin(__b), this);
+      }
+
+      const_local_iterator
+      end(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::end(__b), this);
+      }
+
+      const_local_iterator
+      cbegin(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cbegin(__b), this);
+      }
+
+      const_local_iterator
+      cend(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return const_local_iterator(_Base::cend(__b), this);
+      }
+
+      size_type
+      bucket_size(size_type __b) const
+      {
+	__glibcxx_check_bucket_index(__b);
+	return _Base::bucket_size(__b);
+      }
+
+      float
+      max_load_factor() const noexcept
+      { return _Base::max_load_factor(); }
+
+      void
+      max_load_factor(float __f)
+      {
+	__glibcxx_check_max_load_factor(__f);
+	_Base::max_load_factor(__f);
+      }
+
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it
+	    = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __hint, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__hint);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base_iterator __it = _Base::emplace_hint(__hint.base(),
+					std::forward<_Args>(__args)...);
+	  _M_check_rehashed(__bucket_count);
+	  return iterator(__it, this);
+	}
+
+      iterator
+      insert(const value_type& __obj)
+      {
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__obj);
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      iterator
+      insert(const_iterator __hint, const value_type& __obj)
+      {
+	__glibcxx_check_insert(__hint);
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__hint.base(), __obj); 
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      iterator
+      insert(value_type&& __obj)
+      {
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(std::move(__obj)); 
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __obj)
+      {
+	__glibcxx_check_insert(__hint);
+	size_type __bucket_count = this->bucket_count();
+	_Base_iterator __it = _Base::insert(__hint.base(), std::move(__obj)); 
+	_M_check_rehashed(__bucket_count);
+	return iterator(__it, this);
+      }
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      {
+	size_type __bucket_count = this->bucket_count();
+	_Base::insert(__l);
+	_M_check_rehashed(__bucket_count);
+      }
+
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last)
+	{
+	  __glibcxx_check_valid_range(__first, __last);
+	  size_type __bucket_count = this->bucket_count();
+	  _Base::insert(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  _M_check_rehashed(__bucket_count);
+	}
+
+      iterator
+      find(const key_type& __key)
+      { return iterator(_Base::find(__key), this); }
+
+      const_iterator
+      find(const key_type& __key) const
+      { return const_iterator(_Base::find(__key), this); }
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __key)
+      {
+	typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
+	__pair_type __res = _Base::equal_range(__key);
+	return std::make_pair(iterator(__res.first, this),
+			      iterator(__res.second, this));
+      }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __key) const
+      {
+	std::pair<_Base_const_iterator, _Base_const_iterator>
+	  __res = _Base::equal_range(__key);
+	return std::make_pair(const_iterator(__res.first, this),
+			      const_iterator(__res.second, this));
+      }
+
+      size_type
+      erase(const key_type& __key)
+      {
+	size_type __ret(0);
+	std::pair<_Base_iterator, _Base_iterator> __pair =
+	  _Base::equal_range(__key);
+	for (_Base_iterator __victim = __pair.first; __victim != __pair.second;)
+	  {
+	    this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+			    { return __it == __victim; });
+	    this->_M_invalidate_local_if(
+			    [__victim](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __victim._M_cur; });
+	    _Base::erase(__victim++);
+	    ++__ret;
+	  }
+	return __ret;
+      }
+
+      iterator
+      erase(const_iterator __it)
+      {
+	__glibcxx_check_erase(__it);
+	_Base_const_iterator __victim = __it.base();
+	this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+			{ return __it == __victim; });
+	this->_M_invalidate_local_if(
+			[__victim](_Base_const_local_iterator __it)
+			{ return __it._M_curr() == __victim._M_cur; });
+	return iterator(_Base::erase(__it.base()), this);
+      }
+
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+	__glibcxx_check_erase_range(__first, __last);
+	for (_Base_const_iterator __tmp = __first.base();
+	     __tmp != __last.base(); ++__tmp)
+	  {
+	    _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+				  _M_message(__gnu_debug::__msg_valid_range)
+				  ._M_iterator(__first, "first")
+				  ._M_iterator(__last, "last"));
+	    this->_M_invalidate_if([__tmp](_Base_const_iterator __it)
+			    { return __it == __tmp; });
+	    this->_M_invalidate_local_if(
+			    [__tmp](_Base_const_local_iterator __it)
+			    { return __it._M_curr() == __tmp._M_cur; });
+	  }
+	return iterator(_Base::erase(__first.base(),
+				     __last.base()), this);
+      }
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    private:
+      void
+      _M_invalidate_locals()
+      {
+	_Base_local_iterator __local_end = _Base::end(0);
+	this->_M_invalidate_local_if(
+			[__local_end](_Base_const_local_iterator __it)
+			{ return __it != __local_end; });
+      }
+
+      void
+      _M_invalidate_all()
+      {
+	_Base_iterator __end = _Base::end();
+	this->_M_invalidate_if([__end](_Base_const_iterator __it)
+			{ return __it != __end; });
+	_M_invalidate_locals();
+      }
+
+      void
+      _M_check_rehashed(size_type __prev_count)
+      {
+	if (__prev_count != this->bucket_count())
+	  _M_invalidate_locals();
+      }
+    };
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_base() == __y._M_base(); }
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+} // namespace __debug
+} // namespace std
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/debug/vector b/gcc-4.9/libstdc++-v3/include/debug/vector
new file mode 100644
index 0000000..2e9cd65
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/debug/vector
@@ -0,0 +1,734 @@
+// Debugging vector implementation -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file debug/vector
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_VECTOR
+#define _GLIBCXX_DEBUG_VECTOR 1
+
+#include <vector>
+#include <utility>
+#include <debug/safe_sequence.h>
+#include <debug/safe_iterator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __debug
+{
+  /// Class std::vector with safety/checking/debug instrumentation.
+  template<typename _Tp,
+	   typename _Allocator = std::allocator<_Tp> >
+    class vector
+    : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
+      public __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> >
+    {
+      typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
+
+      typedef typename _Base::iterator _Base_iterator;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> > _Safe_base;
+      typedef __gnu_cxx::__alloc_traits<_Allocator>  _Alloc_traits;
+#endif
+
+    public:
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __gnu_debug::_Safe_iterator<_Base_iterator,vector>
+      iterator;
+      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,vector>
+      const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+
+      typedef _Tp				    value_type;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      // 23.2.4.1 construct/copy/destroy:
+
+      vector() _GLIBCXX_NOEXCEPT
+      : _Base(), _M_guaranteed_capacity(0) { }
+
+      explicit
+      vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT
+      : _Base(__a), _M_guaranteed_capacity(0) { }
+
+#if __cplusplus >= 201103L
+      explicit
+      vector(size_type __n, const _Allocator& __a = _Allocator())
+      : _Base(__n, __a), _M_guaranteed_capacity(__n) { }
+
+      vector(size_type __n, const _Tp& __value,
+	     const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { }
+#else
+      explicit
+      vector(size_type __n, const _Tp& __value = _Tp(),
+	     const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        vector(_InputIterator __first, _InputIterator __last,
+	       const _Allocator& __a = _Allocator())
+        : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
+								     __last)),
+		__gnu_debug::__base(__last), __a),
+	  _M_guaranteed_capacity(0)
+        { _M_update_guaranteed_capacity(); }
+
+      vector(const vector& __x)
+      : _Base(__x), _M_guaranteed_capacity(__x.size()) { }
+
+      /// Construction from a normal-mode vector
+      vector(const _Base& __x)
+      : _Base(__x), _M_guaranteed_capacity(__x.size()) { }
+
+#if __cplusplus >= 201103L
+      vector(vector&& __x) noexcept
+      : _Base(std::move(__x)),
+	_Safe_base(std::move(__x)),
+	_M_guaranteed_capacity(this->size())
+      { __x._M_guaranteed_capacity = 0; }
+
+      vector(const vector& __x, const allocator_type& __a)
+      : _Base(__x, __a), _M_guaranteed_capacity(__x.size()) { }
+
+      vector(vector&& __x, const allocator_type& __a)
+      : _Base(std::move(__x), __a),
+        _M_guaranteed_capacity(this->size())
+      {
+	if (__x.get_allocator() == __a)
+	  this->_M_swap(__x);
+	else
+	  __x._M_invalidate_all();
+	__x._M_guaranteed_capacity = 0;
+      }
+
+      vector(initializer_list<value_type> __l,
+	     const allocator_type& __a = allocator_type())
+      : _Base(__l, __a),
+	_M_guaranteed_capacity(__l.size()) { }
+#endif
+
+      ~vector() _GLIBCXX_NOEXCEPT { }
+
+      vector&
+      operator=(const vector& __x)
+      {
+	_M_base() = __x;
+	this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      vector&
+      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__glibcxx_check_self_move_assign(__x);
+	bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (__xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+	__x._M_invalidate_all();
+	__x._M_guaranteed_capacity = 0;
+	return *this;
+      }
+
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+	return *this;
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_valid_range(__first, __last);
+	  _Base::assign(__gnu_debug::__base(__first),
+			__gnu_debug::__base(__last));
+	  this->_M_invalidate_all();
+	  _M_update_guaranteed_capacity();
+	}
+
+      void
+      assign(size_type __n, const _Tp& __u)
+      {
+	_Base::assign(__n, __u);
+	this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+      }
+
+#if __cplusplus >= 201103L
+      void
+      assign(initializer_list<value_type> __l)
+      {
+	_Base::assign(__l);
+	this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // 23.2.4.2 capacity:
+      using _Base::size;
+      using _Base::max_size;
+
+#if __cplusplus >= 201103L
+      void
+      resize(size_type __sz)
+      {
+	bool __realloc = _M_requires_reallocation(__sz);
+	if (__sz < this->size())
+	  this->_M_invalidate_after_nth(__sz);
+	_Base::resize(__sz);
+	if (__realloc)
+	  this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+      }
+
+      void
+      resize(size_type __sz, const _Tp& __c)
+      {
+	bool __realloc = _M_requires_reallocation(__sz);
+	if (__sz < this->size())
+	  this->_M_invalidate_after_nth(__sz);
+	_Base::resize(__sz, __c);
+	if (__realloc)
+	  this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+      }
+#else
+      void
+      resize(size_type __sz, _Tp __c = _Tp())
+      {
+	bool __realloc = _M_requires_reallocation(__sz);
+	if (__sz < this->size())
+	  this->_M_invalidate_after_nth(__sz);
+	_Base::resize(__sz, __c);
+	if (__realloc)
+	  this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      void
+      shrink_to_fit()
+      {
+	if (_Base::_M_shrink_to_fit())
+	  {
+	    _M_guaranteed_capacity = _Base::capacity();
+	    this->_M_invalidate_all();
+	  }
+      }
+#endif
+
+      size_type
+      capacity() const _GLIBCXX_NOEXCEPT
+      {
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+	return _M_guaranteed_capacity;
+#else
+	return _Base::capacity();
+#endif
+      }
+
+      using _Base::empty;
+
+      void
+      reserve(size_type __n)
+      {
+	bool __realloc = _M_requires_reallocation(__n);
+	_Base::reserve(__n);
+	if (__n > _M_guaranteed_capacity)
+	  _M_guaranteed_capacity = __n;
+	if (__realloc)
+	  this->_M_invalidate_all();
+      }
+
+      // element access:
+      reference
+      operator[](size_type __n) _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_subscript(__n);
+	return _M_base()[__n];
+      }
+
+      const_reference
+      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_subscript(__n);
+	return _M_base()[__n];
+      }
+
+      using _Base::at;
+
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::front();
+      }
+
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::back();
+      }
+
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	return _Base::back();
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 464. Suggestion for new member functions in standard containers.
+      using _Base::data;
+
+      // 23.2.4.3 modifiers:
+      void
+      push_back(const _Tp& __x)
+      {
+	bool __realloc = _M_requires_reallocation(this->size() + 1);
+	_Base::push_back(__x);
+	if (__realloc)
+	  this->_M_invalidate_all();
+	_M_update_guaranteed_capacity();
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Up = _Tp>
+        typename __gnu_cxx::__enable_if<!std::__are_same<_Up, bool>::__value,
+					void>::__type
+        push_back(_Tp&& __x)
+	{ emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args)
+	{
+	  bool __realloc = _M_requires_reallocation(this->size() + 1);
+	  _Base::emplace_back(std::forward<_Args>(__args)...);
+	  if (__realloc)
+	    this->_M_invalidate_all();
+	  _M_update_guaranteed_capacity();
+	}
+#endif
+
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      {
+	__glibcxx_check_nonempty();
+	this->_M_invalidate_if(_Equal(--_Base::end()));
+	_Base::pop_back();
+      }
+
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args)
+	{
+	  __glibcxx_check_insert(__position);
+	  bool __realloc = _M_requires_reallocation(this->size() + 1);
+	  difference_type __offset = __position.base() - _Base::begin();
+	  _Base_iterator __res = _Base::emplace(__position.base(),
+						std::forward<_Args>(__args)...);
+	  if (__realloc)
+	    this->_M_invalidate_all();
+	  else
+	    this->_M_invalidate_after_nth(__offset);
+	  _M_update_guaranteed_capacity();
+	  return iterator(__res, this);
+	}
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const _Tp& __x)
+#else
+      insert(iterator __position, const _Tp& __x)
+#endif
+      {
+	__glibcxx_check_insert(__position);
+	bool __realloc = _M_requires_reallocation(this->size() + 1);
+	difference_type __offset = __position.base() - _Base::begin();
+	_Base_iterator __res = _Base::insert(__position.base(), __x);
+	if (__realloc)
+	  this->_M_invalidate_all();
+	else
+	  this->_M_invalidate_after_nth(__offset);
+	_M_update_guaranteed_capacity();
+	return iterator(__res, this);
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Up = _Tp>
+        typename __gnu_cxx::__enable_if<!std::__are_same<_Up, bool>::__value,
+					iterator>::__type
+        insert(const_iterator __position, _Tp&& __x)
+        { return emplace(__position, std::move(__x)); }
+
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      { return this->insert(__position, __l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, size_type __n, const _Tp& __x)
+      {
+	__glibcxx_check_insert(__position);
+	bool __realloc = _M_requires_reallocation(this->size() + __n);
+	difference_type __offset = __position.base() - _Base::cbegin();
+	_Base_iterator __res = _Base::insert(__position.base(), __n, __x);
+	if (__realloc)
+	  this->_M_invalidate_all();
+	else
+	  this->_M_invalidate_after_nth(__offset);
+	_M_update_guaranteed_capacity();
+	return iterator(__res, this);
+      }
+#else
+      void
+      insert(iterator __position, size_type __n, const _Tp& __x)
+      {
+	__glibcxx_check_insert(__position);
+	bool __realloc = _M_requires_reallocation(this->size() + __n);
+	difference_type __offset = __position.base() - _Base::begin();
+	_Base::insert(__position.base(), __n, __x);
+	if (__realloc)
+	  this->_M_invalidate_all();
+	else
+	  this->_M_invalidate_after_nth(__offset);
+	_M_update_guaranteed_capacity();
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert(const_iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_insert_range(__position, __first, __last);
+
+	  /* Hard to guess if invalidation will occur, because __last
+	     - __first can't be calculated in all cases, so we just
+	     punt here by checking if it did occur. */
+	  _Base_iterator __old_begin = _M_base().begin();
+	  difference_type __offset = __position.base() - _Base::cbegin();
+	  _Base_iterator __res = _Base::insert(__position.base(),
+					       __gnu_debug::__base(__first),
+					       __gnu_debug::__base(__last));
+
+	  if (_M_base().begin() != __old_begin)
+	    this->_M_invalidate_all();
+	  else
+	    this->_M_invalidate_after_nth(__offset);
+	  _M_update_guaranteed_capacity();
+	  return iterator(__res, this);
+	}
+#else
+      template<class _InputIterator>
+        void
+        insert(iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        {
+	  __glibcxx_check_insert_range(__position, __first, __last);
+
+	  /* Hard to guess if invalidation will occur, because __last
+	     - __first can't be calculated in all cases, so we just
+	     punt here by checking if it did occur. */
+	  _Base_iterator __old_begin = _M_base().begin();
+	  difference_type __offset = __position.base() - _Base::begin();
+	  _Base::insert(__position.base(), __gnu_debug::__base(__first),
+					   __gnu_debug::__base(__last));
+
+	  if (_M_base().begin() != __old_begin)
+	    this->_M_invalidate_all();
+	  else
+	    this->_M_invalidate_after_nth(__offset);
+	  _M_update_guaranteed_capacity();
+	}
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position)
+#else
+      erase(iterator __position)
+#endif
+      {
+	__glibcxx_check_erase(__position);
+	difference_type __offset = __position.base() - _Base::begin();
+	_Base_iterator __res = _Base::erase(__position.base());
+	this->_M_invalidate_after_nth(__offset);
+	return iterator(__res, this);
+      }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last)
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	__glibcxx_check_erase_range(__first, __last);
+
+	if (__first.base() != __last.base())
+	  {
+	    difference_type __offset = __first.base() - _Base::begin();
+	    _Base_iterator __res = _Base::erase(__first.base(),
+						__last.base());
+	    this->_M_invalidate_after_nth(__offset);
+	    return iterator(__res, this);
+	  }
+	else
+#if __cplusplus >= 201103L
+	  return iterator(__first.base()._M_const_cast(), this);
+#else
+	  return __first;
+#endif
+      }
+
+      void
+      swap(vector& __x)
+#if __cplusplus >= 201103L
+			noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      {
+#if __cplusplus >= 201103L
+	if (!_Alloc_traits::_S_propagate_on_swap())
+	  __glibcxx_check_equal_allocs(__x);
+#endif
+	_Base::swap(__x);
+	this->_M_swap(__x);
+        std::swap(_M_guaranteed_capacity, __x._M_guaranteed_capacity);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	_Base::clear();
+	this->_M_invalidate_all();
+        _M_guaranteed_capacity = 0;
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    private:
+      size_type _M_guaranteed_capacity;
+
+      bool
+      _M_requires_reallocation(size_type __elements) _GLIBCXX_NOEXCEPT
+      { return __elements > this->capacity(); }
+
+      void
+      _M_update_guaranteed_capacity() _GLIBCXX_NOEXCEPT
+      {
+	if (this->size() > _M_guaranteed_capacity)
+	  _M_guaranteed_capacity = this->size();
+      }
+
+      void
+      _M_invalidate_after_nth(difference_type __n) _GLIBCXX_NOEXCEPT
+      {
+	typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
+	this->_M_invalidate_if(_After_nth(__n, _Base::begin()));
+      }
+    };
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __lhs,
+	       const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __lhs,
+	       const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __lhs,
+	      const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __lhs,
+	       const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __lhs,
+	       const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __lhs,
+	      const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __debug
+
+#if __cplusplus >= 201103L
+  // DR 1182.
+  /// std::hash specialization for vector<bool>.
+  template<typename _Alloc>
+    struct hash<__debug::vector<bool, _Alloc>>
+    : public __hash_base<size_t, __debug::vector<bool, _Alloc>>
+    {
+      size_t
+      operator()(const __debug::vector<bool, _Alloc>& __b) const noexcept
+      { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()
+	  (__b._M_base()); }
+    };
+#endif
+
+} // namespace std
+
+namespace __gnu_debug
+{
+  template<typename _Tp, typename _Alloc>
+    struct _Is_contiguous_sequence<std::__debug::vector<_Tp, _Alloc> >
+    : std::__true_type
+    { };
+
+  template<typename _Alloc>
+    struct _Is_contiguous_sequence<std::__debug::vector<bool, _Alloc> >
+    : std::__false_type
+    { };
+}
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/decimal/decimal b/gcc-4.9/libstdc++-v3/include/decimal/decimal
new file mode 100644
index 0000000..d60790e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/decimal/decimal
@@ -0,0 +1,494 @@
+// <decimal> -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file decimal/decimal
+ *  This is a Standard C++ Library header.
+ */
+
+// ISO/IEC TR 24733 
+// Written by Janis Johnson <janis187@us.ibm.com>
+
+#ifndef _GLIBCXX_DECIMAL
+#define _GLIBCXX_DECIMAL 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#ifndef _GLIBCXX_USE_DECIMAL_FLOAT
+#error This file requires compiler and library support for ISO/IEC TR 24733 \
+that is currently not available.
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  /**
+    * @defgroup decimal Decimal Floating-Point Arithmetic
+    * @ingroup numerics
+    *
+    * Classes and functions for decimal floating-point arithmetic.
+    * @{
+    */
+
+  /** @namespace std::decimal
+    * @brief ISO/IEC TR 24733 Decimal floating-point arithmetic.
+    */
+namespace decimal
+{
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  class decimal32;
+  class decimal64;
+  class decimal128;
+
+  // 3.2.5  Initialization from coefficient and exponent.
+  static decimal32 make_decimal32(long long __coeff, int __exp);
+  static decimal32 make_decimal32(unsigned long long __coeff, int __exp);
+  static decimal64 make_decimal64(long long __coeff, int __exp);
+  static decimal64 make_decimal64(unsigned long long __coeff, int __exp);
+  static decimal128 make_decimal128(long long __coeff, int __exp);
+  static decimal128 make_decimal128(unsigned long long __coeff, int __exp);
+
+  /// Non-conforming extension: Conversion to integral type.
+  long long decimal32_to_long_long(decimal32 __d);
+  long long decimal64_to_long_long(decimal64 __d);
+  long long decimal128_to_long_long(decimal128 __d);
+  long long decimal_to_long_long(decimal32 __d);
+  long long decimal_to_long_long(decimal64 __d);
+  long long decimal_to_long_long(decimal128 __d);
+
+  // 3.2.6  Conversion to generic floating-point type.
+  float decimal32_to_float(decimal32 __d);
+  float decimal64_to_float(decimal64 __d);
+  float decimal128_to_float(decimal128 __d);
+  float decimal_to_float(decimal32 __d);
+  float decimal_to_float(decimal64 __d);
+  float decimal_to_float(decimal128 __d);
+
+  double decimal32_to_double(decimal32 __d);
+  double decimal64_to_double(decimal64 __d);
+  double decimal128_to_double(decimal128 __d);
+  double decimal_to_double(decimal32 __d);
+  double decimal_to_double(decimal64 __d);
+  double decimal_to_double(decimal128 __d);
+
+  long double decimal32_to_long_double(decimal32 __d);
+  long double decimal64_to_long_double(decimal64 __d);
+  long double decimal128_to_long_double(decimal128 __d);
+  long double decimal_to_long_double(decimal32 __d);
+  long double decimal_to_long_double(decimal64 __d);
+  long double decimal_to_long_double(decimal128 __d);
+
+  // 3.2.7  Unary arithmetic operators.
+  decimal32  operator+(decimal32 __rhs);
+  decimal64  operator+(decimal64 __rhs);
+  decimal128 operator+(decimal128 __rhs);
+  decimal32  operator-(decimal32 __rhs);
+  decimal64  operator-(decimal64 __rhs);
+  decimal128 operator-(decimal128 __rhs);
+
+  // 3.2.8  Binary arithmetic operators.
+#define _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(_Op, _T1, _T2, _T3)	\
+  _T1 operator _Op(_T2 __lhs, _T3 __rhs);
+#define _DECLARE_DECIMAL_BINARY_OP_WITH_INT(_Op, _Tp)		\
+  _Tp operator _Op(_Tp __lhs, int __rhs);			\
+  _Tp operator _Op(_Tp __lhs, unsigned int __rhs);		\
+  _Tp operator _Op(_Tp __lhs, long __rhs);			\
+  _Tp operator _Op(_Tp __lhs, unsigned long __rhs);		\
+  _Tp operator _Op(_Tp __lhs, long long __rhs);			\
+  _Tp operator _Op(_Tp __lhs, unsigned long long __rhs);	\
+  _Tp operator _Op(int __lhs, _Tp __rhs);			\
+  _Tp operator _Op(unsigned int __lhs, _Tp __rhs);		\
+  _Tp operator _Op(long __lhs, _Tp __rhs);			\
+  _Tp operator _Op(unsigned long __lhs, _Tp __rhs);		\
+  _Tp operator _Op(long long __lhs, _Tp __rhs);			\
+  _Tp operator _Op(unsigned long long __lhs, _Tp __rhs);
+
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal32, decimal32, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal32, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal32, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal64, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal128)
+
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal32, decimal32, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal32, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal32, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal64, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal128)
+
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal32, decimal32, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal32, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal32, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal64, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal128)
+
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal32, decimal32, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal32, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal32, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal64, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal32)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal64)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal128)
+  _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal128)
+
+#undef _DECLARE_DECIMAL_BINARY_OP_WITH_DEC
+#undef _DECLARE_DECIMAL_BINARY_OP_WITH_INT
+
+  // 3.2.9  Comparison operators.
+#define _DECLARE_DECIMAL_COMPARISON(_Op, _Tp)				\
+  bool operator _Op(_Tp __lhs, decimal32 __rhs);			\
+  bool operator _Op(_Tp __lhs, decimal64 __rhs);			\
+  bool operator _Op(_Tp __lhs, decimal128 __rhs);			\
+  bool operator _Op(_Tp __lhs, int __rhs);				\
+  bool operator _Op(_Tp __lhs, unsigned int __rhs);			\
+  bool operator _Op(_Tp __lhs, long __rhs);				\
+  bool operator _Op(_Tp __lhs, unsigned long __rhs);			\
+  bool operator _Op(_Tp __lhs, long long __rhs);			\
+  bool operator _Op(_Tp __lhs, unsigned long long __rhs);		\
+  bool operator _Op(int __lhs, _Tp __rhs);				\
+  bool operator _Op(unsigned int __lhs, _Tp __rhs);			\
+  bool operator _Op(long __lhs, _Tp __rhs);				\
+  bool operator _Op(unsigned long __lhs, _Tp __rhs);			\
+  bool operator _Op(long long __lhs, _Tp __rhs);			\
+  bool operator _Op(unsigned long long __lhs, _Tp __rhs);
+
+  _DECLARE_DECIMAL_COMPARISON(==, decimal32)
+  _DECLARE_DECIMAL_COMPARISON(==, decimal64)
+  _DECLARE_DECIMAL_COMPARISON(==, decimal128)
+
+  _DECLARE_DECIMAL_COMPARISON(!=, decimal32)
+  _DECLARE_DECIMAL_COMPARISON(!=, decimal64)
+  _DECLARE_DECIMAL_COMPARISON(!=, decimal128)
+
+  _DECLARE_DECIMAL_COMPARISON(<, decimal32)
+  _DECLARE_DECIMAL_COMPARISON(<, decimal64)
+  _DECLARE_DECIMAL_COMPARISON(<, decimal128)
+
+  _DECLARE_DECIMAL_COMPARISON(>=, decimal32)
+  _DECLARE_DECIMAL_COMPARISON(>=, decimal64)
+  _DECLARE_DECIMAL_COMPARISON(>=, decimal128)
+
+  _DECLARE_DECIMAL_COMPARISON(>, decimal32)
+  _DECLARE_DECIMAL_COMPARISON(>, decimal64)
+  _DECLARE_DECIMAL_COMPARISON(>, decimal128)
+
+  _DECLARE_DECIMAL_COMPARISON(>=, decimal32)
+  _DECLARE_DECIMAL_COMPARISON(>=, decimal64)
+  _DECLARE_DECIMAL_COMPARISON(>=, decimal128)
+
+#undef _DECLARE_DECIMAL_COMPARISON
+
+  /// 3.2.2  Class decimal32.
+  class decimal32
+  {
+  public:
+    typedef float __decfloat32 __attribute__((mode(SD)));
+
+    // 3.2.2.2  Construct/copy/destroy.
+    decimal32()					: __val(0.e-101DF) {}
+
+    // 3.2.2.3  Conversion from floating-point type.
+    explicit decimal32(decimal64 __d64);
+    explicit decimal32(decimal128 __d128);
+    explicit decimal32(float __r)		: __val(__r) {}
+    explicit decimal32(double __r)		: __val(__r) {}
+    explicit decimal32(long double __r)		: __val(__r) {}
+
+    // 3.2.2.4  Conversion from integral type.
+    decimal32(int __z)				: __val(__z) {}
+    decimal32(unsigned int __z)			: __val(__z) {}
+    decimal32(long __z)				: __val(__z) {}
+    decimal32(unsigned long __z)		: __val(__z) {}
+    decimal32(long long __z)			: __val(__z) {}
+    decimal32(unsigned long long __z)		: __val(__z) {}
+
+    /// Conforming extension: Conversion from scalar decimal type.
+    decimal32(__decfloat32 __z)			: __val(__z) {}
+
+#if __cplusplus >= 201103L
+    // 3.2.2.5  Conversion to integral type.
+    // Note: explicit per n3407.
+    explicit operator long long() const { return (long long)__val; }
+#endif
+
+    // 3.2.2.6  Increment and decrement operators.
+    decimal32& operator++()
+    {
+      __val += 1;
+      return *this;
+    }
+
+    decimal32 operator++(int)
+    {
+      decimal32 __tmp = *this;
+      __val += 1;
+      return __tmp;
+    }
+
+    decimal32& operator--()
+    {
+      __val -= 1;
+      return *this;
+    }
+
+    decimal32   operator--(int)
+    {
+      decimal32 __tmp = *this;
+      __val -= 1;
+      return __tmp;
+    }
+
+    // 3.2.2.7  Compound assignment.
+#define _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(_Op)	\
+    decimal32& operator _Op(decimal32 __rhs);		\
+    decimal32& operator _Op(decimal64 __rhs);		\
+    decimal32& operator _Op(decimal128 __rhs);		\
+    decimal32& operator _Op(int __rhs);			\
+    decimal32& operator _Op(unsigned int __rhs);	\
+    decimal32& operator _Op(long __rhs);		\
+    decimal32& operator _Op(unsigned long __rhs);	\
+    decimal32& operator _Op(long long __rhs);		\
+    decimal32& operator _Op(unsigned long long __rhs);
+
+    _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(+=)
+    _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(-=)
+    _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(*=)
+    _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(/=)
+#undef _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT
+
+  private:
+    __decfloat32 __val;
+
+  public:
+    __decfloat32 __getval(void) { return __val; }
+    void __setval(__decfloat32 __x) { __val = __x; }
+  };
+
+  /// 3.2.3  Class decimal64.
+  class decimal64
+  {
+  public:
+    typedef float __decfloat64 __attribute__((mode(DD)));
+
+    // 3.2.3.2  Construct/copy/destroy.
+    decimal64()					: __val(0.e-398dd) {}
+
+    // 3.2.3.3  Conversion from floating-point type.
+	     decimal64(decimal32 d32);
+    explicit decimal64(decimal128 d128);
+    explicit decimal64(float __r)		: __val(__r) {}
+    explicit decimal64(double __r)		: __val(__r) {}
+    explicit decimal64(long double __r)		: __val(__r) {}
+
+    // 3.2.3.4  Conversion from integral type.
+    decimal64(int __z)				: __val(__z) {}
+    decimal64(unsigned int __z)			: __val(__z) {}
+    decimal64(long __z)				: __val(__z) {}
+    decimal64(unsigned long __z)		: __val(__z) {}
+    decimal64(long long __z)			: __val(__z) {}
+    decimal64(unsigned long long __z)		: __val(__z) {}
+
+    /// Conforming extension: Conversion from scalar decimal type.
+    decimal64(__decfloat64 __z)			: __val(__z) {}
+
+#if __cplusplus >= 201103L
+    // 3.2.3.5  Conversion to integral type.
+    // Note: explicit per n3407.
+    explicit operator long long() const { return (long long)__val; }
+#endif
+
+    // 3.2.3.6  Increment and decrement operators.
+    decimal64& operator++()
+    {
+      __val += 1;
+      return *this;
+    }
+
+    decimal64 operator++(int)
+    {
+      decimal64 __tmp = *this;
+      __val += 1;
+      return __tmp;
+    }
+
+    decimal64& operator--()
+    {
+      __val -= 1;
+      return *this;
+    }
+
+    decimal64 operator--(int)
+    {
+      decimal64 __tmp = *this;
+      __val -= 1;
+      return __tmp;
+    }
+
+    // 3.2.3.7  Compound assignment.
+#define _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(_Op)	\
+    decimal64& operator _Op(decimal32 __rhs);		\
+    decimal64& operator _Op(decimal64 __rhs);		\
+    decimal64& operator _Op(decimal128 __rhs);		\
+    decimal64& operator _Op(int __rhs);			\
+    decimal64& operator _Op(unsigned int __rhs);	\
+    decimal64& operator _Op(long __rhs);		\
+    decimal64& operator _Op(unsigned long __rhs);	\
+    decimal64& operator _Op(long long __rhs);		\
+    decimal64& operator _Op(unsigned long long __rhs);
+
+    _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(+=)
+    _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(-=)
+    _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(*=)
+    _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(/=)
+#undef _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT
+
+  private:
+    __decfloat64 __val;
+
+  public:
+    __decfloat64 __getval(void) { return __val; }
+    void __setval(__decfloat64 __x) { __val = __x; }
+  };
+
+  /// 3.2.4  Class decimal128.
+  class decimal128
+  {
+  public:
+    typedef float __decfloat128 __attribute__((mode(TD)));
+
+    // 3.2.4.2  Construct/copy/destroy.
+    decimal128()				: __val(0.e-6176DL) {}
+
+    // 3.2.4.3  Conversion from floating-point type.
+	     decimal128(decimal32 d32);
+	     decimal128(decimal64 d64);
+    explicit decimal128(float __r)		: __val(__r) {}
+    explicit decimal128(double __r)		: __val(__r) {}
+    explicit decimal128(long double __r)	: __val(__r) {}
+
+
+    // 3.2.4.4  Conversion from integral type.
+    decimal128(int __z)				: __val(__z) {}
+    decimal128(unsigned int __z)		: __val(__z) {}
+    decimal128(long __z)			: __val(__z) {}
+    decimal128(unsigned long __z)		: __val(__z) {}
+    decimal128(long long __z)			: __val(__z) {}
+    decimal128(unsigned long long __z)		: __val(__z) {}
+
+    /// Conforming extension: Conversion from scalar decimal type.
+    decimal128(__decfloat128 __z)		: __val(__z) {}
+
+#if __cplusplus >= 201103L
+    // 3.2.4.5  Conversion to integral type.
+    // Note: explicit per n3407.
+    explicit operator long long() const { return (long long)__val; }
+#endif
+
+    // 3.2.4.6  Increment and decrement operators.
+    decimal128& operator++()
+    {
+      __val += 1;
+      return *this;
+    }
+
+    decimal128 operator++(int)
+    {
+      decimal128 __tmp = *this;
+      __val += 1;
+      return __tmp;
+    }
+
+    decimal128& operator--()
+    {
+      __val -= 1;
+      return *this;
+    }
+
+    decimal128   operator--(int)
+    {
+      decimal128 __tmp = *this;
+      __val -= 1;
+      return __tmp;
+    }
+
+    // 3.2.4.7  Compound assignment.
+#define _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(_Op)	\
+    decimal128& operator _Op(decimal32 __rhs);		\
+    decimal128& operator _Op(decimal64 __rhs);		\
+    decimal128& operator _Op(decimal128 __rhs);		\
+    decimal128& operator _Op(int __rhs);		\
+    decimal128& operator _Op(unsigned int __rhs);	\
+    decimal128& operator _Op(long __rhs);		\
+    decimal128& operator _Op(unsigned long __rhs);	\
+    decimal128& operator _Op(long long __rhs);		\
+    decimal128& operator _Op(unsigned long long __rhs);
+
+    _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(+=)
+    _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(-=)
+    _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(*=)
+    _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(/=)
+#undef _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT
+
+  private:
+    __decfloat128 __val;
+
+  public:
+    __decfloat128 __getval(void) { return __val; }
+    void __setval(__decfloat128 __x) { __val = __x; }
+  };
+
+#define _GLIBCXX_USE_DECIMAL_ 1
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace decimal
+  // @} group decimal
+} // namespace std
+
+#include <decimal/decimal.h>
+
+#endif /* _GLIBCXX_DECIMAL */
diff --git a/gcc-4.9/libstdc++-v3/include/decimal/decimal.h b/gcc-4.9/libstdc++-v3/include/decimal/decimal.h
new file mode 100644
index 0000000..969962c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/decimal/decimal.h
@@ -0,0 +1,468 @@
+// decimal classes -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file decimal/decimal.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{decimal}
+ */
+
+// ISO/IEC TR 24733
+// Written by Janis Johnson <janis187@us.ibm.com>
+
+#ifndef _GLIBCXX_DECIMAL_IMPL
+#define _GLIBCXX_DECIMAL_IMPL 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace decimal
+{
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // ISO/IEC TR 24733  3.2.[234].1  Construct/copy/destroy.
+
+  inline decimal32::decimal32(decimal64 __r)	: __val(__r.__getval()) {}
+  inline decimal32::decimal32(decimal128 __r)	: __val(__r.__getval()) {}
+  inline decimal64::decimal64(decimal32 __r)	: __val(__r.__getval()) {}
+  inline decimal64::decimal64(decimal128 __r)	: __val(__r.__getval()) {}
+  inline decimal128::decimal128(decimal32 __r)	: __val(__r.__getval()) {}
+  inline decimal128::decimal128(decimal64 __r)	: __val(__r.__getval()) {}
+
+  // ISO/IEC TR 24733  3.2.[234].6  Compound assignment.
+
+#define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, _T2)	 \
+  inline _T1& _T1::operator _Op1(_T2 __rhs)				 \
+  {									 \
+    __setval(__getval() _Op2 __rhs.__getval());				 \
+    return *this;							 \
+  }
+
+#define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, _T2)	 \
+  inline _T1& _T1::operator _Op1(_T2 __rhs)				 \
+  {									 \
+    __setval(__getval() _Op2 __rhs);					 \
+    return *this;							 \
+  }
+
+#define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(_Op1, _Op2, _T1)		 \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, decimal32)	 \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, decimal64)	 \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, decimal128)	 \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, int)		 \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, unsigned int) \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, long)	 \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, unsigned long)\
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, long long)	 \
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, unsigned long long)
+
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal32)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal32)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal32)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal32)
+
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal64)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal64)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal64)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal64)
+
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal128)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal128)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal128)
+  _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal128)
+
+#undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC
+#undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT
+#undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS
+
+  // Extension: Conversion to integral type.
+
+  inline long long decimal32_to_long_long(decimal32 __d)
+  { return (long long)__d.__getval(); }
+
+  inline long long decimal64_to_long_long(decimal64 __d)
+  { return (long long)__d.__getval(); }
+
+  inline long long decimal128_to_long_long(decimal128 __d)
+  { return (long long)__d.__getval(); }
+
+  inline long long decimal_to_long_long(decimal32 __d)
+  { return (long long)__d.__getval(); }
+
+  inline long long decimal_to_long_long(decimal64 __d)
+  { return (long long)__d.__getval(); }
+
+  inline long long decimal_to_long_long(decimal128 __d)
+  { return (long long)__d.__getval(); }
+
+  // ISO/IEC TR 24733  3.2.5  Initialization from coefficient and exponent.
+
+  static decimal32 make_decimal32(long long __coeff, int __exponent)
+  {
+    decimal32 __decexp = 1, __multiplier;
+
+    if (__exponent < 0)
+      {
+	__multiplier = 1.E-1DF;
+	__exponent = -__exponent;
+      }
+    else
+      __multiplier = 1.E1DF;
+
+    for (int __i = 0; __i < __exponent; ++__i)
+      __decexp *= __multiplier;
+
+    return __coeff * __decexp;
+  }
+
+  static decimal32 make_decimal32(unsigned long long __coeff, int __exponent)
+  {
+    decimal32 __decexp = 1, __multiplier;
+
+    if (__exponent < 0)
+      {
+	__multiplier = 1.E-1DF;
+	__exponent = -__exponent;
+      }
+    else
+      __multiplier = 1.E1DF;
+
+    for (int __i = 0; __i < __exponent; ++__i)
+      __decexp *= __multiplier;
+
+    return __coeff * __decexp;
+  }
+
+  static decimal64 make_decimal64(long long __coeff, int __exponent)
+  {
+    decimal64 __decexp = 1, __multiplier;
+
+    if (__exponent < 0)
+      {
+	__multiplier = 1.E-1DD;
+	__exponent = -__exponent;
+      }
+    else
+      __multiplier = 1.E1DD;
+
+    for (int __i = 0; __i < __exponent; ++__i)
+      __decexp *= __multiplier;
+
+    return __coeff * __decexp;
+  }
+
+  static decimal64 make_decimal64(unsigned long long __coeff, int __exponent)
+  {
+    decimal64 __decexp = 1, __multiplier;
+
+    if (__exponent < 0)
+      {
+	__multiplier = 1.E-1DD;
+	__exponent = -__exponent;
+      }
+    else
+      __multiplier = 1.E1DD;
+
+    for (int __i = 0; __i < __exponent; ++__i)
+      __decexp *= __multiplier;
+
+    return __coeff * __decexp;
+  }
+
+  static decimal128 make_decimal128(long long __coeff, int __exponent)
+  {
+    decimal128 __decexp = 1, __multiplier;
+
+    if (__exponent < 0)
+      {
+	__multiplier = 1.E-1DL;
+	__exponent = -__exponent;
+      }
+    else
+      __multiplier = 1.E1DL;
+
+    for (int __i = 0; __i < __exponent; ++__i)
+      __decexp *= __multiplier;
+
+    return __coeff * __decexp;
+  }
+
+  static decimal128 make_decimal128(unsigned long long __coeff, int __exponent)
+  {
+    decimal128 __decexp = 1, __multiplier;
+
+    if (__exponent < 0)
+      {
+	__multiplier = 1.E-1DL;
+	__exponent = -__exponent;
+      }
+    else
+      __multiplier = 1.E1DL;
+
+    for (int __i = 0; __i < __exponent; ++__i)
+      __decexp *= __multiplier;
+
+    return __coeff * __decexp;
+  }
+
+  // ISO/IEC TR 24733  3.2.6  Conversion to generic floating-point type.
+
+  inline float decimal32_to_float(decimal32 __d)
+  { return (float)__d.__getval(); }
+
+  inline float decimal64_to_float(decimal64 __d)
+  { return (float)__d.__getval(); }
+
+  inline float decimal128_to_float(decimal128 __d)
+  { return (float)__d.__getval(); }
+
+  inline float decimal_to_float(decimal32 __d)
+  { return (float)__d.__getval(); }
+
+  inline float decimal_to_float(decimal64 __d)
+  { return (float)__d.__getval(); }
+
+  inline float decimal_to_float(decimal128 __d)
+  { return (float)__d.__getval(); }
+
+  inline double decimal32_to_double(decimal32 __d)
+  { return (double)__d.__getval(); }
+
+  inline double decimal64_to_double(decimal64 __d)
+  { return (double)__d.__getval(); }
+
+  inline double decimal128_to_double(decimal128 __d)
+  { return (double)__d.__getval(); }
+
+  inline double decimal_to_double(decimal32 __d)
+  { return (double)__d.__getval(); }
+
+  inline double decimal_to_double(decimal64 __d)
+  { return (double)__d.__getval(); }
+
+  inline double decimal_to_double(decimal128 __d)
+  { return (double)__d.__getval(); }
+
+  inline long double decimal32_to_long_double(decimal32 __d)
+  { return (long double)__d.__getval(); }
+
+  inline long double decimal64_to_long_double(decimal64 __d)
+  { return (long double)__d.__getval(); }
+
+  inline long double decimal128_to_long_double(decimal128 __d)
+  { return (long double)__d.__getval(); }
+
+  inline long double decimal_to_long_double(decimal32 __d)
+  { return (long double)__d.__getval(); }
+
+  inline long double decimal_to_long_double(decimal64 __d)
+  { return (long double)__d.__getval(); }
+
+  inline long double decimal_to_long_double(decimal128 __d)
+  { return (long double)__d.__getval(); }
+
+  // ISO/IEC TR 24733  3.2.7  Unary arithmetic operators.
+
+#define _DEFINE_DECIMAL_UNARY_OP(_Op, _Tp)	\
+  inline _Tp operator _Op(_Tp __rhs)		\
+  {						\
+    _Tp __tmp;					\
+    __tmp.__setval(_Op __rhs.__getval());	\
+    return __tmp;				\
+  }
+
+  _DEFINE_DECIMAL_UNARY_OP(+, decimal32)
+  _DEFINE_DECIMAL_UNARY_OP(+, decimal64)
+  _DEFINE_DECIMAL_UNARY_OP(+, decimal128)
+  _DEFINE_DECIMAL_UNARY_OP(-, decimal32)
+  _DEFINE_DECIMAL_UNARY_OP(-, decimal64)
+  _DEFINE_DECIMAL_UNARY_OP(-, decimal128)
+
+#undef _DEFINE_DECIMAL_UNARY_OP
+
+  // ISO/IEC TR 24733  3.2.8  Binary arithmetic operators.
+
+#define _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(_Op, _T1, _T2, _T3)	\
+  inline _T1 operator _Op(_T2 __lhs, _T3 __rhs)			\
+  {								\
+    _T1 __retval;						\
+    __retval.__setval(__lhs.__getval() _Op __rhs.__getval());	\
+    return __retval;						\
+  }
+
+#define _DEFINE_DECIMAL_BINARY_OP_BOTH(_Op, _T1, _T2, _T3)	\
+  inline _T1 operator _Op(_T2 __lhs, _T3 __rhs)			\
+  {								\
+    _T1 __retval;						\
+    __retval.__setval(__lhs.__getval() _Op __rhs.__getval());	\
+    return __retval;						\
+  }
+
+#define _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, _T2)		\
+  inline _T1 operator _Op(_T1 __lhs, _T2 __rhs)			\
+  {								\
+    _T1 __retval;						\
+    __retval.__setval(__lhs.__getval() _Op __rhs);		\
+    return __retval;						\
+  }
+
+#define _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, _T2)		\
+  inline _T1 operator _Op(_T2 __lhs, _T1 __rhs)			\
+  {								\
+    _T1 __retval;						\
+    __retval.__setval(__lhs _Op __rhs.__getval());		\
+    return __retval;						\
+  }
+
+#define _DEFINE_DECIMAL_BINARY_OP_WITH_INT(_Op, _T1)		\
+  _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, int);			\
+  _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, unsigned int);	\
+  _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, long);		\
+  _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, unsigned long);	\
+  _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, long long);		\
+  _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, unsigned long long);	\
+  _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, int);			\
+  _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, unsigned int);	\
+  _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, long);		\
+  _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, unsigned long);	\
+  _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, long long);		\
+  _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, unsigned long long);	\
+
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal32, decimal32, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal32, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal32, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal64, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal128)
+
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal32, decimal32, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal32, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal32, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal64, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal128)
+
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal32, decimal32, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal32, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal32, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal64, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal128)
+
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal32, decimal32, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal32, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal32, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal64, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal32)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal64)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal128)
+  _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal128)
+
+#undef _DEFINE_DECIMAL_BINARY_OP_WITH_DEC
+#undef _DEFINE_DECIMAL_BINARY_OP_BOTH
+#undef _DEFINE_DECIMAL_BINARY_OP_LHS
+#undef _DEFINE_DECIMAL_BINARY_OP_RHS
+#undef _DEFINE_DECIMAL_BINARY_OP_WITH_INT
+
+  // ISO/IEC TR 24733  3.2.9  Comparison operators.
+
+#define _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _T1, _T2)	\
+  inline bool operator _Op(_T1 __lhs, _T2 __rhs)	\
+  { return __lhs.__getval() _Op __rhs.__getval(); }
+
+#define _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _T1, _T2)	\
+  inline bool operator _Op(_T1 __lhs, _T2 __rhs)	\
+  { return __lhs.__getval() _Op __rhs; }
+
+#define _DEFINE_DECIMAL_COMPARISON_RHS(_Op, _T1, _T2)	\
+  inline bool operator _Op(_T1 __lhs, _T2 __rhs)	\
+  { return __lhs _Op __rhs.__getval(); }
+
+#define _DEFINE_DECIMAL_COMPARISONS(_Op, _Tp)			\
+  _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal32)		\
+  _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal64)		\
+  _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal128)		\
+  _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, int)			\
+  _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned int)	\
+  _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, long)		\
+  _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned long)	\
+  _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, long long)		\
+  _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned long long)	\
+  _DEFINE_DECIMAL_COMPARISON_RHS(_Op, int, _Tp)			\
+  _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned int, _Tp)	\
+  _DEFINE_DECIMAL_COMPARISON_RHS(_Op, long, _Tp)		\
+  _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned long, _Tp)	\
+  _DEFINE_DECIMAL_COMPARISON_RHS(_Op, long long, _Tp)		\
+  _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned long long, _Tp)
+
+  _DEFINE_DECIMAL_COMPARISONS(==, decimal32)
+  _DEFINE_DECIMAL_COMPARISONS(==, decimal64)
+  _DEFINE_DECIMAL_COMPARISONS(==, decimal128)
+  _DEFINE_DECIMAL_COMPARISONS(!=, decimal32)
+  _DEFINE_DECIMAL_COMPARISONS(!=, decimal64)
+  _DEFINE_DECIMAL_COMPARISONS(!=, decimal128)
+  _DEFINE_DECIMAL_COMPARISONS(<,  decimal32)
+  _DEFINE_DECIMAL_COMPARISONS(<,  decimal64)
+  _DEFINE_DECIMAL_COMPARISONS(<,  decimal128)
+  _DEFINE_DECIMAL_COMPARISONS(<=, decimal32)
+  _DEFINE_DECIMAL_COMPARISONS(<=, decimal64)
+  _DEFINE_DECIMAL_COMPARISONS(<=, decimal128)
+  _DEFINE_DECIMAL_COMPARISONS(>,  decimal32)
+  _DEFINE_DECIMAL_COMPARISONS(>,  decimal64)
+  _DEFINE_DECIMAL_COMPARISONS(>,  decimal128)
+  _DEFINE_DECIMAL_COMPARISONS(>=, decimal32)
+  _DEFINE_DECIMAL_COMPARISONS(>=, decimal64)
+  _DEFINE_DECIMAL_COMPARISONS(>=, decimal128)
+
+#undef _DEFINE_DECIMAL_COMPARISON_BOTH
+#undef _DEFINE_DECIMAL_COMPARISON_LHS
+#undef _DEFINE_DECIMAL_COMPARISON_RHS
+#undef _DEFINE_DECIMAL_COMPARISONS
+  _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace decimal
+} // namespace std
+
+#endif /* _GLIBCXX_DECIMAL_IMPL */
diff --git a/gcc-4.9/libstdc++-v3/include/experimental/optional b/gcc-4.9/libstdc++-v3/include/experimental/optional
new file mode 100644
index 0000000..5f2d93f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/experimental/optional
@@ -0,0 +1,823 @@
+// <optional> -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/optional
+ *  This is a TS C++ Library header.
+ */
+
+#ifndef _GLIBCXX_EXPERIMENTAL_OPTIONAL
+#define _GLIBCXX_EXPERIMENTAL_OPTIONAL 1
+
+/**
+ * @defgroup experimental Experimental
+ *
+ * Components specified by various Technical Specifications.
+ */
+
+#if __cplusplus <= 201103L
+# include <bits/c++14_warning.h>
+#else
+
+#include <utility>
+#include <type_traits>
+#include <stdexcept>
+#include <new>
+#include <initializer_list>
+#include <bits/functexcept.h>
+#include <bits/functional_hash.h>
+#include <bits/enable_special_members.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup optional Optional values
+   * @ingroup experimental
+   *
+   * Class template for optional values and surrounding facilities, as
+   * described in n3793 "A proposal to add a utility class to represent
+   * optional objects (Revision 5)".
+   *
+   * @{
+   */
+
+  // All subsequent [X.Y.n] references are against n3793.
+
+  // [X.Y.4]
+  template<typename _Tp>
+    class optional;
+
+  // [X.Y.5]
+  /// Tag type for in-place construction.
+  struct in_place_t { };
+
+  /// Tag for in-place construction.
+  constexpr in_place_t in_place { };
+
+  // [X.Y.6]
+  /// Tag type to disengage optional objects.
+  struct nullopt_t
+  {
+    // Do not user-declare default constructor at all for
+    // optional_value = {} syntax to work.
+    // nullopt_t() = delete;
+
+    // Used for constructing nullopt.
+    enum class _Construct { _Token };
+
+    // Must be constexpr for nullopt_t to be literal.
+    explicit constexpr nullopt_t(_Construct) { }
+  };
+
+  // [X.Y.6]
+  /// Tag to disengage optional objects.
+  constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };
+
+  // [X.Y.7]
+  /**
+   *  @brief Exception class thrown when a disengaged optional object is
+   *  dereferenced.
+   *  @ingroup exceptions
+   */
+  class bad_optional_access : public logic_error
+  {
+  public:
+    // XXX Should not be inline
+    explicit bad_optional_access(const string& __arg) : logic_error(__arg) { }
+
+    explicit bad_optional_access(const char* __arg) : logic_error(__arg) { }
+
+    virtual ~bad_optional_access() noexcept = default;
+  };
+
+  void
+  __throw_bad_optional_access(const char*)
+  __attribute__((__noreturn__));
+
+  // XXX Does not belong here.
+  inline void
+  __throw_bad_optional_access(const char* __s)
+  { _GLIBCXX_THROW_OR_ABORT(bad_optional_access(__s)); }
+
+  template<typename _Tp, typename _Sfinae = void>
+    struct _Has_addressof_impl : std::false_type { };
+
+  template<typename _Tp>
+    struct _Has_addressof_impl<_Tp,
+      decltype( std::declval<const _Tp&>().operator&(), void() )>
+      : std::true_type { };
+
+  /**
+    * @brief Trait that detects the presence of an overloaded unary operator&.
+    *
+    * Practically speaking this detects the presence of such an operator when
+    * called on a const-qualified lvalue (i.e.
+    * declval<_Tp * const&>().operator&()).
+    */
+  template<typename _Tp>
+    struct _Has_addressof : _Has_addressof_impl<_Tp>::type { };
+
+  /**
+    * @brief An overload that attempts to take the address of an lvalue as a
+    * constant expression. Falls back to __addressof in the presence of an
+    * overloaded addressof operator (unary operator&), in which case the call
+    * will not be a constant expression.
+    */
+  template<typename _Tp, typename enable_if<!_Has_addressof<_Tp>::value,
+                                            int>::type...>
+    constexpr _Tp* __constexpr_addressof(_Tp& __t)
+    { return &__t; }
+
+  /**
+    * @brief Fallback overload that defers to __addressof.
+    */
+  template<typename _Tp, typename enable_if<_Has_addressof<_Tp>::value,
+                                            int>::type...>
+    inline _Tp* __constexpr_addressof(_Tp& __t)
+    { return std::__addressof(__t); }
+
+  /**
+    * @brief Class template that holds the necessary state for @ref optional
+    * and that has the responsibility for construction and the special members.
+    *
+    * Such a separate base class template is necessary in order to
+    * conditionally enable the special members (e.g. copy/move constructors).
+    * Note that this means that @ref _Optional_base implements the
+    * functionality for copy and move assignment, but not for converting
+    * assignment.
+    *
+    * @see optional, _Enable_special_members
+    */
+  template<typename _Tp, bool _ShouldProvideDestructor =
+	   !is_trivially_destructible<_Tp>::value>
+    class _Optional_base
+    {
+    private:
+      // Remove const to avoid prohibition of reusing object storage for
+      // const-qualified types in [3.8/9]. This is strictly internal
+      // and even optional itself is oblivious to it.
+      using _Stored_type = typename remove_const<_Tp>::type;
+
+    public:
+      // [X.Y.4.1] Constructors.
+
+      // Constructors for disengaged optionals.
+      constexpr _Optional_base() noexcept
+      : _M_empty{} { }
+
+      constexpr _Optional_base(nullopt_t) noexcept
+      : _Optional_base{} { }
+
+      // Constructors for engaged optionals.
+      constexpr _Optional_base(const _Tp& __t)
+      : _M_payload(__t), _M_engaged(true) { }
+
+      constexpr _Optional_base(_Tp&& __t)
+      : _M_payload(std::move(__t)), _M_engaged(true) { }
+
+      template<typename... _Args>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
+
+      template<typename _Up, typename... _Args,
+               typename enable_if<is_constructible<_Tp,
+                                                   initializer_list<_Up>&,
+                                                   _Args&&...>::value,
+                                  int>::type...>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(__il, std::forward<_Args>(__args)...),
+          _M_engaged(true) { }
+
+      // Copy and move constructors.
+      _Optional_base(const _Optional_base& __other)
+      {
+        if (__other._M_engaged)
+          this->_M_construct(__other._M_get());
+      }
+
+      _Optional_base(_Optional_base&& __other)
+      noexcept(is_nothrow_move_constructible<_Tp>())
+      {
+        if (__other._M_engaged)
+          this->_M_construct(std::move(__other._M_get()));
+      }
+
+      // [X.Y.4.3] (partly) Assignment.
+      _Optional_base&
+      operator=(const _Optional_base& __other)
+      {
+        if (this->_M_engaged && __other._M_engaged)
+          this->_M_get() = __other._M_get();
+        else
+	  {
+	    if (__other._M_engaged)
+	      this->_M_construct(__other._M_get());
+	    else
+	      this->_M_reset();
+	  }
+
+        return *this;
+      }
+
+      _Optional_base&
+      operator=(_Optional_base&& __other)
+      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+		      is_nothrow_move_assignable<_Tp>>())
+      {
+	if (this->_M_engaged && __other._M_engaged)
+	  this->_M_get() = std::move(__other._M_get());
+	else
+	  {
+	    if (__other._M_engaged)
+	      this->_M_construct(std::move(__other._M_get()));
+	    else
+	      this->_M_reset();
+	  }
+	return *this;
+      }
+
+      // [X.Y.4.2] Destructor.
+      ~_Optional_base()
+      {
+        if (this->_M_engaged)
+          this->_M_payload.~_Stored_type();
+      }
+
+      // The following functionality is also needed by optional, hence the
+      // protected accessibility.
+    protected:
+      constexpr bool _M_is_engaged() const noexcept
+      { return this->_M_engaged; }
+
+      // The _M_get operations have _M_engaged as a precondition.
+      _Tp&
+      _M_get() noexcept
+      { return _M_payload; }
+
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return _M_payload; }
+
+      // The _M_construct operation has !_M_engaged as a precondition
+      // while _M_destruct has _M_engaged as a precondition.
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+        {
+          ::new (std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
+
+      void
+      _M_destruct()
+      {
+        this->_M_engaged = false;
+        this->_M_payload.~_Stored_type();
+      }
+
+      // _M_reset is a 'safe' operation with no precondition.
+      void
+      _M_reset()
+      {
+        if (this->_M_engaged)
+          this->_M_destruct();
+      }
+
+    private:
+      struct _Empty_byte { };
+      union {
+          _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged = false;
+    };
+
+  /// Partial specialization that is exactly identical to the primary template
+  /// save for not providing a destructor, to fulfill triviality requirements.
+  template<typename _Tp>
+    class _Optional_base<_Tp, false>
+    {
+    private:
+      using _Stored_type = typename remove_const<_Tp>::type;
+
+    public:
+      constexpr _Optional_base() noexcept
+      : _M_empty{} { }
+
+      constexpr _Optional_base(nullopt_t) noexcept
+      : _Optional_base{} { }
+
+      constexpr _Optional_base(const _Tp& __t)
+      : _M_payload(__t), _M_engaged(true) { }
+
+      constexpr _Optional_base(_Tp&& __t)
+      : _M_payload(std::move(__t)), _M_engaged(true) { }
+
+      template<typename... _Args>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
+
+      template<typename _Up, typename... _Args,
+               typename enable_if<is_constructible<_Tp,
+                                                   initializer_list<_Up>&,
+                                                   _Args&&...>::value,
+                                  int>::type...>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(__il, std::forward<_Args>(__args)...),
+          _M_engaged(true) { }
+
+      _Optional_base(const _Optional_base& __other)
+      {
+        if (__other._M_engaged)
+          this->_M_construct(__other._M_get());
+      }
+
+      _Optional_base(_Optional_base&& __other)
+      noexcept(is_nothrow_move_constructible<_Tp>())
+      {
+        if (__other._M_engaged)
+          this->_M_construct(std::move(__other._M_get()));
+      }
+
+      _Optional_base&
+      operator=(const _Optional_base& __other)
+      {
+	if (this->_M_engaged && __other._M_engaged)
+	  this->_M_get() = __other._M_get();
+	else
+	  {
+	    if (__other._M_engaged)
+	      this->_M_construct(__other._M_get());
+	    else
+	      this->_M_reset();
+	  }
+	return *this;
+      }
+
+      _Optional_base&
+      operator=(_Optional_base&& __other)
+      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+		      is_nothrow_move_assignable<_Tp>>())
+      {
+	if (this->_M_engaged && __other._M_engaged)
+	  this->_M_get() = std::move(__other._M_get());
+	else
+	  {
+	    if (__other._M_engaged)
+	      this->_M_construct(std::move(__other._M_get()));
+	    else
+	      this->_M_reset();
+	  }
+	return *this;
+      }
+
+      // Sole difference
+      // ~_Optional_base() noexcept = default;
+
+    protected:
+      constexpr bool _M_is_engaged() const noexcept
+      { return this->_M_engaged; }
+
+      _Tp&
+      _M_get() noexcept
+      { return _M_payload; }
+
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return _M_payload; }
+
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+        {
+          ::new (std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
+
+      void
+      _M_destruct()
+      {
+        this->_M_engaged = false;
+        this->_M_payload.~_Stored_type();
+      }
+
+      void
+      _M_reset()
+      {
+        if (this->_M_engaged)
+          this->_M_destruct();
+      }
+
+    private:
+      struct _Empty_byte { };
+      union
+      {
+	_Empty_byte _M_empty;
+	_Stored_type _M_payload;
+      };
+      bool _M_engaged = false;
+    };
+
+  /**
+    * @brief Class template for optional values.
+    */
+  template<typename _Tp>
+    class optional
+    : private _Optional_base<_Tp>,
+      private _Enable_copy_move<
+        // Copy constructor.
+        is_copy_constructible<_Tp>::value,
+        // Copy assignment.
+        __and_<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>::value,
+        // Move constructor.
+        is_move_constructible<_Tp>::value,
+        // Move assignment.
+        __and_<is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value,
+        // Unique tag type.
+        optional<_Tp>>
+    {
+      static_assert(__and_<__not_<is_same<typename remove_cv<_Tp>::type,
+					  nullopt_t>>,
+			   __not_<is_same<typename remove_cv<_Tp>::type,
+					  in_place_t>>,
+			   __not_<is_reference<_Tp>>>(),
+                    "Invalid instantiation of optional<T>");
+
+    private:
+      using _Base = _Optional_base<_Tp>;
+
+    public:
+      using value_type = _Tp;
+
+      // _Optional_base has the responsibility for construction.
+      using _Base::_Base;
+
+      // [X.Y.4.3] (partly) Assignment.
+      optional&
+      operator=(nullopt_t) noexcept
+      {
+        this->_M_reset();
+        return *this;
+      }
+
+      template<typename _Up>
+        typename enable_if<
+                 is_same<_Tp, typename decay<_Up>::type>::value,
+                 optional&
+               >::type
+        operator=(_Up&& __u)
+        {
+          static_assert(__and_<is_constructible<_Tp, _Up>,
+			       is_assignable<_Tp&, _Up>>(),
+                        "Cannot assign to value type from argument");
+
+          if (this->_M_is_engaged())
+            this->_M_get() = std::forward<_Up>(__u);
+          else
+            this->_M_construct(std::forward<_Up>(__u));
+
+          return *this;
+        }
+
+      template<typename... _Args>
+	void
+	emplace(_Args&&... __args)
+	{
+	  static_assert(is_constructible<_Tp, _Args&&...>(),
+			"Cannot emplace value type from arguments");
+
+	  this->_M_reset();
+	  this->_M_construct(std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Up, typename... _Args>
+        typename enable_if<
+                 is_constructible<_Tp,
+                                  initializer_list<_Up>&,
+                                  _Args&&...>::value
+               >::type
+	emplace(initializer_list<_Up> __il, _Args&&... __args)
+	{
+	  this->_M_reset();
+	  this->_M_construct(__il, std::forward<_Args>(__args)...);
+	}
+
+      // [X.Y.4.2] Destructor is implicit, implemented in _Optional_base.
+
+      // [X.Y.4.4] Swap.
+      void
+      swap(optional& __other)
+      noexcept(is_nothrow_move_constructible<_Tp>()
+               && noexcept(swap(declval<_Tp&>(), declval<_Tp&>())))
+      {
+        using std::swap;
+
+        if (this->_M_is_engaged() && __other._M_is_engaged())
+          swap(this->_M_get(), __other._M_get());
+        else if (this->_M_is_engaged())
+	  {
+	    __other._M_construct(std::move(this->_M_get()));
+	    this->_M_destruct();
+	  }
+        else if (__other._M_is_engaged())
+	  {
+	    this->_M_construct(std::move(__other._M_get()));
+	    __other._M_destruct();
+	  }
+      }
+
+      // [X.Y.4.5] Observers.
+      constexpr const _Tp*
+      operator->() const
+      { return __constexpr_addressof(this->_M_get()); }
+
+      _Tp*
+      operator->()
+      { return std::__addressof(this->_M_get()); }
+
+      constexpr const _Tp&
+      operator*() const
+      { return this->_M_get(); }
+
+      _Tp&
+      operator*()
+      { return this->_M_get(); }
+
+      constexpr explicit operator bool() const noexcept
+      { return this->_M_is_engaged(); }
+
+      constexpr const _Tp&
+      value() const
+      {
+	return this->_M_is_engaged()
+	  ?  this->_M_get()
+	  : (__throw_bad_optional_access("Attempt to access value of a "
+		                         "disengaged optional object"),
+	     this->_M_get());
+      }
+
+      _Tp&
+      value()
+      {
+        if (this->_M_is_engaged())
+          return this->_M_get();
+
+        __throw_bad_optional_access("Attempt to access value of a "
+				    "disengaged optional object");
+      }
+
+      template<typename _Up>
+	constexpr _Tp
+	value_or(_Up&& __u) const&
+	{
+	  static_assert(__and_<is_copy_constructible<_Tp>,
+			       is_convertible<_Up&&, _Tp>>(),
+			"Cannot return value");
+
+	  return this->_M_is_engaged()
+	    ? this->_M_get()
+	    : static_cast<_Tp>(std::forward<_Up>(__u));
+	}
+
+      template<typename _Up>
+	_Tp
+	value_or(_Up&& __u) &&
+	{
+	  static_assert(__and_<is_move_constructible<_Tp>,
+			       is_convertible<_Up&&, _Tp>>(),
+			"Cannot return value" );
+
+	  return this->_M_is_engaged()
+	    ? std::move(this->_M_get())
+	    : static_cast<_Tp>(std::forward<_Up>(__u));
+	}
+    };
+
+  // [X.Y.8] Comparisons between optional values.
+  template<typename _Tp>
+    constexpr bool
+    operator==(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs)
+    {
+      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
+	     && (!__lhs || *__lhs == *__rhs);
+    }
+
+  template<typename _Tp>
+    constexpr bool
+    operator!=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs)
+    {
+      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
+    }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs)
+    { return __rhs < __lhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs)
+    { return !(__rhs < __lhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs)
+    { return !(__lhs < __rhs); }
+
+  // [X.Y.9] Comparisons with nullopt.
+  template<typename _Tp>
+    constexpr bool
+    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return !__lhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return !__rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return static_cast<bool>(__lhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return static_cast<bool>(__rhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
+    { return false; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return static_cast<bool>(__rhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return static_cast<bool>(__lhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
+    { return false; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return !__lhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
+    { return true; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
+    { return true; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return !__rhs; }
+
+  // [X.Y.10] Comparisons with value type.
+  template<typename _Tp>
+    constexpr bool
+    operator==(const optional<_Tp>& __lhs, const _Tp& __rhs)
+    { return __lhs && *__lhs == __rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator==(const _Tp& __lhs, const optional<_Tp>& __rhs)
+    { return __rhs && __lhs == *__rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator!=(const optional<_Tp>& __lhs, _Tp const& __rhs)
+    { return !__lhs || *__lhs != __rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator!=(const _Tp& __lhs, const optional<_Tp>& __rhs)
+    { return !__rhs || __lhs != *__rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<(const optional<_Tp>& __lhs, const _Tp& __rhs)
+    { return !__lhs || *__lhs < __rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<(const _Tp& __lhs, const optional<_Tp>& __rhs)
+    { return __rhs && __lhs < *__rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>(const optional<_Tp>& __lhs, const _Tp& __rhs)
+    { return __lhs && __rhs < *__lhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>(const _Tp& __lhs, const optional<_Tp>& __rhs)
+    { return !__rhs || *__rhs < __lhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<=(const optional<_Tp>& __lhs, const _Tp& __rhs)
+    { return !__lhs || !(__rhs < *__lhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<=(const _Tp& __lhs, const optional<_Tp>& __rhs)
+    { return __rhs && !(*__rhs < __lhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>=(const optional<_Tp>& __lhs, const _Tp& __rhs)
+    { return __lhs && !(*__lhs < __rhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>=(const _Tp& __lhs, const optional<_Tp>& __rhs)
+    { return !__rhs || !(__lhs < *__rhs); }
+
+  // [X.Y.11]
+  template<typename _Tp>
+    inline void
+    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
+    { __lhs.swap(__rhs); }
+
+  template<typename _Tp>
+    constexpr optional<typename decay<_Tp>::type>
+    make_optional(_Tp&& __t)
+    { return optional<typename decay<_Tp>::type> { std::forward<_Tp>(__t) }; }
+
+  // @} group optional
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+
+  // [X.Y.12]
+  template<typename _Tp>
+    struct hash<experimental::optional<_Tp>>
+    {
+      using result_type = size_t;
+      using argument_type = experimental::optional<_Tp>;
+
+      size_t
+      operator()(const experimental::optional<_Tp>& __t) const
+      noexcept(noexcept(hash<_Tp> {}(*__t)))
+      {
+        // We pick an arbitrary hash for disengaged optionals which hopefully
+        // usual values of _Tp won't typically hash to.
+        constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
+        return __t ? hash<_Tp> {}(*__t) : __magic_disengaged_hash;
+      }
+    };
+}
+
+#endif // C++14
+
+#endif // _GLIBCXX_EXPERIMENTAL_OPTIONAL
diff --git a/gcc-4.9/libstdc++-v3/include/experimental/string_view b/gcc-4.9/libstdc++-v3/include/experimental/string_view
new file mode 100644
index 0000000..bebeb6b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/experimental/string_view
@@ -0,0 +1,708 @@
+// Components for manipulating non-owning sequences of characters -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/string_view
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// N3762 basic_string_view library
+//
+
+#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW
+#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW 1
+
+#pragma GCC system_header
+
+#if __cplusplus <= 201103L
+# include <bits/c++14_warning.h>
+#else
+
+#include <debug/debug.h>
+#include <string>
+#include <limits>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @class basic_string_view <string_view>
+   *  @brief  A non-owning reference to a string.
+   *
+   *  @ingroup strings
+   *  @ingroup sequences
+   *
+   *  @tparam _CharT  Type of character
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  A basic_string_view looks like this:
+   *
+   *  @code
+   *    _CharT*    _M_str
+   *    size_t     _M_len
+   *  @endcode
+   *
+   *  A basic_string_view represents an empty string with a static constexpr
+   *  length one string:
+   *
+   *  @code
+   *    static constexpr value_type _S_empty_str[1]{0};
+   *  @endcode
+   */
+  template<typename _CharT, typename _Traits = char_traits<_CharT>>
+    class basic_string_view
+    {
+
+    public:
+
+      // types
+      using traits_type = _Traits;
+      using value_type = _CharT;
+      using pointer = const _CharT*;
+      using const_pointer = const _CharT*;
+      using reference = const _CharT&;
+      using const_reference = const _CharT&;
+      using const_iterator = const _CharT*;
+      using iterator = const_iterator;
+      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+      using reverse_iterator = const_reverse_iterator;
+      using size_type = size_t;
+      using difference_type = ptrdiff_t;
+      static constexpr size_type npos = size_type(-1);
+
+      // [string.view.cons], construct/copy
+
+      constexpr
+      basic_string_view() noexcept
+      : _M_len{0}, _M_str{_S_empty_str}
+      { }
+
+      constexpr basic_string_view(const basic_string_view&) noexcept = default;
+
+      template<typename _Allocator>
+        basic_string_view(const basic_string<_CharT, _Traits,
+			  _Allocator>& __str) noexcept
+        : _M_len{__str.length()}, _M_str{__str.data()}
+        { }
+
+      constexpr basic_string_view(const _CharT* __str)
+      : _M_len{__str == nullptr ? 0 : traits_type::length(__str)},
+	_M_str{__str == nullptr ? _S_empty_str : __str}
+      { }
+
+      constexpr basic_string_view(const _CharT* __str, size_type __len)
+      : _M_len{__str == nullptr ? 0 :__len},
+        _M_str{__str == nullptr ? _S_empty_str : __str}
+      { }
+
+      basic_string_view&
+      operator=(const basic_string_view&) noexcept = default;
+
+      // [string.view.iterators], iterators
+
+      constexpr const_iterator
+      begin() const noexcept
+      { return this->_M_str; }
+
+      constexpr const_iterator
+      end() const noexcept
+      { return this->_M_str + this->_M_len; }
+
+      constexpr const_iterator
+      cbegin() const noexcept
+      { return this->_M_str; }
+
+      constexpr const_iterator
+      cend() const noexcept
+      { return this->_M_str + this->_M_len; }
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return std::reverse_iterator<const_iterator>(this->end()); }
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return std::reverse_iterator<const_iterator>(this->begin()); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return std::reverse_iterator<const_iterator>(this->end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return std::reverse_iterator<const_iterator>(this->begin()); }
+
+      // [string.view.capacity], capacity
+
+      constexpr size_type
+      size() const noexcept
+      { return this->_M_len; }
+
+      constexpr size_type
+      length() const noexcept
+      { return _M_len; }
+
+      constexpr size_type
+      max_size() const noexcept
+      { return ((npos - sizeof(size_type) - sizeof(void*))
+		/ sizeof(value_type) / 4); }
+
+      constexpr bool
+      empty() const noexcept
+      { return this->_M_len == 0; }
+
+      // [string.view.access], element access
+
+      constexpr const _CharT&
+      operator[](size_type __pos) const
+      {
+	// TODO: Assert to restore in a way compatible with the constexpr.
+	// _GLIBCXX_DEBUG_ASSERT(__pos < this->_M_len);
+	return *(this->_M_str + __pos);
+      }
+
+      constexpr const _CharT&
+      at(size_type __pos) const
+      {
+	return __pos < this->_M_len
+	     ? *(this->_M_str + __pos)
+	     : (__throw_out_of_range_fmt(__N("basic_string_view::at: __pos "
+					     "(which is %zu) >= this->size() "
+					     "(which is %zu)"),
+					 __pos, this->size()),
+		_S_empty_str[0]);
+      }
+
+      constexpr const _CharT&
+      front() const
+      {
+	// TODO: Assert to restore in a way compatible with the constexpr.
+	// _GLIBCXX_DEBUG_ASSERT(this->_M_len > 0);
+	return *this->_M_str;
+      }
+
+      constexpr const _CharT&
+      back() const
+      {
+	// TODO: Assert to restore in a way compatible with the constexpr.
+	// _GLIBCXX_DEBUG_ASSERT(this->_M_len > 0);
+	return *(this->_M_str + this->_M_len - 1);
+      }
+
+      constexpr const _CharT*
+      data() const noexcept
+      { return this->_M_str; }
+
+      // [string.view.modifiers], modifiers:
+      void
+      clear() noexcept
+      {
+	this->_M_len = 0;
+	this->_M_str = _S_empty_str;
+      }
+
+      void
+      remove_prefix(size_type __n)
+      {
+	_GLIBCXX_DEBUG_ASSERT(this->_M_len >= __n);
+	this->_M_str += __n;
+	this->_M_len -= __n;
+      }
+
+      void
+      remove_suffix(size_type __n)
+      { this->_M_len -= __n; }
+
+      void
+      swap(basic_string_view& __sv) noexcept
+      {
+	std::swap(this->_M_len, __sv._M_len);
+	std::swap(this->_M_str, __sv._M_str);
+      }
+
+
+      // [string.view.ops], string operations:
+
+      template<typename _Allocator>
+        explicit operator basic_string<_CharT, _Traits, _Allocator>() const
+        {
+	  return basic_string<_CharT, _Traits, _Allocator>
+					(this->_M_len, this->_M_str);
+	}
+
+      size_type
+      copy(_CharT* __str, size_type __n, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string_len(__str, __n);
+	if (__pos > this->_M_len)
+	  __throw_out_of_range_fmt(__N("basic_string_view::copy: __pos "
+				       "(which is %zu) > this->size() "
+				       "(which is %zu)"),
+				   __pos, this->size());
+	size_type __rlen{std::min(__n, size_type{this->_M_len  - __pos})};
+	for (auto __begin = this->_M_str + __pos,
+	     __end = __begin + __rlen; __begin != __end;)
+	  *__str++ = *__begin++;
+	return __rlen;
+      }
+
+
+      // [string.view.ops], string operations:
+
+      constexpr basic_string_view
+      substr(size_type __pos, size_type __n=npos) const
+      {
+	return __pos <= this->_M_len
+	     ? basic_string_view{this->_M_str + __pos,
+				std::min(__n, size_type{this->_M_len  - __pos})}
+	     : (__throw_out_of_range_fmt(__N("basic_string_view::substr: __pos "
+					     "(which is %zu) > this->size() "
+					     "(which is %zu)"),
+				     __pos, this->size()), basic_string_view{});
+      }
+
+      int
+      compare(basic_string_view __str) const noexcept
+      {
+	int __ret = traits_type::compare(this->_M_str, __str._M_str,
+					 std::min(this->_M_len, __str._M_len));
+	if (__ret == 0)
+	  __ret = _S_compare(this->_M_len, __str._M_len);
+	return __ret;
+      }
+
+      int
+      compare(size_type __pos1, size_type __n1, basic_string_view __str) const
+      { return this->substr(__pos1, __n1).compare(__str); }
+
+      int
+      compare(size_type __pos1, size_type __n1,
+	      basic_string_view __str, size_type __pos2, size_type __n2) const
+      { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); }
+
+      int
+      compare(const _CharT* __str) const noexcept
+      { return this->compare(basic_string_view{__str}); }
+
+      int
+      compare(size_type __pos1, size_type __n1, const _CharT* __str) const
+      { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }
+
+      int
+      compare(size_type __pos1, size_type __n1,
+	      const _CharT* __str, size_type __n2) const
+      {
+	return this->substr(__pos1, __n1)
+		   .compare(basic_string_view(__str, __n2));
+      }
+
+      size_type
+      find(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find(__str._M_str, __pos, __str._M_len); }
+
+      size_type
+      find(_CharT __c, size_type __pos=0) const noexcept;
+
+      size_type
+      find(const _CharT* __str, size_type __pos, size_type __n) const;
+
+      size_type
+      find(const _CharT* __str, size_type __pos=0) const noexcept
+      { return this->find(__str, __pos, traits_type::length(__str)); }
+
+      size_type
+      rfind(basic_string_view __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str._M_str, __pos, __str._M_len); }
+
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+
+      size_type
+      rfind(const _CharT* __str, size_type __pos, size_type __n) const;
+
+      size_type
+      rfind(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str, __pos, traits_type::length(__str)); }
+
+      size_type
+      find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str._M_str, __pos, __str._M_len); }
+
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+
+      size_type
+      find_first_of(const _CharT* __str, size_type __pos, size_type __n) const;
+
+      size_type
+      find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str, __pos, traits_type::length(__str)); }
+
+      size_type
+      find_last_of(basic_string_view __str,
+		   size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str._M_str, __pos, __str._M_len); }
+
+      size_type
+      find_last_of(_CharT __c, size_type __pos=npos) const noexcept
+      { return this->rfind(__c, __pos); }
+
+      size_type
+      find_last_of(const _CharT* __str, size_type __pos, size_type __n) const;
+
+      size_type
+      find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str, __pos, traits_type::length(__str)); }
+
+      size_type
+      find_first_not_of(basic_string_view __str,
+			size_type __pos = 0) const noexcept
+      { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }
+
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
+
+      size_type
+      find_first_not_of(const _CharT* __str,
+			size_type __pos, size_type __n) const;
+
+      size_type
+      find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      {
+	return this->find_first_not_of(__str, __pos,
+				       traits_type::length(__str));
+      }
+
+      size_type
+      find_last_not_of(basic_string_view __str,
+		       size_type __pos = npos) const noexcept
+      { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }
+
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;
+
+      size_type
+      find_last_not_of(const _CharT* __str,
+		       size_type __pos, size_type __n) const;
+
+      size_type
+      find_last_not_of(const _CharT* __str,
+		       size_type __pos = npos) const noexcept
+      {
+	return this->find_last_not_of(__str, __pos,
+				      traits_type::length(__str));
+      }
+
+    private:
+
+      static constexpr const int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+	return difference_type{__n1 - __n2} > std::numeric_limits<int>::max()
+	     ? std::numeric_limits<int>::max()
+	     : difference_type{__n1 - __n2} < std::numeric_limits<int>::min()
+	     ? std::numeric_limits<int>::min()
+	     : static_cast<int>(difference_type{__n1 - __n2});
+      }
+
+      static constexpr value_type _S_empty_str[1]{};
+
+      size_t	    _M_len;
+      const _CharT* _M_str;
+    };
+
+
+  // [string.view.comparison], non-member basic_string_view comparison functions
+
+  namespace __detail
+  {
+    //  Identity transform to make ADL work with just one argument.
+    //  See n3766.html.
+    template<typename _Tp = void>
+      struct __identity
+      { typedef _Tp type; };
+
+    template<>
+      struct __identity<void>;
+
+    template<typename _Tp>
+      using __idt = typename __identity<_Tp>::type;
+  }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator==(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator!=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator< (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator> (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator<=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    operator>=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+  // [string.view.comparison], sufficient additional overloads of comparison functions
+
+  // [string.view.nonmem], other non-member basic_string_view functions
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Allocator = allocator<_CharT>>
+    basic_string<_CharT, _Traits, _Allocator>
+    to_string(basic_string_view<_CharT, _Traits> __str,
+	      const _Allocator& __alloc = _Allocator())
+    {
+      return basic_string<_CharT, _Traits, _Allocator>
+			(__str.begin(), __str.end(), __alloc);
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+      operator<<(basic_ostream<_CharT, _Traits>& __os,
+                 basic_string_view<_CharT,_Traits> __str)
+      { return __ostream_insert(__os, __str.data(), __str.size()); }
+
+
+  // basic_string_view typedef names
+
+  using string_view = basic_string_view<char>;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  using wstring_view = basic_string_view<wchar_t>;
+#endif
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+  using u16string_view = basic_string_view<char16_t>;
+  using u32string_view = basic_string_view<char32_t>;
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace experimental
+
+
+  // [string.view.hash], hash support:
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+  template<typename _Tp>
+    struct hash;
+
+  template<>
+    struct hash<experimental::string_view>
+    : public __hash_base<size_t, experimental::string_view>
+    {
+      size_t
+      operator()(const experimental::string_view& __str) const noexcept
+      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<experimental::string_view>> : std::false_type
+    { };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    struct hash<experimental::wstring_view>
+    : public __hash_base<size_t, wstring>
+    {
+      size_t
+      operator()(const experimental::wstring_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<experimental::wstring_view>> : std::false_type
+    { };
+#endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+  template<>
+    struct hash<experimental::u16string_view>
+    : public __hash_base<size_t, experimental::u16string_view>
+    {
+      size_t
+      operator()(const experimental::u16string_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<experimental::u16string_view>> : std::false_type
+    { };
+
+  template<>
+    struct hash<experimental::u32string_view>
+    : public __hash_base<size_t, experimental::u32string_view>
+    {
+      size_t
+      operator()(const experimental::u32string_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<experimental::u32string_view>> : std::false_type
+    { };
+#endif
+_GLIBCXX_END_NAMESPACE_VERSION
+
+namespace experimental
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // I added these EMSR.
+  inline namespace literals
+  {
+  inline namespace string_view_literals
+  {
+
+    inline basic_string_view<char>
+    operator""sv(const char* __str, size_t __len)
+    { return basic_string_view<char>{__str, __len}; }
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+    inline basic_string_view<wchar_t>
+    operator""sv(const wchar_t* __str, size_t __len)
+    { return basic_string_view<wchar_t>{__str, __len}; }
+#endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+    inline basic_string_view<char16_t>
+    operator""sv(const char16_t* __str, size_t __len)
+    { return basic_string_view<char16_t>{__str, __len}; }
+
+    inline basic_string_view<char32_t>
+    operator""sv(const char32_t* __str, size_t __len)
+    { return basic_string_view<char32_t>{__str, __len}; }
+#endif
+
+  }
+  }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace experimental
+} // namespace std
+
+#include <experimental/string_view.tcc>
+
+#endif // __cplusplus <= 201103L
+
+#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW
diff --git a/gcc-4.9/libstdc++-v3/include/experimental/string_view.tcc b/gcc-4.9/libstdc++-v3/include/experimental/string_view.tcc
new file mode 100644
index 0000000..1af3a4d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/experimental/string_view.tcc
@@ -0,0 +1,234 @@
+// Components for manipulating non-owning sequences of characters -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/string_view.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{string_view}
+ */
+
+//
+// N3762 basic_string_view library
+//
+
+#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC
+#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC 1
+
+#pragma GCC system_header
+
+#if __cplusplus <= 201103L
+# include <bits/c++14_warning.h>
+#else
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    constexpr _CharT
+    basic_string_view<_CharT, _Traits>::_S_empty_str[1];
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+    {
+      __glibcxx_requires_string_len(__str, __n);
+
+      if (__n == 0)
+	return __pos <= this->_M_len ? __pos : npos;
+
+      if (__n <= this->_M_len)
+	{
+	  for (; __pos <= this->_M_len - __n; ++__pos)
+	    if (traits_type::eq(this->_M_str[__pos], __str[0])
+		&& traits_type::compare(this->_M_str + __pos + 1,
+					__str + 1, __n - 1) == 0)
+	      return __pos;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __ret = npos;
+      if (__pos < this->_M_len)
+	{
+	  const size_type __n = this->_M_len - __pos;
+	  const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
+	  if (__p)
+	    __ret = __p - this->_M_str;
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+    {
+      __glibcxx_requires_string_len(__str, __n);
+
+      if (__n <= this->_M_len)
+	{
+	  __pos = std::min(size_type(this->_M_len - __n), __pos);
+	  do
+	    {
+	      if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
+		return __pos;
+	    }
+	  while (__pos-- > 0);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    rfind(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->_M_len;
+      if (__size > 0)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  for (++__size; __size-- > 0; )
+	    if (traits_type::eq(this->_M_str[__size], __c))
+	      return __size;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_of(const _CharT* __str, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__str, __n);
+      for (; __n && __pos < this->_M_len; ++__pos)
+	{
+	  const _CharT* __p = traits_type::find(__str, __n,
+						this->_M_str[__pos]);
+	  if (__p)
+	    return __pos;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_of(const _CharT* __str, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__str, __n);
+      size_type __size = this->size();
+      if (__size && __n)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (traits_type::find(__str, __n, this->_M_str[__size]))
+		return __size;
+	    }
+	  while (__size-- != 0);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__str, __n);
+      for (; __pos < this->_M_len; ++__pos)
+	if (!traits_type::find(__str, __n, this->_M_str[__pos]))
+	  return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      for (; __pos < this->_M_len; ++__pos)
+	if (!traits_type::eq(this->_M_str[__pos], __c))
+	  return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__str, __n);
+      size_type __size = this->_M_len;
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (!traits_type::find(__str, __n, this->_M_str[__size]))
+		return __size;
+	    }
+	  while (__size--);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->_M_len;
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (!traits_type::eq(this->_M_str[__size], __c))
+		return __size;
+	    }
+	  while (__size--);
+	}
+      return npos;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace experimental
+} // namespace std
+
+#endif // __cplusplus <= 201103L
+
+#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/ext/algorithm b/gcc-4.9/libstdc++-v3/include/ext/algorithm
new file mode 100644
index 0000000..2731e67
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/algorithm
@@ -0,0 +1,603 @@
+// Algorithm extensions -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/algorithm
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _EXT_ALGORITHM
+#define _EXT_ALGORITHM 1
+
+#pragma GCC system_header
+
+#include <algorithm>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::ptrdiff_t;
+  using std::min;
+  using std::pair;
+  using std::input_iterator_tag;
+  using std::random_access_iterator_tag;
+  using std::iterator_traits;
+
+  //--------------------------------------------------
+  // copy_n (not part of the C++ standard)
+
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    pair<_InputIterator, _OutputIterator>
+    __copy_n(_InputIterator __first, _Size __count,
+	     _OutputIterator __result,
+	     input_iterator_tag)
+    {
+      for ( ; __count > 0; --__count)
+	{
+	  *__result = *__first;
+	  ++__first;
+	  ++__result;
+	}
+      return pair<_InputIterator, _OutputIterator>(__first, __result);
+    }
+
+  template<typename _RAIterator, typename _Size, typename _OutputIterator>
+    inline pair<_RAIterator, _OutputIterator>
+    __copy_n(_RAIterator __first, _Size __count,
+	     _OutputIterator __result,
+	     random_access_iterator_tag)
+    {
+      _RAIterator __last = __first + __count;
+      return pair<_RAIterator, _OutputIterator>(__last, std::copy(__first,
+								  __last,
+								  __result));
+    }
+
+  /**
+   *  @brief Copies the range [first,first+count) into [result,result+count).
+   *  @param  __first  An input iterator.
+   *  @param  __count  The number of elements to copy.
+   *  @param  __result An output iterator.
+   *  @return   A std::pair composed of first+count and result+count.
+   *
+   *  This is an SGI extension.
+   *  This inline function will boil down to a call to @c memmove whenever
+   *  possible.  Failing that, if random access iterators are passed, then the
+   *  loop count will be known (and therefore a candidate for compiler
+   *  optimizations such as unrolling).
+   *  @ingroup SGIextensions
+  */
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    inline pair<_InputIterator, _OutputIterator>
+    copy_n(_InputIterator __first, _Size __count, _OutputIterator __result)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+	    typename iterator_traits<_InputIterator>::value_type>)
+
+      return __gnu_cxx::__copy_n(__first, __count, __result,
+				 std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2>
+    int
+    __lexicographical_compare_3way(_InputIterator1 __first1,
+				   _InputIterator1 __last1,
+				   _InputIterator2 __first2,
+				   _InputIterator2 __last2)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (*__first1 < *__first2)
+	    return -1;
+	  if (*__first2 < *__first1)
+	    return 1;
+	  ++__first1;
+	  ++__first2;
+	}
+      if (__first2 == __last2)
+	return !(__first1 == __last1);
+      else
+	return -1;
+    }
+
+  inline int
+  __lexicographical_compare_3way(const unsigned char* __first1,
+				 const unsigned char* __last1,
+				 const unsigned char* __first2,
+				 const unsigned char* __last2)
+  {
+    const ptrdiff_t __len1 = __last1 - __first1;
+    const ptrdiff_t __len2 = __last2 - __first2;
+    const int __result = __builtin_memcmp(__first1, __first2,
+					  min(__len1, __len2));
+    return __result != 0 ? __result
+			 : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
+  }
+
+  inline int
+  __lexicographical_compare_3way(const char* __first1, const char* __last1,
+				 const char* __first2, const char* __last2)
+  {
+#if CHAR_MAX == SCHAR_MAX
+    return __lexicographical_compare_3way((const signed char*) __first1,
+					  (const signed char*) __last1,
+					  (const signed char*) __first2,
+					  (const signed char*) __last2);
+#else
+    return __lexicographical_compare_3way((const unsigned char*) __first1,
+					  (const unsigned char*) __last1,
+					  (const unsigned char*) __first2,
+					  (const unsigned char*) __last2);
+#endif
+  }
+
+  /**
+   *  @brief @c memcmp on steroids.
+   *  @param  __first1  An input iterator.
+   *  @param  __last1   An input iterator.
+   *  @param  __first2  An input iterator.
+   *  @param  __last2   An input iterator.
+   *  @return   An int, as with @c memcmp.
+   *
+   *  The return value will be less than zero if the first range is
+   *  <em>lexigraphically less than</em> the second, greater than zero
+   *  if the second range is <em>lexigraphically less than</em> the
+   *  first, and zero otherwise.
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+  */
+  template<typename _InputIterator1, typename _InputIterator2>
+    int
+    lexicographical_compare_3way(_InputIterator1 __first1,
+				 _InputIterator1 __last1,
+				 _InputIterator2 __first2,
+				 _InputIterator2 __last2)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_InputIterator1>::value_type>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_InputIterator2>::value_type>)
+      __glibcxx_requires_valid_range(__first1, __last1);
+      __glibcxx_requires_valid_range(__first2, __last2);
+
+      return __lexicographical_compare_3way(__first1, __last1, __first2,
+					    __last2);
+    }
+
+  // count and count_if: this version, whose return type is void, was present
+  // in the HP STL, and is retained as an extension for backward compatibility.
+  template<typename _InputIterator, typename _Tp, typename _Size>
+    void
+    count(_InputIterator __first, _InputIterator __last,
+	  const _Tp& __value,
+	  _Size& __n)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_EqualityComparableConcept<
+	    typename iterator_traits<_InputIterator>::value_type >)
+      __glibcxx_function_requires(_EqualityComparableConcept<_Tp>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for ( ; __first != __last; ++__first)
+	if (*__first == __value)
+	  ++__n;
+    }
+
+  template<typename _InputIterator, typename _Predicate, typename _Size>
+    void
+    count_if(_InputIterator __first, _InputIterator __last,
+	     _Predicate __pred,
+	     _Size& __n)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
+	    typename iterator_traits<_InputIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      for ( ; __first != __last; ++__first)
+	if (__pred(*__first))
+	  ++__n;
+    }
+
+  // random_sample and random_sample_n (extensions, not part of the standard).
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _ForwardIterator, typename _OutputIterator,
+	   typename _Distance>
+    _OutputIterator
+    random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
+                    _OutputIterator __out, const _Distance __n)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      _Distance __remaining = std::distance(__first, __last);
+      _Distance __m = min(__n, __remaining);
+
+      while (__m > 0)
+	{
+	  if ((std::rand() % __remaining) < __m)
+	    {
+	      *__out = *__first;
+	      ++__out;
+	      --__m;
+	    }
+	  --__remaining;
+	  ++__first;
+	}
+      return __out;
+    }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _ForwardIterator, typename _OutputIterator,
+	   typename _Distance, typename _RandomNumberGenerator>
+    _OutputIterator
+    random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
+                   _OutputIterator __out, const _Distance __n,
+		   _RandomNumberGenerator& __rand)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
+		typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_function_requires(_UnaryFunctionConcept<
+		_RandomNumberGenerator, _Distance, _Distance>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      _Distance __remaining = std::distance(__first, __last);
+      _Distance __m = min(__n, __remaining);
+
+      while (__m > 0)
+	{
+	  if (__rand(__remaining) < __m)
+	    {
+	      *__out = *__first;
+	      ++__out;
+	      --__m;
+	    }
+	  --__remaining;
+	  ++__first;
+	}
+      return __out;
+    }
+
+  template<typename _InputIterator, typename _RandomAccessIterator,
+	   typename _Distance>
+    _RandomAccessIterator
+    __random_sample(_InputIterator __first, _InputIterator __last,
+		    _RandomAccessIterator __out,
+		    const _Distance __n)
+    {
+      _Distance __m = 0;
+      _Distance __t = __n;
+      for ( ; __first != __last && __m < __n; ++__m, ++__first)
+	__out[__m] = *__first;
+
+      while (__first != __last)
+	{
+	  ++__t;
+	  _Distance __M = std::rand() % (__t);
+	  if (__M < __n)
+	    __out[__M] = *__first;
+	  ++__first;
+	}
+      return __out + __m;
+    }
+
+  template<typename _InputIterator, typename _RandomAccessIterator,
+	   typename _RandomNumberGenerator, typename _Distance>
+    _RandomAccessIterator
+    __random_sample(_InputIterator __first, _InputIterator __last,
+		    _RandomAccessIterator __out,
+		    _RandomNumberGenerator& __rand,
+		    const _Distance __n)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_UnaryFunctionConcept<
+	    _RandomNumberGenerator, _Distance, _Distance>)
+
+      _Distance __m = 0;
+      _Distance __t = __n;
+      for ( ; __first != __last && __m < __n; ++__m, ++__first)
+	__out[__m] = *__first;
+
+      while (__first != __last)
+	{
+	  ++__t;
+	  _Distance __M = __rand(__t);
+	  if (__M < __n)
+	    __out[__M] = *__first;
+	  ++__first;
+	}
+      return __out + __m;
+    }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    random_sample(_InputIterator __first, _InputIterator __last,
+		  _RandomAccessIterator __out_first,
+		  _RandomAccessIterator __out_last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_valid_range(__out_first, __out_last);
+
+      return __random_sample(__first, __last,
+			     __out_first, __out_last - __out_first);
+    }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _InputIterator, typename _RandomAccessIterator,
+	   typename _RandomNumberGenerator>
+    inline _RandomAccessIterator
+    random_sample(_InputIterator __first, _InputIterator __last,
+		  _RandomAccessIterator __out_first,
+		  _RandomAccessIterator __out_last,
+		  _RandomNumberGenerator& __rand)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+	    _RandomAccessIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+      __glibcxx_requires_valid_range(__out_first, __out_last);
+
+      return __random_sample(__first, __last,
+			     __out_first, __rand,
+			     __out_last - __out_first);
+    }
+
+#if __cplusplus >= 201103L
+  using std::is_heap;
+#else
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _RandomAccessIterator>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__is_heap(__first, __last - __first);
+    }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _RandomAccessIterator, typename _StrictWeakOrdering>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	    _StrictWeakOrdering __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering,
+	    typename iterator_traits<_RandomAccessIterator>::value_type,
+	    typename iterator_traits<_RandomAccessIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      return std::__is_heap(__first, __comp, __last - __first);
+    }
+#endif
+
+#if __cplusplus >= 201103L
+  using std::is_sorted;
+#else
+  // is_sorted, a predicated testing whether a range is sorted in
+  // nondescending order.  This is an extension, not part of the C++
+  // standard.
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _ForwardIterator>
+    bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_LessThanComparableConcept<
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return true;
+
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, ++__next)
+	if (*__next < *__first)
+	  return false;
+      return true;
+    }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _ForwardIterator, typename _StrictWeakOrdering>
+    bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
+	      _StrictWeakOrdering __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering,
+	    typename iterator_traits<_ForwardIterator>::value_type,
+	    typename iterator_traits<_ForwardIterator>::value_type>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      if (__first == __last)
+	return true;
+
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, ++__next)
+	if (__comp(*__next, *__first))
+	  return false;
+      return true;
+    }
+#endif  // C++11
+
+  /**
+   *  @brief Find the median of three values.
+   *  @param  __a  A value.
+   *  @param  __b  A value.
+   *  @param  __c  A value.
+   *  @return One of @p a, @p b or @p c.
+   *
+   *  If @c {l,m,n} is some convolution of @p {a,b,c} such that @c l<=m<=n
+   *  then the value returned will be @c m.
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+  */
+  template<typename _Tp>
+    const _Tp&
+    __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
+      if (__a < __b)
+	if (__b < __c)
+	  return __b;
+	else if (__a < __c)
+	  return __c;
+	else
+	  return __a;
+      else if (__a < __c)
+	return __a;
+      else if (__b < __c)
+	return __c;
+      else
+	return __b;
+    }
+
+  /**
+   *  @brief Find the median of three values using a predicate for comparison.
+   *  @param  __a     A value.
+   *  @param  __b     A value.
+   *  @param  __c     A value.
+   *  @param  __comp  A binary predicate.
+   *  @return One of @p a, @p b or @p c.
+   *
+   *  If @c {l,m,n} is some convolution of @p {a,b,c} such that @p comp(l,m)
+   *  and @p comp(m,n) are both true then the value returned will be @c m.
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+  */
+  template<typename _Tp, typename _Compare>
+    const _Tp&
+    __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_BinaryFunctionConcept<_Compare, bool,
+				                         _Tp, _Tp>)
+      if (__comp(__a, __b))
+	if (__comp(__b, __c))
+	  return __b;
+	else if (__comp(__a, __c))
+	  return __c;
+	else
+	  return __a;
+      else if (__comp(__a, __c))
+	return __a;
+      else if (__comp(__b, __c))
+	return __c;
+      else
+	return __b;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _EXT_ALGORITHM */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/aligned_buffer.h b/gcc-4.9/libstdc++-v3/include/ext/aligned_buffer.h
new file mode 100644
index 0000000..861de5b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/aligned_buffer.h
@@ -0,0 +1,73 @@
+// Aligned memory buffer -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/aligned_buffer.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _ALIGNED_BUFFER_H
+#define _ALIGNED_BUFFER_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus >= 201103L
+# include <type_traits>
+#else
+# include <bits/c++0x_warning.h>
+#endif
+
+namespace __gnu_cxx
+{
+  template<typename _Tp>
+    struct __aligned_buffer
+    : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
+    {
+      typename
+	std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
+	_M_storage;
+
+      void*
+      _M_addr() noexcept
+      {
+        return static_cast<void*>(&_M_storage);
+      }
+
+      const void*
+      _M_addr() const noexcept
+      {
+        return static_cast<const void*>(&_M_storage);
+      }
+
+      _Tp*
+      _M_ptr() noexcept
+      { return static_cast<_Tp*>(_M_addr()); }
+
+      const _Tp*
+      _M_ptr() const noexcept
+      { return static_cast<const _Tp*>(_M_addr()); }
+    };
+
+} // namespace
+
+#endif /* _ALIGNED_BUFFER_H */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/alloc_traits.h b/gcc-4.9/libstdc++-v3/include/ext/alloc_traits.h
new file mode 100644
index 0000000..14fbc43
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/alloc_traits.h
@@ -0,0 +1,215 @@
+// Allocator traits -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/alloc_traits.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _EXT_ALLOC_TRAITS_H
+#define _EXT_ALLOC_TRAITS_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus >= 201103L
+# include <bits/move.h>
+# include <bits/alloc_traits.h>
+#else
+# include <bits/allocator.h>  // for __alloc_swap
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if __cplusplus >= 201103L
+  template<typename _Alloc>
+    struct __allocator_always_compares_equal : std::false_type { };
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<std::allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename, typename> struct array_allocator;
+
+  template<typename _Tp, typename _Array>
+    struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
+    : std::true_type { };
+
+  template<typename> struct bitmap_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<bitmap_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct malloc_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<malloc_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct mt_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<mt_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct new_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<new_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct pool_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<pool_allocator<_Tp>>
+    : std::true_type { };
+#endif
+
+/**
+ * @brief  Uniform interface to C++98 and C++0x allocators.
+ * @ingroup allocators
+*/
+template<typename _Alloc>
+  struct __alloc_traits
+#if __cplusplus >= 201103L
+  : std::allocator_traits<_Alloc>
+#endif
+  {
+    typedef _Alloc allocator_type;
+#if __cplusplus >= 201103L
+    typedef std::allocator_traits<_Alloc>           _Base_type;
+    typedef typename _Base_type::value_type         value_type;
+    typedef typename _Base_type::pointer            pointer;
+    typedef typename _Base_type::const_pointer      const_pointer;
+    typedef typename _Base_type::size_type          size_type;
+    typedef typename _Base_type::difference_type    difference_type;
+    // C++11 allocators do not define reference or const_reference
+    typedef value_type&                             reference;
+    typedef const value_type&                       const_reference;
+    using _Base_type::allocate;
+    using _Base_type::deallocate;
+    using _Base_type::construct;
+    using _Base_type::destroy;
+    using _Base_type::max_size;
+
+  private:
+    template<typename _Ptr>
+      using __is_custom_pointer
+	= std::__and_<std::is_same<pointer, _Ptr>,
+		      std::__not_<std::is_pointer<_Ptr>>>;
+
+  public:
+    // overload construct for non-standard pointer types
+    template<typename _Ptr, typename... _Args>
+      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
+      {
+	_Base_type::construct(__a, std::addressof(*__p),
+			      std::forward<_Args>(__args)...);
+      }
+
+    // overload destroy for non-standard pointer types
+    template<typename _Ptr>
+      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+      destroy(_Alloc& __a, _Ptr __p)
+      { _Base_type::destroy(__a, std::addressof(*__p)); }
+
+    static _Alloc _S_select_on_copy(const _Alloc& __a)
+    { return _Base_type::select_on_container_copy_construction(__a); }
+
+    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
+    { std::__alloc_on_swap(__a, __b); }
+
+    static constexpr bool _S_propagate_on_copy_assign()
+    { return _Base_type::propagate_on_container_copy_assignment::value; }
+
+    static constexpr bool _S_propagate_on_move_assign()
+    { return _Base_type::propagate_on_container_move_assignment::value; }
+
+    static constexpr bool _S_propagate_on_swap()
+    { return _Base_type::propagate_on_container_swap::value; }
+
+    static constexpr bool _S_always_equal()
+    { return __allocator_always_compares_equal<_Alloc>::value; }
+
+    static constexpr bool _S_nothrow_move()
+    { return _S_propagate_on_move_assign() || _S_always_equal(); }
+
+    static constexpr bool _S_nothrow_swap()
+    {
+      using std::swap;
+      return !_S_propagate_on_swap()
+       	|| noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>()));
+    }
+
+    template<typename _Tp>
+      struct rebind
+      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
+#else
+
+    typedef typename _Alloc::pointer                pointer;
+    typedef typename _Alloc::const_pointer          const_pointer;
+    typedef typename _Alloc::value_type             value_type;
+    typedef typename _Alloc::reference              reference;
+    typedef typename _Alloc::const_reference        const_reference;
+    typedef typename _Alloc::size_type              size_type;
+    typedef typename _Alloc::difference_type        difference_type;
+
+    static pointer
+    allocate(_Alloc& __a, size_type __n)
+    { return __a.allocate(__n); }
+
+    static void deallocate(_Alloc& __a, pointer __p, size_type __n)
+    { __a.deallocate(__p, __n); }
+
+    template<typename _Tp>
+      static void construct(_Alloc& __a, pointer __p, const _Tp& __arg)
+      { __a.construct(__p, __arg); }
+
+    static void destroy(_Alloc& __a, pointer __p)
+    { __a.destroy(__p); }
+
+    static size_type max_size(const _Alloc& __a)
+    { return __a.max_size(); }
+
+    static const _Alloc& _S_select_on_copy(const _Alloc& __a) { return __a; }
+
+    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 431. Swapping containers with unequal allocators.
+      std::__alloc_swap<_Alloc>::_S_do_it(__a, __b);
+    }
+
+    template<typename _Tp>
+      struct rebind
+      { typedef typename _Alloc::template rebind<_Tp>::other other; };
+#endif
+  };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/array_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/array_allocator.h
new file mode 100644
index 0000000..f807495
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/array_allocator.h
@@ -0,0 +1,174 @@
+// array allocator -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/array_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _ARRAY_ALLOCATOR_H
+#define _ARRAY_ALLOCATOR_H 1
+
+#include <bits/c++config.h>
+#include <new>
+#include <bits/functexcept.h>
+#include <tr1/array>
+#include <bits/move.h>
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ using std::size_t;
+ using std::ptrdiff_t;
+
+  /// Base class.
+ template<typename _Tp>
+    class array_allocator_base
+    {
+    public:
+      typedef size_t     	size_type;
+      typedef ptrdiff_t  	difference_type;
+      typedef _Tp*       	pointer;
+      typedef const _Tp* 	const_pointer;
+      typedef _Tp&       	reference;
+      typedef const _Tp&	const_reference;
+      typedef _Tp        	value_type;
+
+      pointer
+      address(reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      const_pointer
+      address(const_reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      void
+      deallocate(pointer, size_type)
+      { 
+	// Does nothing.
+      }
+
+      size_type
+      max_size() const _GLIBCXX_USE_NOEXCEPT 
+      { return size_t(-1) / sizeof(_Tp); }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p) { __p->~_Up(); }
+#else
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 402. wrong new expression in [some_] allocator::construct
+      void 
+      construct(pointer __p, const _Tp& __val) 
+      { ::new((void *)__p) value_type(__val); }
+
+      void 
+      destroy(pointer __p) { __p->~_Tp(); }
+#endif
+    } _GLIBCXX_DEPRECATED;
+
+  /**
+   *  @brief  An allocator that uses previously allocated memory.
+   *  This memory can be externally, globally, or otherwise allocated.
+   *  @ingroup allocators
+   */
+  template<typename _Tp, typename _Array = std::tr1::array<_Tp, 1> >
+    class array_allocator : public array_allocator_base<_Tp>
+    {
+    public:
+      typedef size_t     	size_type;
+      typedef ptrdiff_t  	difference_type;
+      typedef _Tp*       	pointer;
+      typedef const _Tp* 	const_pointer;
+      typedef _Tp&       	reference;
+      typedef const _Tp& 	const_reference;
+      typedef _Tp        	value_type;
+      typedef _Array		array_type;
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. std::allocator propagate_on_container_move_assignment
+      typedef std::true_type propagate_on_container_move_assignment;
+#endif
+
+    private:
+      array_type* 	_M_array;
+      size_type 	_M_used;
+
+    public:
+     template<typename _Tp1, typename _Array1 = _Array>
+        struct rebind
+        {
+	  typedef array_allocator<_Tp1, _Array1> other _GLIBCXX_DEPRECATED;
+	} _GLIBCXX_DEPRECATED;
+
+      array_allocator(array_type* __array = 0) _GLIBCXX_USE_NOEXCEPT 
+      : _M_array(__array), _M_used(size_type()) { }
+
+      array_allocator(const array_allocator& __o) _GLIBCXX_USE_NOEXCEPT 
+      : _M_array(__o._M_array), _M_used(__o._M_used) { }
+
+      template<typename _Tp1, typename _Array1>
+        array_allocator(const array_allocator<_Tp1, _Array1>&)
+	_GLIBCXX_USE_NOEXCEPT
+	: _M_array(0), _M_used(size_type()) { }
+
+      ~array_allocator() _GLIBCXX_USE_NOEXCEPT { }
+
+      pointer
+      allocate(size_type __n, const void* = 0)
+      {
+	if (_M_array == 0 || _M_used + __n > _M_array->size())
+	  std::__throw_bad_alloc();
+	pointer __ret = _M_array->begin() + _M_used;
+	_M_used += __n;
+	return __ret;
+      }
+    } _GLIBCXX_DEPRECATED;
+
+  template<typename _Tp, typename _Array>
+    inline bool
+    operator==(const array_allocator<_Tp, _Array>&,
+	       const array_allocator<_Tp, _Array>&)
+    { return true; }
+  
+  template<typename _Tp, typename _Array>
+    inline bool
+    operator!=(const array_allocator<_Tp, _Array>&, 
+	       const array_allocator<_Tp, _Array>&)
+    { return false; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/atomicity.h b/gcc-4.9/libstdc++-v3/include/ext/atomicity.h
new file mode 100644
index 0000000..bada709
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/atomicity.h
@@ -0,0 +1,117 @@
+// Support for atomic operations -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/atomicity.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_ATOMICITY_H
+#define _GLIBCXX_ATOMICITY_H	1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/gthr.h>
+#include <bits/atomic_word.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Functions for portable atomic access.
+  // To abstract locking primitives across all thread policies, use:
+  // __exchange_and_add_dispatch
+  // __atomic_add_dispatch
+#ifdef _GLIBCXX_ATOMIC_BUILTINS
+  static inline _Atomic_word 
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL); }
+
+  static inline void
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL); }
+#else
+  _Atomic_word
+  __attribute__ ((__unused__))
+  __exchange_and_add(volatile _Atomic_word*, int) throw ();
+
+  void
+  __attribute__ ((__unused__))
+  __atomic_add(volatile _Atomic_word*, int) throw ();
+#endif
+
+  static inline _Atomic_word
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+
+  static inline void
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+
+  static inline _Atomic_word
+  __attribute__ ((__unused__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+#ifdef __GTHREADS
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+    else
+      return __exchange_and_add_single(__mem, __val);
+#else
+    return __exchange_and_add_single(__mem, __val);
+#endif
+  }
+
+  static inline void
+  __attribute__ ((__unused__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+#ifdef __GTHREADS
+    if (__gthread_active_p())
+      __atomic_add(__mem, __val);
+    else
+      __atomic_add_single(__mem, __val);
+#else
+    __atomic_add_single(__mem, __val);
+#endif
+  }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+// Even if the CPU doesn't need a memory barrier, we need to ensure
+// that the compiler doesn't reorder memory accesses across the
+// barriers.
+#ifndef _GLIBCXX_READ_MEM_BARRIER
+#define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory")
+#endif
+#ifndef _GLIBCXX_WRITE_MEM_BARRIER
+#define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory")
+#endif
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/bitmap_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/bitmap_allocator.h
new file mode 100644
index 0000000..2bfbbf5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/bitmap_allocator.h
@@ -0,0 +1,1119 @@
+// Bitmap Allocator. -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/bitmap_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _BITMAP_ALLOCATOR_H
+#define _BITMAP_ALLOCATOR_H 1
+
+#include <utility> // For std::pair.
+#include <bits/functexcept.h> // For __throw_bad_alloc().
+#include <functional> // For greater_equal, and less_equal.
+#include <new> // For operator new.
+#include <debug/debug.h> // _GLIBCXX_DEBUG_ASSERT
+#include <ext/concurrence.h>
+#include <bits/move.h>
+
+/** @brief The constant in the expression below is the alignment
+ * required in bytes.
+ */
+#define _BALLOC_ALIGN_BYTES 8
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+  using std::size_t;
+  using std::ptrdiff_t;
+
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+    /** @class  __mini_vector bitmap_allocator.h bitmap_allocator.h
+     *
+     *  @brief  __mini_vector<> is a stripped down version of the
+     *  full-fledged std::vector<>.
+     *
+     *  It is to be used only for built-in types or PODs. Notable
+     *  differences are:
+     * 
+     *  1. Not all accessor functions are present.
+     *  2. Used ONLY for PODs.
+     *  3. No Allocator template argument. Uses ::operator new() to get
+     *  memory, and ::operator delete() to free it.
+     *  Caveat: The dtor does NOT free the memory allocated, so this a
+     *  memory-leaking vector!
+     */
+    template<typename _Tp>
+      class __mini_vector
+      {
+	__mini_vector(const __mini_vector&);
+	__mini_vector& operator=(const __mini_vector&);
+
+      public:
+	typedef _Tp value_type;
+	typedef _Tp* pointer;
+	typedef _Tp& reference;
+	typedef const _Tp& const_reference;
+	typedef size_t size_type;
+	typedef ptrdiff_t difference_type;
+	typedef pointer iterator;
+
+      private:
+	pointer _M_start;
+	pointer _M_finish;
+	pointer _M_end_of_storage;
+
+	size_type
+	_M_space_left() const throw()
+	{ return _M_end_of_storage - _M_finish; }
+
+	pointer
+	allocate(size_type __n)
+	{ return static_cast<pointer>(::operator new(__n * sizeof(_Tp))); }
+
+	void
+	deallocate(pointer __p, size_type)
+	{ ::operator delete(__p); }
+
+      public:
+	// Members used: size(), push_back(), pop_back(),
+	// insert(iterator, const_reference), erase(iterator),
+	// begin(), end(), back(), operator[].
+
+	__mini_vector()
+        : _M_start(0), _M_finish(0), _M_end_of_storage(0) { }
+
+	size_type
+	size() const throw()
+	{ return _M_finish - _M_start; }
+
+	iterator
+	begin() const throw()
+	{ return this->_M_start; }
+
+	iterator
+	end() const throw()
+	{ return this->_M_finish; }
+
+	reference
+	back() const throw()
+	{ return *(this->end() - 1); }
+
+	reference
+	operator[](const size_type __pos) const throw()
+	{ return this->_M_start[__pos]; }
+
+	void
+	insert(iterator __pos, const_reference __x);
+
+	void
+	push_back(const_reference __x)
+	{
+	  if (this->_M_space_left())
+	    {
+	      *this->end() = __x;
+	      ++this->_M_finish;
+	    }
+	  else
+	    this->insert(this->end(), __x);
+	}
+
+	void
+	pop_back() throw()
+	{ --this->_M_finish; }
+
+	void
+	erase(iterator __pos) throw();
+
+	void
+	clear() throw()
+	{ this->_M_finish = this->_M_start; }
+      };
+
+    // Out of line function definitions.
+    template<typename _Tp>
+      void __mini_vector<_Tp>::
+      insert(iterator __pos, const_reference __x)
+      {
+	if (this->_M_space_left())
+	  {
+	    size_type __to_move = this->_M_finish - __pos;
+	    iterator __dest = this->end();
+	    iterator __src = this->end() - 1;
+
+	    ++this->_M_finish;
+	    while (__to_move)
+	      {
+		*__dest = *__src;
+		--__dest; --__src; --__to_move;
+	      }
+	    *__pos = __x;
+	  }
+	else
+	  {
+	    size_type __new_size = this->size() ? this->size() * 2 : 1;
+	    iterator __new_start = this->allocate(__new_size);
+	    iterator __first = this->begin();
+	    iterator __start = __new_start;
+	    while (__first != __pos)
+	      {
+		*__start = *__first;
+		++__start; ++__first;
+	      }
+	    *__start = __x;
+	    ++__start;
+	    while (__first != this->end())
+	      {
+		*__start = *__first;
+		++__start; ++__first;
+	      }
+	    if (this->_M_start)
+	      this->deallocate(this->_M_start, this->size());
+
+	    this->_M_start = __new_start;
+	    this->_M_finish = __start;
+	    this->_M_end_of_storage = this->_M_start + __new_size;
+	  }
+      }
+
+    template<typename _Tp>
+      void __mini_vector<_Tp>::
+      erase(iterator __pos) throw()
+      {
+	while (__pos + 1 != this->end())
+	  {
+	    *__pos = __pos[1];
+	    ++__pos;
+	  }
+	--this->_M_finish;
+      }
+
+
+    template<typename _Tp>
+      struct __mv_iter_traits
+      {
+	typedef typename _Tp::value_type value_type;
+	typedef typename _Tp::difference_type difference_type;
+      };
+
+    template<typename _Tp>
+      struct __mv_iter_traits<_Tp*>
+      {
+	typedef _Tp value_type;
+	typedef ptrdiff_t difference_type;
+      };
+
+    enum 
+      { 
+	bits_per_byte = 8,
+	bits_per_block = sizeof(size_t) * size_t(bits_per_byte) 
+      };
+
+    template<typename _ForwardIterator, typename _Tp, typename _Compare>
+      _ForwardIterator
+      __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+		    const _Tp& __val, _Compare __comp)
+      {
+	typedef typename __mv_iter_traits<_ForwardIterator>::difference_type
+	  _DistanceType;
+
+	_DistanceType __len = __last - __first;
+	_DistanceType __half;
+	_ForwardIterator __middle;
+
+	while (__len > 0)
+	  {
+	    __half = __len >> 1;
+	    __middle = __first;
+	    __middle += __half;
+	    if (__comp(*__middle, __val))
+	      {
+		__first = __middle;
+		++__first;
+		__len = __len - __half - 1;
+	      }
+	    else
+	      __len = __half;
+	  }
+	return __first;
+      }
+
+    /** @brief The number of Blocks pointed to by the address pair
+     *  passed to the function.
+     */
+    template<typename _AddrPair>
+      inline size_t
+      __num_blocks(_AddrPair __ap)
+      { return (__ap.second - __ap.first) + 1; }
+
+    /** @brief The number of Bit-maps pointed to by the address pair
+     *  passed to the function.
+     */
+    template<typename _AddrPair>
+      inline size_t
+      __num_bitmaps(_AddrPair __ap)
+      { return __num_blocks(__ap) / size_t(bits_per_block); }
+
+    // _Tp should be a pointer type.
+    template<typename _Tp>
+      class _Inclusive_between 
+      : public std::unary_function<typename std::pair<_Tp, _Tp>, bool>
+      {
+	typedef _Tp pointer;
+	pointer _M_ptr_value;
+	typedef typename std::pair<_Tp, _Tp> _Block_pair;
+	
+      public:
+	_Inclusive_between(pointer __ptr) : _M_ptr_value(__ptr) 
+	{ }
+	
+	bool 
+	operator()(_Block_pair __bp) const throw()
+	{
+	  if (std::less_equal<pointer>()(_M_ptr_value, __bp.second) 
+	      && std::greater_equal<pointer>()(_M_ptr_value, __bp.first))
+	    return true;
+	  else
+	    return false;
+	}
+      };
+  
+    // Used to pass a Functor to functions by reference.
+    template<typename _Functor>
+      class _Functor_Ref 
+      : public std::unary_function<typename _Functor::argument_type, 
+				   typename _Functor::result_type>
+      {
+	_Functor& _M_fref;
+	
+      public:
+	typedef typename _Functor::argument_type argument_type;
+	typedef typename _Functor::result_type result_type;
+
+	_Functor_Ref(_Functor& __fref) : _M_fref(__fref) 
+	{ }
+
+	result_type 
+	operator()(argument_type __arg) 
+	{ return _M_fref(__arg); }
+      };
+
+    /** @class  _Ffit_finder bitmap_allocator.h bitmap_allocator.h
+     *
+     *  @brief  The class which acts as a predicate for applying the
+     *  first-fit memory allocation policy for the bitmap allocator.
+     */
+    // _Tp should be a pointer type, and _Alloc is the Allocator for
+    // the vector.
+    template<typename _Tp>
+      class _Ffit_finder 
+      : public std::unary_function<typename std::pair<_Tp, _Tp>, bool>
+      {
+	typedef typename std::pair<_Tp, _Tp> _Block_pair;
+	typedef typename __detail::__mini_vector<_Block_pair> _BPVector;
+	typedef typename _BPVector::difference_type _Counter_type;
+
+	size_t* _M_pbitmap;
+	_Counter_type _M_data_offset;
+
+      public:
+	_Ffit_finder() : _M_pbitmap(0), _M_data_offset(0)
+	{ }
+
+	bool 
+	operator()(_Block_pair __bp) throw()
+	{
+	  // Set the _rover to the last physical location bitmap,
+	  // which is the bitmap which belongs to the first free
+	  // block. Thus, the bitmaps are in exact reverse order of
+	  // the actual memory layout. So, we count down the bitmaps,
+	  // which is the same as moving up the memory.
+
+	  // If the used count stored at the start of the Bit Map headers
+	  // is equal to the number of Objects that the current Block can
+	  // store, then there is definitely no space for another single
+	  // object, so just return false.
+	  _Counter_type __diff = __detail::__num_bitmaps(__bp);
+
+	  if (*(reinterpret_cast<size_t*>
+		(__bp.first) - (__diff + 1)) == __detail::__num_blocks(__bp))
+	    return false;
+
+	  size_t* __rover = reinterpret_cast<size_t*>(__bp.first) - 1;
+
+	  for (_Counter_type __i = 0; __i < __diff; ++__i)
+	    {
+	      _M_data_offset = __i;
+	      if (*__rover)
+		{
+		  _M_pbitmap = __rover;
+		  return true;
+		}
+	      --__rover;
+	    }
+	  return false;
+	}
+    
+	size_t*
+	_M_get() const throw()
+	{ return _M_pbitmap; }
+
+	_Counter_type
+	_M_offset() const throw()
+	{ return _M_data_offset * size_t(bits_per_block); }
+      };
+
+    /** @class  _Bitmap_counter bitmap_allocator.h bitmap_allocator.h
+     *
+     *  @brief  The bitmap counter which acts as the bitmap
+     *  manipulator, and manages the bit-manipulation functions and
+     *  the searching and identification functions on the bit-map.
+     */
+    // _Tp should be a pointer type.
+    template<typename _Tp>
+      class _Bitmap_counter
+      {
+	typedef typename
+	__detail::__mini_vector<typename std::pair<_Tp, _Tp> > _BPVector;
+	typedef typename _BPVector::size_type _Index_type;
+	typedef _Tp pointer;
+
+	_BPVector& _M_vbp;
+	size_t* _M_curr_bmap;
+	size_t* _M_last_bmap_in_block;
+	_Index_type _M_curr_index;
+    
+      public:
+	// Use the 2nd parameter with care. Make sure that such an
+	// entry exists in the vector before passing that particular
+	// index to this ctor.
+	_Bitmap_counter(_BPVector& Rvbp, long __index = -1) : _M_vbp(Rvbp)
+	{ this->_M_reset(__index); }
+    
+	void 
+	_M_reset(long __index = -1) throw()
+	{
+	  if (__index == -1)
+	    {
+	      _M_curr_bmap = 0;
+	      _M_curr_index = static_cast<_Index_type>(-1);
+	      return;
+	    }
+
+	  _M_curr_index = __index;
+	  _M_curr_bmap = reinterpret_cast<size_t*>
+	    (_M_vbp[_M_curr_index].first) - 1;
+	  
+	  _GLIBCXX_DEBUG_ASSERT(__index <= (long)_M_vbp.size() - 1);
+	
+	  _M_last_bmap_in_block = _M_curr_bmap
+	    - ((_M_vbp[_M_curr_index].second 
+		- _M_vbp[_M_curr_index].first + 1) 
+	       / size_t(bits_per_block) - 1);
+	}
+    
+	// Dangerous Function! Use with extreme care. Pass to this
+	// function ONLY those values that are known to be correct,
+	// otherwise this will mess up big time.
+	void
+	_M_set_internal_bitmap(size_t* __new_internal_marker) throw()
+	{ _M_curr_bmap = __new_internal_marker; }
+    
+	bool
+	_M_finished() const throw()
+	{ return(_M_curr_bmap == 0); }
+    
+	_Bitmap_counter&
+	operator++() throw()
+	{
+	  if (_M_curr_bmap == _M_last_bmap_in_block)
+	    {
+	      if (++_M_curr_index == _M_vbp.size())
+		_M_curr_bmap = 0;
+	      else
+		this->_M_reset(_M_curr_index);
+	    }
+	  else
+	    --_M_curr_bmap;
+	  return *this;
+	}
+    
+	size_t*
+	_M_get() const throw()
+	{ return _M_curr_bmap; }
+    
+	pointer 
+	_M_base() const throw()
+	{ return _M_vbp[_M_curr_index].first; }
+
+	_Index_type
+	_M_offset() const throw()
+	{
+	  return size_t(bits_per_block)
+	    * ((reinterpret_cast<size_t*>(this->_M_base()) 
+		- _M_curr_bmap) - 1);
+	}
+    
+	_Index_type
+	_M_where() const throw()
+	{ return _M_curr_index; }
+      };
+
+    /** @brief  Mark a memory address as allocated by re-setting the
+     *  corresponding bit in the bit-map.
+     */
+    inline void 
+    __bit_allocate(size_t* __pbmap, size_t __pos) throw()
+    {
+      size_t __mask = 1 << __pos;
+      __mask = ~__mask;
+      *__pbmap &= __mask;
+    }
+  
+    /** @brief  Mark a memory address as free by setting the
+     *  corresponding bit in the bit-map.
+     */
+    inline void 
+    __bit_free(size_t* __pbmap, size_t __pos) throw()
+    {
+      size_t __mask = 1 << __pos;
+      *__pbmap |= __mask;
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace __detail
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /** @brief  Generic Version of the bsf instruction.
+   */
+  inline size_t 
+  _Bit_scan_forward(size_t __num)
+  { return static_cast<size_t>(__builtin_ctzl(__num)); }
+
+  /** @class  free_list bitmap_allocator.h bitmap_allocator.h
+   *
+   *  @brief  The free list class for managing chunks of memory to be
+   *  given to and returned by the bitmap_allocator.
+   */
+  class free_list
+  {
+  public:
+    typedef size_t* 				value_type;
+    typedef __detail::__mini_vector<value_type> vector_type;
+    typedef vector_type::iterator 		iterator;
+    typedef __mutex				__mutex_type;
+
+  private:
+    struct _LT_pointer_compare
+    {
+      bool
+      operator()(const size_t* __pui, 
+		 const size_t __cui) const throw()
+      { return *__pui < __cui; }
+    };
+
+#if defined __GTHREADS
+    __mutex_type&
+    _M_get_mutex()
+    {
+      static __mutex_type _S_mutex;
+      return _S_mutex;
+    }
+#endif
+
+    vector_type&
+    _M_get_free_list()
+    {
+      static vector_type _S_free_list;
+      return _S_free_list;
+    }
+
+    /** @brief  Performs validation of memory based on their size.
+     *
+     *  @param  __addr The pointer to the memory block to be
+     *  validated.
+     *
+     *  Validates the memory block passed to this function and
+     *  appropriately performs the action of managing the free list of
+     *  blocks by adding this block to the free list or deleting this
+     *  or larger blocks from the free list.
+     */
+    void
+    _M_validate(size_t* __addr) throw()
+    {
+      vector_type& __free_list = _M_get_free_list();
+      const vector_type::size_type __max_size = 64;
+      if (__free_list.size() >= __max_size)
+	{
+	  // Ok, the threshold value has been reached.  We determine
+	  // which block to remove from the list of free blocks.
+	  if (*__addr >= *__free_list.back())
+	    {
+	      // Ok, the new block is greater than or equal to the
+	      // last block in the list of free blocks. We just free
+	      // the new block.
+	      ::operator delete(static_cast<void*>(__addr));
+	      return;
+	    }
+	  else
+	    {
+	      // Deallocate the last block in the list of free lists,
+	      // and insert the new one in its correct position.
+	      ::operator delete(static_cast<void*>(__free_list.back()));
+	      __free_list.pop_back();
+	    }
+	}
+	  
+      // Just add the block to the list of free lists unconditionally.
+      iterator __temp = __detail::__lower_bound
+	(__free_list.begin(), __free_list.end(), 
+	 *__addr, _LT_pointer_compare());
+
+      // We may insert the new free list before _temp;
+      __free_list.insert(__temp, __addr);
+    }
+
+    /** @brief  Decides whether the wastage of memory is acceptable for
+     *  the current memory request and returns accordingly.
+     *
+     *  @param __block_size The size of the block available in the free
+     *  list.
+     *
+     *  @param __required_size The required size of the memory block.
+     *
+     *  @return true if the wastage incurred is acceptable, else returns
+     *  false.
+     */
+    bool 
+    _M_should_i_give(size_t __block_size, 
+		     size_t __required_size) throw()
+    {
+      const size_t __max_wastage_percentage = 36;
+      if (__block_size >= __required_size && 
+	  (((__block_size - __required_size) * 100 / __block_size)
+	   < __max_wastage_percentage))
+	return true;
+      else
+	return false;
+    }
+
+  public:
+    /** @brief This function returns the block of memory to the
+     *  internal free list.
+     *
+     *  @param  __addr The pointer to the memory block that was given
+     *  by a call to the _M_get function.
+     */
+    inline void 
+    _M_insert(size_t* __addr) throw()
+    {
+#if defined __GTHREADS
+      __scoped_lock __bfl_lock(_M_get_mutex());
+#endif
+      // Call _M_validate to decide what should be done with
+      // this particular free list.
+      this->_M_validate(reinterpret_cast<size_t*>(__addr) - 1);
+      // See discussion as to why this is 1!
+    }
+    
+    /** @brief  This function gets a block of memory of the specified
+     *  size from the free list.
+     *
+     *  @param  __sz The size in bytes of the memory required.
+     *
+     *  @return  A pointer to the new memory block of size at least
+     *  equal to that requested.
+     */
+    size_t*
+    _M_get(size_t __sz) throw(std::bad_alloc);
+
+    /** @brief  This function just clears the internal Free List, and
+     *  gives back all the memory to the OS.
+     */
+    void 
+    _M_clear();
+  };
+
+
+  // Forward declare the class.
+  template<typename _Tp> 
+    class bitmap_allocator;
+
+  // Specialize for void:
+  template<>
+    class bitmap_allocator<void>
+    {
+    public:
+      typedef void*       pointer;
+      typedef const void* const_pointer;
+
+      // Reference-to-void members are impossible.
+      typedef void  value_type;
+      template<typename _Tp1>
+        struct rebind
+	{
+	  typedef bitmap_allocator<_Tp1> other;
+	};
+    };
+
+  /**
+   * @brief Bitmap Allocator, primary template.
+   * @ingroup allocators
+   */
+  template<typename _Tp>
+    class bitmap_allocator : private free_list
+    {
+    public:
+      typedef size_t    		size_type;
+      typedef ptrdiff_t 		difference_type;
+      typedef _Tp*        		pointer;
+      typedef const _Tp*  		const_pointer;
+      typedef _Tp&        		reference;
+      typedef const _Tp&  		const_reference;
+      typedef _Tp         		value_type;
+      typedef free_list::__mutex_type 	__mutex_type;
+
+      template<typename _Tp1>
+        struct rebind
+	{
+	  typedef bitmap_allocator<_Tp1> other;
+	};
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. propagate_on_container_move_assignment
+      typedef std::true_type propagate_on_container_move_assignment;
+#endif
+
+    private:
+      template<size_t _BSize, size_t _AlignSize>
+        struct aligned_size
+	{
+	  enum
+	    { 
+	      modulus = _BSize % _AlignSize,
+	      value = _BSize + (modulus ? _AlignSize - (modulus) : 0)
+	    };
+	};
+
+      struct _Alloc_block
+      {
+	char __M_unused[aligned_size<sizeof(value_type),
+			_BALLOC_ALIGN_BYTES>::value];
+      };
+
+
+      typedef typename std::pair<_Alloc_block*, _Alloc_block*> _Block_pair;
+
+      typedef typename __detail::__mini_vector<_Block_pair> _BPVector;
+      typedef typename _BPVector::iterator _BPiter;
+
+      template<typename _Predicate>
+        static _BPiter
+        _S_find(_Predicate __p)
+        {
+	  _BPiter __first = _S_mem_blocks.begin();
+	  while (__first != _S_mem_blocks.end() && !__p(*__first))
+	    ++__first;
+	  return __first;
+	}
+
+#if defined _GLIBCXX_DEBUG
+      // Complexity: O(lg(N)). Where, N is the number of block of size
+      // sizeof(value_type).
+      void 
+      _S_check_for_free_blocks() throw()
+      {
+	typedef typename __detail::_Ffit_finder<_Alloc_block*> _FFF;
+	_BPiter __bpi = _S_find(_FFF());
+
+	_GLIBCXX_DEBUG_ASSERT(__bpi == _S_mem_blocks.end());
+      }
+#endif
+
+      /** @brief  Responsible for exponentially growing the internal
+       *  memory pool.
+       *
+       *  @throw  std::bad_alloc. If memory can not be allocated.
+       *
+       *  Complexity: O(1), but internally depends upon the
+       *  complexity of the function free_list::_M_get. The part where
+       *  the bitmap headers are written has complexity: O(X),where X
+       *  is the number of blocks of size sizeof(value_type) within
+       *  the newly acquired block. Having a tight bound.
+       */
+      void 
+      _S_refill_pool() throw(std::bad_alloc)
+      {
+#if defined _GLIBCXX_DEBUG
+	_S_check_for_free_blocks();
+#endif
+
+	const size_t __num_bitmaps = (_S_block_size
+				      / size_t(__detail::bits_per_block));
+	const size_t __size_to_allocate = sizeof(size_t) 
+	  + _S_block_size * sizeof(_Alloc_block) 
+	  + __num_bitmaps * sizeof(size_t);
+
+	size_t* __temp =
+	  reinterpret_cast<size_t*>(this->_M_get(__size_to_allocate));
+	*__temp = 0;
+	++__temp;
+
+	// The Header information goes at the Beginning of the Block.
+	_Block_pair __bp = 
+	  std::make_pair(reinterpret_cast<_Alloc_block*>
+			 (__temp + __num_bitmaps), 
+			 reinterpret_cast<_Alloc_block*>
+			 (__temp + __num_bitmaps) 
+			 + _S_block_size - 1);
+	
+	// Fill the Vector with this information.
+	_S_mem_blocks.push_back(__bp);
+
+	for (size_t __i = 0; __i < __num_bitmaps; ++__i)
+	  __temp[__i] = ~static_cast<size_t>(0); // 1 Indicates all Free.
+
+	_S_block_size *= 2;
+      }
+
+      static _BPVector _S_mem_blocks;
+      static size_t _S_block_size;
+      static __detail::_Bitmap_counter<_Alloc_block*> _S_last_request;
+      static typename _BPVector::size_type _S_last_dealloc_index;
+#if defined __GTHREADS
+      static __mutex_type _S_mut;
+#endif
+
+    public:
+
+      /** @brief  Allocates memory for a single object of size
+       *  sizeof(_Tp).
+       *
+       *  @throw  std::bad_alloc. If memory can not be allocated.
+       *
+       *  Complexity: Worst case complexity is O(N), but that
+       *  is hardly ever hit. If and when this particular case is
+       *  encountered, the next few cases are guaranteed to have a
+       *  worst case complexity of O(1)!  That's why this function
+       *  performs very well on average. You can consider this
+       *  function to have a complexity referred to commonly as:
+       *  Amortized Constant time.
+       */
+      pointer 
+      _M_allocate_single_object() throw(std::bad_alloc)
+      {
+#if defined __GTHREADS
+	__scoped_lock __bit_lock(_S_mut);
+#endif
+
+	// The algorithm is something like this: The last_request
+	// variable points to the last accessed Bit Map. When such a
+	// condition occurs, we try to find a free block in the
+	// current bitmap, or succeeding bitmaps until the last bitmap
+	// is reached. If no free block turns up, we resort to First
+	// Fit method.
+
+	// WARNING: Do not re-order the condition in the while
+	// statement below, because it relies on C++'s short-circuit
+	// evaluation. The return from _S_last_request->_M_get() will
+	// NOT be dereference able if _S_last_request->_M_finished()
+	// returns true. This would inevitably lead to a NULL pointer
+	// dereference if tinkered with.
+	while (_S_last_request._M_finished() == false
+	       && (*(_S_last_request._M_get()) == 0))
+	  _S_last_request.operator++();
+
+	if (__builtin_expect(_S_last_request._M_finished() == true, false))
+	  {
+	    // Fall Back to First Fit algorithm.
+	    typedef typename __detail::_Ffit_finder<_Alloc_block*> _FFF;
+	    _FFF __fff;
+	    _BPiter __bpi = _S_find(__detail::_Functor_Ref<_FFF>(__fff));
+
+	    if (__bpi != _S_mem_blocks.end())
+	      {
+		// Search was successful. Ok, now mark the first bit from
+		// the right as 0, meaning Allocated. This bit is obtained
+		// by calling _M_get() on __fff.
+		size_t __nz_bit = _Bit_scan_forward(*__fff._M_get());
+		__detail::__bit_allocate(__fff._M_get(), __nz_bit);
+
+		_S_last_request._M_reset(__bpi - _S_mem_blocks.begin());
+
+		// Now, get the address of the bit we marked as allocated.
+		pointer __ret = reinterpret_cast<pointer>
+		  (__bpi->first + __fff._M_offset() + __nz_bit);
+		size_t* __puse_count = 
+		  reinterpret_cast<size_t*>
+		  (__bpi->first) - (__detail::__num_bitmaps(*__bpi) + 1);
+		
+		++(*__puse_count);
+		return __ret;
+	      }
+	    else
+	      {
+		// Search was unsuccessful. We Add more memory to the
+		// pool by calling _S_refill_pool().
+		_S_refill_pool();
+
+		// _M_Reset the _S_last_request structure to the first
+		// free block's bit map.
+		_S_last_request._M_reset(_S_mem_blocks.size() - 1);
+
+		// Now, mark that bit as allocated.
+	      }
+	  }
+
+	// _S_last_request holds a pointer to a valid bit map, that
+	// points to a free block in memory.
+	size_t __nz_bit = _Bit_scan_forward(*_S_last_request._M_get());
+	__detail::__bit_allocate(_S_last_request._M_get(), __nz_bit);
+
+	pointer __ret = reinterpret_cast<pointer>
+	  (_S_last_request._M_base() + _S_last_request._M_offset() + __nz_bit);
+
+	size_t* __puse_count = reinterpret_cast<size_t*>
+	  (_S_mem_blocks[_S_last_request._M_where()].first)
+	  - (__detail::
+	     __num_bitmaps(_S_mem_blocks[_S_last_request._M_where()]) + 1);
+
+	++(*__puse_count);
+	return __ret;
+      }
+
+      /** @brief  Deallocates memory that belongs to a single object of
+       *  size sizeof(_Tp).
+       *
+       *  Complexity: O(lg(N)), but the worst case is not hit
+       *  often!  This is because containers usually deallocate memory
+       *  close to each other and this case is handled in O(1) time by
+       *  the deallocate function.
+       */
+      void 
+      _M_deallocate_single_object(pointer __p) throw()
+      {
+#if defined __GTHREADS
+	__scoped_lock __bit_lock(_S_mut);
+#endif
+	_Alloc_block* __real_p = reinterpret_cast<_Alloc_block*>(__p);
+
+	typedef typename _BPVector::iterator _Iterator;
+	typedef typename _BPVector::difference_type _Difference_type;
+
+	_Difference_type __diff;
+	long __displacement;
+
+	_GLIBCXX_DEBUG_ASSERT(_S_last_dealloc_index >= 0);
+
+	__detail::_Inclusive_between<_Alloc_block*> __ibt(__real_p);
+	if (__ibt(_S_mem_blocks[_S_last_dealloc_index]))
+	  {
+	    _GLIBCXX_DEBUG_ASSERT(_S_last_dealloc_index
+				  <= _S_mem_blocks.size() - 1);
+
+	    // Initial Assumption was correct!
+	    __diff = _S_last_dealloc_index;
+	    __displacement = __real_p - _S_mem_blocks[__diff].first;
+	  }
+	else
+	  {
+	    _Iterator _iter = _S_find(__ibt);
+
+	    _GLIBCXX_DEBUG_ASSERT(_iter != _S_mem_blocks.end());
+
+	    __diff = _iter - _S_mem_blocks.begin();
+	    __displacement = __real_p - _S_mem_blocks[__diff].first;
+	    _S_last_dealloc_index = __diff;
+	  }
+
+	// Get the position of the iterator that has been found.
+	const size_t __rotate = (__displacement
+				 % size_t(__detail::bits_per_block));
+	size_t* __bitmapC = 
+	  reinterpret_cast<size_t*>
+	  (_S_mem_blocks[__diff].first) - 1;
+	__bitmapC -= (__displacement / size_t(__detail::bits_per_block));
+      
+	__detail::__bit_free(__bitmapC, __rotate);
+	size_t* __puse_count = reinterpret_cast<size_t*>
+	  (_S_mem_blocks[__diff].first)
+	  - (__detail::__num_bitmaps(_S_mem_blocks[__diff]) + 1);
+	
+	_GLIBCXX_DEBUG_ASSERT(*__puse_count != 0);
+
+	--(*__puse_count);
+
+	if (__builtin_expect(*__puse_count == 0, false))
+	  {
+	    _S_block_size /= 2;
+	  
+	    // We can safely remove this block.
+	    // _Block_pair __bp = _S_mem_blocks[__diff];
+	    this->_M_insert(__puse_count);
+	    _S_mem_blocks.erase(_S_mem_blocks.begin() + __diff);
+
+	    // Reset the _S_last_request variable to reflect the
+	    // erased block. We do this to protect future requests
+	    // after the last block has been removed from a particular
+	    // memory Chunk, which in turn has been returned to the
+	    // free list, and hence had been erased from the vector,
+	    // so the size of the vector gets reduced by 1.
+	    if ((_Difference_type)_S_last_request._M_where() >= __diff--)
+	      _S_last_request._M_reset(__diff); 
+
+	    // If the Index into the vector of the region of memory
+	    // that might hold the next address that will be passed to
+	    // deallocated may have been invalidated due to the above
+	    // erase procedure being called on the vector, hence we
+	    // try to restore this invariant too.
+	    if (_S_last_dealloc_index >= _S_mem_blocks.size())
+	      {
+		_S_last_dealloc_index =(__diff != -1 ? __diff : 0);
+		_GLIBCXX_DEBUG_ASSERT(_S_last_dealloc_index >= 0);
+	      }
+	  }
+      }
+
+    public:
+      bitmap_allocator() _GLIBCXX_USE_NOEXCEPT
+      { }
+
+      bitmap_allocator(const bitmap_allocator&) _GLIBCXX_USE_NOEXCEPT
+      { }
+
+      template<typename _Tp1>
+        bitmap_allocator(const bitmap_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT
+        { }
+
+      ~bitmap_allocator() _GLIBCXX_USE_NOEXCEPT
+      { }
+
+      pointer 
+      allocate(size_type __n)
+      {
+	if (__n > this->max_size())
+	  std::__throw_bad_alloc();
+
+	if (__builtin_expect(__n == 1, true))
+	  return this->_M_allocate_single_object();
+	else
+	  { 
+	    const size_type __b = __n * sizeof(value_type);
+	    return reinterpret_cast<pointer>(::operator new(__b));
+	  }
+      }
+
+      pointer 
+      allocate(size_type __n, typename bitmap_allocator<void>::const_pointer)
+      { return allocate(__n); }
+
+      void 
+      deallocate(pointer __p, size_type __n) throw()
+      {
+	if (__builtin_expect(__p != 0, true))
+	  {
+	    if (__builtin_expect(__n == 1, true))
+	      this->_M_deallocate_single_object(__p);
+	    else
+	      ::operator delete(__p);
+	  }
+      }
+
+      pointer 
+      address(reference __r) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__r); }
+
+      const_pointer 
+      address(const_reference __r) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__r); }
+
+      size_type 
+      max_size() const _GLIBCXX_USE_NOEXCEPT
+      { return size_type(-1) / sizeof(value_type); }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p)
+        { __p->~_Up(); }
+#else
+      void 
+      construct(pointer __p, const_reference __data)
+      { ::new((void *)__p) value_type(__data); }
+
+      void 
+      destroy(pointer __p)
+      { __p->~value_type(); }
+#endif
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    bool 
+    operator==(const bitmap_allocator<_Tp1>&, 
+	       const bitmap_allocator<_Tp2>&) throw()
+    { return true; }
+  
+  template<typename _Tp1, typename _Tp2>
+    bool 
+    operator!=(const bitmap_allocator<_Tp1>&, 
+	       const bitmap_allocator<_Tp2>&) throw() 
+  { return false; }
+
+  // Static member definitions.
+  template<typename _Tp>
+    typename bitmap_allocator<_Tp>::_BPVector
+    bitmap_allocator<_Tp>::_S_mem_blocks;
+
+  template<typename _Tp>
+    size_t bitmap_allocator<_Tp>::_S_block_size = 
+    2 * size_t(__detail::bits_per_block);
+
+  template<typename _Tp>
+    typename bitmap_allocator<_Tp>::_BPVector::size_type 
+    bitmap_allocator<_Tp>::_S_last_dealloc_index = 0;
+
+  template<typename _Tp>
+    __detail::_Bitmap_counter
+      <typename bitmap_allocator<_Tp>::_Alloc_block*>
+    bitmap_allocator<_Tp>::_S_last_request(_S_mem_blocks);
+
+#if defined __GTHREADS
+  template<typename _Tp>
+    typename bitmap_allocator<_Tp>::__mutex_type
+    bitmap_allocator<_Tp>::_S_mut;
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/cast.h b/gcc-4.9/libstdc++-v3/include/ext/cast.h
new file mode 100644
index 0000000..655ca06
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/cast.h
@@ -0,0 +1,121 @@
+// <cast.h> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/cast.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/pointer.h}
+ */
+
+#ifndef _GLIBCXX_CAST_H
+#define _GLIBCXX_CAST_H 1
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * These functions are here to allow containers to support non standard
+   * pointer types.  For normal pointers, these resolve to the use of the
+   * standard cast operation.  For other types the functions will perform
+   * the appropriate cast to/from the custom pointer class so long as that
+   * class meets the following conditions:
+   * 1) has a typedef element_type which names tehe type it points to.
+   * 2) has a get() const method which returns element_type*.
+   * 3) has a constructor which can take one element_type* argument.
+   */
+
+  /**
+   * This type supports the semantics of the pointer cast operators (below.)
+   */
+  template<typename _ToType>
+    struct _Caster
+    { typedef typename _ToType::element_type*  type; };
+
+  template<typename _ToType>
+    struct _Caster<_ToType*>
+    { typedef _ToType*  type; };
+
+  /**
+   * Casting operations for cases where _FromType is not a standard pointer.
+   * _ToType can be a standard or non-standard pointer.  Given that _FromType
+   * is not a pointer, it must have a get() method that returns the standard
+   * pointer equivalent of the address it points to, and must have an
+   * element_type typedef which names the type it points to.
+   */
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __static_pointer_cast(const _FromType& __arg)
+    { return _ToType(static_cast<typename _Caster<_ToType>::
+		     type>(__arg.get())); }
+
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __dynamic_pointer_cast(const _FromType& __arg)
+    { return _ToType(dynamic_cast<typename _Caster<_ToType>::
+		     type>(__arg.get())); }
+
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __const_pointer_cast(const _FromType& __arg)
+    { return _ToType(const_cast<typename _Caster<_ToType>::
+		     type>(__arg.get())); }
+
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __reinterpret_pointer_cast(const _FromType& __arg)
+    { return _ToType(reinterpret_cast<typename _Caster<_ToType>::
+		     type>(__arg.get())); }
+
+  /**
+   * Casting operations for cases where _FromType is a standard pointer.
+   * _ToType can be a standard or non-standard pointer.
+   */
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __static_pointer_cast(_FromType* __arg)
+    { return _ToType(static_cast<typename _Caster<_ToType>::
+		     type>(__arg)); }
+
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __dynamic_pointer_cast(_FromType* __arg)
+    { return _ToType(dynamic_cast<typename _Caster<_ToType>::
+		     type>(__arg)); }
+
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __const_pointer_cast(_FromType* __arg)
+    { return _ToType(const_cast<typename _Caster<_ToType>::
+		     type>(__arg)); }
+
+  template<typename _ToType, typename _FromType>
+    inline _ToType
+    __reinterpret_pointer_cast(_FromType* __arg)
+    { return _ToType(reinterpret_cast<typename _Caster<_ToType>::
+		     type>(__arg)); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _GLIBCXX_CAST_H
diff --git a/gcc-4.9/libstdc++-v3/include/ext/cmath b/gcc-4.9/libstdc++-v3/include/ext/cmath
new file mode 100644
index 0000000..91434d3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/cmath
@@ -0,0 +1,152 @@
+// Math extensions -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/cmath
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _EXT_CMATH
+#define _EXT_CMATH 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <cmath>
+#include <type_traits>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // A class for math constants.
+  template<typename _RealType>
+    struct __math_constants
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+      // Constant @f$ \pi @f$.
+      static constexpr _RealType __pi = 3.1415926535897932384626433832795029L;
+      // Constant @f$ \pi / 2 @f$.
+      static constexpr _RealType __pi_half = 1.5707963267948966192313216916397514L;
+      // Constant @f$ \pi / 3 @f$.
+      static constexpr _RealType __pi_third = 1.0471975511965977461542144610931676L;
+      // Constant @f$ \pi / 4 @f$.
+      static constexpr _RealType __pi_quarter = 0.7853981633974483096156608458198757L;
+      // Constant @f$ \sqrt(\pi / 2) @f$.
+      static constexpr _RealType __root_pi_div_2 = 1.2533141373155002512078826424055226L;
+      // Constant @f$ 1 / \pi @f$.
+      static constexpr _RealType __one_div_pi = 0.3183098861837906715377675267450287L;
+      // Constant @f$ 2 / \pi @f$.
+      static constexpr _RealType __two_div_pi = 0.6366197723675813430755350534900574L;
+      // Constant @f$ 2 / \sqrt(\pi) @f$.
+      static constexpr _RealType __two_div_root_pi = 1.1283791670955125738961589031215452L;
+
+      // Constant Euler's number @f$ e @f$.
+      static constexpr _RealType __e = 2.7182818284590452353602874713526625L;
+      // Constant @f$ 1 / e @f$.
+      static constexpr _RealType __one_div_e = 0.36787944117144232159552377016146087L;
+      // Constant @f$ \log_2(e) @f$.
+      static constexpr _RealType __log2_e = 1.4426950408889634073599246810018921L;
+      // Constant @f$ \log_10(e) @f$.
+      static constexpr _RealType __log10_e = 0.4342944819032518276511289189166051L;
+      // Constant @f$ \ln(2) @f$.
+      static constexpr _RealType __ln_2 = 0.6931471805599453094172321214581766L;
+      // Constant @f$ \ln(3) @f$.
+      static constexpr _RealType __ln_3 = 1.0986122886681096913952452369225257L;
+      // Constant @f$ \ln(10) @f$.
+      static constexpr _RealType __ln_10 = 2.3025850929940456840179914546843642L;
+
+      // Constant Euler-Mascheroni @f$ \gamma_E @f$.
+      static constexpr _RealType __gamma_e = 0.5772156649015328606065120900824024L;
+      // Constant Golden Ratio @f$ \phi @f$.
+      static constexpr _RealType __phi = 1.6180339887498948482045868343656381L;
+
+      // Constant @f$ \sqrt(2) @f$.
+      static constexpr _RealType __root_2 = 1.4142135623730950488016887242096981L;
+      // Constant @f$ \sqrt(3) @f$.
+      static constexpr _RealType __root_3 = 1.7320508075688772935274463415058724L;
+      // Constant @f$ \sqrt(5) @f$.
+      static constexpr _RealType __root_5 = 2.2360679774997896964091736687312762L;
+      // Constant @f$ \sqrt(7) @f$.
+      static constexpr _RealType __root_7 = 2.6457513110645905905016157536392604L;
+      // Constant @f$ 1 / \sqrt(2) @f$.
+      static constexpr _RealType __one_div_root_2 = 0.7071067811865475244008443621048490L;
+    };
+
+  // And the template definitions for the constants.
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__pi;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__pi_half;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__pi_third;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__pi_quarter;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__root_pi_div_2;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__one_div_pi;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__two_div_pi;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__two_div_root_pi;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__e;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__one_div_e;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__log2_e;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__log10_e;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__ln_2;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__ln_3;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__ln_10;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__gamma_e;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__phi;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__root_2;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__root_3;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__root_5;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__root_7;
+  template<typename _RealType>
+    constexpr _RealType __math_constants<_RealType>::__one_div_root_2;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
+
+#endif // C++11
+
+#endif // _EXT_CMATH
diff --git a/gcc-4.9/libstdc++-v3/include/ext/codecvt_specializations.h b/gcc-4.9/libstdc++-v3/include/ext/codecvt_specializations.h
new file mode 100644
index 0000000..9a4c6e0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/codecvt_specializations.h
@@ -0,0 +1,512 @@
+// Locale support (codecvt) -*- C++ -*-
+
+// Copyright (C) 2000-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 22.2.1.5 Template class codecvt
+//
+
+// Written by Benjamin Kosnik <bkoz@redhat.com>
+
+/** @file ext/codecvt_specializations.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _EXT_CODECVT_SPECIALIZATIONS_H
+#define _EXT_CODECVT_SPECIALIZATIONS_H 1
+
+#include <bits/c++config.h>
+#include <locale>
+#include <iconv.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// Extension to use iconv for dealing with character encodings.
+  // This includes conversions and comparisons between various character
+  // sets.  This object encapsulates data that may need to be shared between
+  // char_traits, codecvt and ctype.
+  class encoding_state
+  {
+  public:
+    // Types: 
+    // NB: A conversion descriptor subsumes and enhances the
+    // functionality of a simple state type such as mbstate_t.
+    typedef iconv_t	descriptor_type;
+    
+  protected:
+    // Name of internal character set encoding.
+    std::string	       	_M_int_enc;
+
+    // Name of external character set encoding.
+    std::string  	_M_ext_enc;
+
+    // Conversion descriptor between external encoding to internal encoding.
+    descriptor_type	_M_in_desc;
+
+    // Conversion descriptor between internal encoding to external encoding.
+    descriptor_type	_M_out_desc;
+
+    // The byte-order marker for the external encoding, if necessary.
+    int			_M_ext_bom;
+
+    // The byte-order marker for the internal encoding, if necessary.
+    int			_M_int_bom;
+
+    // Number of external bytes needed to construct one complete
+    // character in the internal encoding.
+    // NB: -1 indicates variable, or stateful, encodings.
+    int 		_M_bytes;
+
+  public:
+    explicit 
+    encoding_state() 
+    : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0), _M_bytes(0)
+    { }
+
+    explicit 
+    encoding_state(const char* __int, const char* __ext, 
+		   int __ibom = 0, int __ebom = 0, int __bytes = 1)
+    : _M_int_enc(__int), _M_ext_enc(__ext), _M_in_desc(0), _M_out_desc(0), 
+      _M_ext_bom(__ebom), _M_int_bom(__ibom), _M_bytes(__bytes)
+    { init(); }
+
+    // 21.1.2 traits typedefs
+    // p4
+    // typedef STATE_T state_type
+    // requires: state_type shall meet the requirements of
+    // CopyConstructible types (20.1.3)
+    // NB: This does not preserve the actual state of the conversion
+    // descriptor member, but it does duplicate the encoding
+    // information.
+    encoding_state(const encoding_state& __obj) : _M_in_desc(0), _M_out_desc(0)
+    { construct(__obj); }
+
+    // Need assignment operator as well.
+    encoding_state&
+    operator=(const encoding_state& __obj)
+    {
+      construct(__obj);
+      return *this;
+    }
+
+    ~encoding_state()
+    { destroy(); } 
+
+    bool
+    good() const throw()
+    { 
+      const descriptor_type __err = (iconv_t)(-1);
+      bool __test = _M_in_desc && _M_in_desc != __err; 
+      __test &=  _M_out_desc && _M_out_desc != __err;
+      return __test;
+    }
+    
+    int
+    character_ratio() const
+    { return _M_bytes; }
+
+    const std::string
+    internal_encoding() const
+    { return _M_int_enc; }
+
+    int 
+    internal_bom() const
+    { return _M_int_bom; }
+
+    const std::string
+    external_encoding() const
+    { return _M_ext_enc; }
+
+    int 
+    external_bom() const
+    { return _M_ext_bom; }
+
+    const descriptor_type&
+    in_descriptor() const
+    { return _M_in_desc; }
+
+    const descriptor_type&
+    out_descriptor() const
+    { return _M_out_desc; }
+
+  protected:
+    void
+    init()
+    {
+      const descriptor_type __err = (iconv_t)(-1);
+      const bool __have_encodings = _M_int_enc.size() && _M_ext_enc.size();
+      if (!_M_in_desc && __have_encodings)
+	{
+	  _M_in_desc = iconv_open(_M_int_enc.c_str(), _M_ext_enc.c_str());
+	  if (_M_in_desc == __err)
+	    std::__throw_runtime_error(__N("encoding_state::_M_init "
+				    "creating iconv input descriptor failed"));
+	}
+      if (!_M_out_desc && __have_encodings)
+	{
+	  _M_out_desc = iconv_open(_M_ext_enc.c_str(), _M_int_enc.c_str());
+	  if (_M_out_desc == __err)
+	    std::__throw_runtime_error(__N("encoding_state::_M_init "
+				  "creating iconv output descriptor failed"));
+	}
+    }
+
+    void
+    construct(const encoding_state& __obj)
+    {
+      destroy();
+      _M_int_enc = __obj._M_int_enc;
+      _M_ext_enc = __obj._M_ext_enc;
+      _M_ext_bom = __obj._M_ext_bom;
+      _M_int_bom = __obj._M_int_bom;
+      _M_bytes = __obj._M_bytes;
+      init();
+    }
+
+    void
+    destroy() throw()
+    {
+      const descriptor_type __err = (iconv_t)(-1);
+      if (_M_in_desc && _M_in_desc != __err) 
+	{
+	  iconv_close(_M_in_desc);
+	  _M_in_desc = 0;
+	}
+      if (_M_out_desc && _M_out_desc != __err) 
+	{
+	  iconv_close(_M_out_desc);
+	  _M_out_desc = 0;
+	}
+    }
+  };
+
+  /// encoding_char_traits
+  // Custom traits type with encoding_state for the state type, and the
+  // associated fpos<encoding_state> for the position type, all other
+  // bits equivalent to the required char_traits instantiations.
+  template<typename _CharT>
+    struct encoding_char_traits : public std::char_traits<_CharT>
+    {
+      typedef encoding_state				state_type;
+      typedef typename std::fpos<state_type>		pos_type;
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using __gnu_cxx::encoding_state;
+
+  /// codecvt<InternT, _ExternT, encoding_state> specialization.
+  // This partial specialization takes advantage of iconv to provide
+  // code conversions between a large number of character encodings.
+  template<typename _InternT, typename _ExternT>
+    class codecvt<_InternT, _ExternT, encoding_state>
+    : public __codecvt_abstract_base<_InternT, _ExternT, encoding_state>
+    {
+    public:      
+      // Types:
+      typedef codecvt_base::result			result;
+      typedef _InternT 					intern_type;
+      typedef _ExternT 					extern_type;
+      typedef __gnu_cxx::encoding_state 		state_type;
+      typedef state_type::descriptor_type 		descriptor_type;
+
+      // Data Members:
+      static locale::id 		id;
+
+      explicit 
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
+      { }
+
+      explicit 
+      codecvt(state_type& __enc, size_t __refs = 0)
+      : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
+      { }
+
+     protected:
+      virtual 
+      ~codecvt() { }
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from, 
+	     const intern_type* __from_end, const intern_type*& __from_next,
+	     extern_type* __to, extern_type* __to_end,
+	     extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to, 
+		 extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from, 
+	    const extern_type* __from_end, const extern_type*& __from_next,
+	    intern_type* __to, intern_type* __to_end, 
+	    intern_type*& __to_next) const;
+
+      virtual int 
+      do_encoding() const throw();
+
+      virtual bool 
+      do_always_noconv() const throw();
+
+      virtual int 
+      do_length(state_type&, const extern_type* __from, 
+		const extern_type* __end, size_t __max) const;
+
+      virtual int 
+      do_max_length() const throw();
+    };
+
+  template<typename _InternT, typename _ExternT>
+    locale::id 
+    codecvt<_InternT, _ExternT, encoding_state>::id;
+
+  // This adaptor works around the signature problems of the second
+  // argument to iconv():  SUSv2 and others use 'const char**', but glibc 2.2
+  // uses 'char**', which matches the POSIX 1003.1-2001 standard.
+  // Using this adaptor, g++ will do the work for us.
+  template<typename _Tp>
+    inline size_t
+    __iconv_adaptor(size_t(*__func)(iconv_t, _Tp, size_t*, char**, size_t*),
+                    iconv_t __cd, char** __inbuf, size_t* __inbytes,
+                    char** __outbuf, size_t* __outbytes)
+    { return __func(__cd, (_Tp)__inbuf, __inbytes, __outbuf, __outbytes); }
+
+  template<typename _InternT, typename _ExternT>
+    codecvt_base::result
+    codecvt<_InternT, _ExternT, encoding_state>::
+    do_out(state_type& __state, const intern_type* __from, 
+	   const intern_type* __from_end, const intern_type*& __from_next,
+	   extern_type* __to, extern_type* __to_end,
+	   extern_type*& __to_next) const
+    {
+      result __ret = codecvt_base::error;
+      if (__state.good())
+	{
+	  const descriptor_type& __desc = __state.out_descriptor();
+	  const size_t __fmultiple = sizeof(intern_type);
+	  size_t __fbytes = __fmultiple * (__from_end - __from);
+	  const size_t __tmultiple = sizeof(extern_type);
+	  size_t __tbytes = __tmultiple * (__to_end - __to); 
+	  
+	  // Argument list for iconv specifies a byte sequence. Thus,
+	  // all to/from arrays must be brutally casted to char*.
+	  char* __cto = reinterpret_cast<char*>(__to);
+	  char* __cfrom;
+	  size_t __conv;
+
+	  // Some encodings need a byte order marker as the first item
+	  // in the byte stream, to designate endian-ness. The default
+	  // value for the byte order marker is NULL, so if this is
+	  // the case, it's not necessary and we can just go on our
+	  // merry way.
+	  int __int_bom = __state.internal_bom();
+	  if (__int_bom)
+	    {	  
+	      size_t __size = __from_end - __from;
+	      intern_type* __cfixed = static_cast<intern_type*>
+		(__builtin_alloca(sizeof(intern_type) * (__size + 1)));
+	      __cfixed[0] = static_cast<intern_type>(__int_bom);
+	      char_traits<intern_type>::copy(__cfixed + 1, __from, __size);
+	      __cfrom = reinterpret_cast<char*>(__cfixed);
+	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
+                                        &__fbytes, &__cto, &__tbytes); 
+	    }
+	  else
+	    {
+	      intern_type* __cfixed = const_cast<intern_type*>(__from);
+	      __cfrom = reinterpret_cast<char*>(__cfixed);
+	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom, &__fbytes, 
+				       &__cto, &__tbytes); 
+	    }
+
+	  if (__conv != size_t(-1))
+	    {
+	      __from_next = reinterpret_cast<const intern_type*>(__cfrom);
+	      __to_next = reinterpret_cast<extern_type*>(__cto);
+	      __ret = codecvt_base::ok;
+	    }
+	  else 
+	    {
+	      if (__fbytes < __fmultiple * (__from_end - __from))
+		{
+		  __from_next = reinterpret_cast<const intern_type*>(__cfrom);
+		  __to_next = reinterpret_cast<extern_type*>(__cto);
+		  __ret = codecvt_base::partial;
+		}
+	      else
+		__ret = codecvt_base::error;
+	    }
+	}
+      return __ret; 
+    }
+
+  template<typename _InternT, typename _ExternT>
+    codecvt_base::result
+    codecvt<_InternT, _ExternT, encoding_state>::
+    do_unshift(state_type& __state, extern_type* __to, 
+	       extern_type* __to_end, extern_type*& __to_next) const
+    {
+      result __ret = codecvt_base::error;
+      if (__state.good())
+	{
+	  const descriptor_type& __desc = __state.in_descriptor();
+	  const size_t __tmultiple = sizeof(intern_type);
+	  size_t __tlen = __tmultiple * (__to_end - __to); 
+	  
+	  // Argument list for iconv specifies a byte sequence. Thus,
+	  // all to/from arrays must be brutally casted to char*.
+	  char* __cto = reinterpret_cast<char*>(__to);
+	  size_t __conv = __iconv_adaptor(iconv,__desc, 0, 0,
+                                          &__cto, &__tlen); 
+	  
+	  if (__conv != size_t(-1))
+	    {
+	      __to_next = reinterpret_cast<extern_type*>(__cto);
+	      if (__tlen == __tmultiple * (__to_end - __to))
+		__ret = codecvt_base::noconv;
+	      else if (__tlen == 0)
+		__ret = codecvt_base::ok;
+	      else
+		__ret = codecvt_base::partial;
+	    }
+	  else 
+	    __ret = codecvt_base::error;
+	}
+      return __ret; 
+    }
+   
+  template<typename _InternT, typename _ExternT>
+    codecvt_base::result
+    codecvt<_InternT, _ExternT, encoding_state>::
+    do_in(state_type& __state, const extern_type* __from, 
+	  const extern_type* __from_end, const extern_type*& __from_next,
+	  intern_type* __to, intern_type* __to_end, 
+	  intern_type*& __to_next) const
+    { 
+      result __ret = codecvt_base::error;
+      if (__state.good())
+	{
+	  const descriptor_type& __desc = __state.in_descriptor();
+	  const size_t __fmultiple = sizeof(extern_type);
+	  size_t __flen = __fmultiple * (__from_end - __from);
+	  const size_t __tmultiple = sizeof(intern_type);
+	  size_t __tlen = __tmultiple * (__to_end - __to); 
+	  
+	  // Argument list for iconv specifies a byte sequence. Thus,
+	  // all to/from arrays must be brutally casted to char*.
+	  char* __cto = reinterpret_cast<char*>(__to);
+	  char* __cfrom;
+	  size_t __conv;
+
+	  // Some encodings need a byte order marker as the first item
+	  // in the byte stream, to designate endian-ness. The default
+	  // value for the byte order marker is NULL, so if this is
+	  // the case, it's not necessary and we can just go on our
+	  // merry way.
+	  int __ext_bom = __state.external_bom();
+	  if (__ext_bom)
+	    {	  
+	      size_t __size = __from_end - __from;
+	      extern_type* __cfixed =  static_cast<extern_type*>
+		(__builtin_alloca(sizeof(extern_type) * (__size + 1)));
+	      __cfixed[0] = static_cast<extern_type>(__ext_bom);
+	      char_traits<extern_type>::copy(__cfixed + 1, __from, __size);
+	      __cfrom = reinterpret_cast<char*>(__cfixed);
+	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
+                                       &__flen, &__cto, &__tlen); 
+	    }
+	  else
+	    {
+	      extern_type* __cfixed = const_cast<extern_type*>(__from);
+	      __cfrom = reinterpret_cast<char*>(__cfixed);
+	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
+                                       &__flen, &__cto, &__tlen); 
+	    }
+
+	  
+	  if (__conv != size_t(-1))
+	    {
+	      __from_next = reinterpret_cast<const extern_type*>(__cfrom);
+	      __to_next = reinterpret_cast<intern_type*>(__cto);
+	      __ret = codecvt_base::ok;
+	    }
+	  else 
+	    {
+	      if (__flen < static_cast<size_t>(__from_end - __from))
+		{
+		  __from_next = reinterpret_cast<const extern_type*>(__cfrom);
+		  __to_next = reinterpret_cast<intern_type*>(__cto);
+		  __ret = codecvt_base::partial;
+		}
+	      else
+		__ret = codecvt_base::error;
+	    }
+	}
+      return __ret; 
+    }
+  
+  template<typename _InternT, typename _ExternT>
+    int 
+    codecvt<_InternT, _ExternT, encoding_state>::
+    do_encoding() const throw()
+    {
+      int __ret = 0;
+      if (sizeof(_ExternT) <= sizeof(_InternT))
+	__ret = sizeof(_InternT) / sizeof(_ExternT);
+      return __ret; 
+    }
+  
+  template<typename _InternT, typename _ExternT>
+    bool 
+    codecvt<_InternT, _ExternT, encoding_state>::
+    do_always_noconv() const throw()
+    { return false; }
+  
+  template<typename _InternT, typename _ExternT>
+    int 
+    codecvt<_InternT, _ExternT, encoding_state>::
+    do_length(state_type&, const extern_type* __from, 
+	      const extern_type* __end, size_t __max) const
+    { return std::min(__max, static_cast<size_t>(__end - __from)); }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 74.  Garbled text for codecvt::do_max_length
+  template<typename _InternT, typename _ExternT>
+    int 
+    codecvt<_InternT, _ExternT, encoding_state>::
+    do_max_length() const throw()
+    { return 1; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/concurrence.h b/gcc-4.9/libstdc++-v3/include/ext/concurrence.h
new file mode 100644
index 0000000..1d39661
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/concurrence.h
@@ -0,0 +1,318 @@
+// Support for concurrent programing -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/concurrence.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _CONCURRENCE_H
+#define _CONCURRENCE_H 1
+
+#pragma GCC system_header
+
+#include <exception>
+#include <bits/gthr.h> 
+#include <bits/functexcept.h>
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Available locking policies:
+  // _S_single    single-threaded code that doesn't need to be locked.
+  // _S_mutex     multi-threaded code that requires additional support
+  //              from gthr.h or abstraction layers in concurrence.h.
+  // _S_atomic    multi-threaded code using atomic operations.
+  enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; 
+
+  // Compile time constant that indicates prefered locking policy in
+  // the current configuration.
+  static const _Lock_policy __default_lock_policy = 
+#ifdef __GTHREADS
+#if (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2) \
+     && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4))
+  _S_atomic;
+#else
+  _S_mutex;
+#endif
+#else
+  _S_single;
+#endif
+
+  // NB: As this is used in libsupc++, need to only depend on
+  // exception. No stdexception classes, no use of std::string.
+  class __concurrence_lock_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_lock_error"; }
+  };
+
+  class __concurrence_unlock_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_unlock_error"; }
+  };
+
+  class __concurrence_broadcast_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_broadcast_error"; }
+  };
+
+  class __concurrence_wait_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_wait_error"; }
+  };
+
+  // Substitute for concurrence_error object in the case of -fno-exceptions.
+  inline void
+  __throw_concurrence_lock_error()
+  { _GLIBCXX_THROW_OR_ABORT(__concurrence_lock_error()); }
+
+  inline void
+  __throw_concurrence_unlock_error()
+  { _GLIBCXX_THROW_OR_ABORT(__concurrence_unlock_error()); }
+
+#ifdef __GTHREAD_HAS_COND
+  inline void
+  __throw_concurrence_broadcast_error()
+  { _GLIBCXX_THROW_OR_ABORT(__concurrence_broadcast_error()); }
+
+  inline void
+  __throw_concurrence_wait_error()
+  { _GLIBCXX_THROW_OR_ABORT(__concurrence_wait_error()); }
+#endif
+ 
+  class __mutex 
+  {
+  private:
+#if __GTHREADS && defined __GTHREAD_MUTEX_INIT
+    __gthread_mutex_t _M_mutex = __GTHREAD_MUTEX_INIT;
+#else
+    __gthread_mutex_t _M_mutex;
+#endif
+
+    __mutex(const __mutex&);
+    __mutex& operator=(const __mutex&);
+
+  public:
+    __mutex() 
+    { 
+#if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT
+      if (__gthread_active_p())
+	__GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
+#endif
+    }
+
+#if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT
+    ~__mutex() 
+    { 
+      if (__gthread_active_p())
+	__gthread_mutex_destroy(&_M_mutex); 
+    }
+#endif 
+
+    void lock()
+    {
+#if __GTHREADS
+      if (__gthread_active_p())
+	{
+	  if (__gthread_mutex_lock(&_M_mutex) != 0)
+	    __throw_concurrence_lock_error();
+	}
+#endif
+    }
+    
+    void unlock()
+    {
+#if __GTHREADS
+      if (__gthread_active_p())
+	{
+	  if (__gthread_mutex_unlock(&_M_mutex) != 0)
+	    __throw_concurrence_unlock_error();
+	}
+#endif
+    }
+
+    __gthread_mutex_t* gthread_mutex(void)
+      { return &_M_mutex; }
+  };
+
+  class __recursive_mutex 
+  {
+  private:
+#if __GTHREADS && defined __GTHREAD_RECURSIVE_MUTEX_INIT
+    __gthread_recursive_mutex_t _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT;
+#else
+    __gthread_recursive_mutex_t _M_mutex;
+#endif
+
+    __recursive_mutex(const __recursive_mutex&);
+    __recursive_mutex& operator=(const __recursive_mutex&);
+
+  public:
+    __recursive_mutex() 
+    { 
+#if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT
+      if (__gthread_active_p())
+	__GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
+#endif
+    }
+
+#if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT
+    ~__recursive_mutex()
+    {
+      if (__gthread_active_p())
+	__gthread_recursive_mutex_destroy(&_M_mutex);
+    }
+#endif
+
+    void lock()
+    { 
+#if __GTHREADS
+      if (__gthread_active_p())
+	{
+	  if (__gthread_recursive_mutex_lock(&_M_mutex) != 0)
+	    __throw_concurrence_lock_error();
+	}
+#endif
+    }
+    
+    void unlock()
+    { 
+#if __GTHREADS
+      if (__gthread_active_p())
+	{
+	  if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0)
+	    __throw_concurrence_unlock_error();
+	}
+#endif
+    }
+
+    __gthread_recursive_mutex_t* gthread_recursive_mutex(void)
+    { return &_M_mutex; }
+  };
+
+  /// Scoped lock idiom.
+  // Acquire the mutex here with a constructor call, then release with
+  // the destructor call in accordance with RAII style.
+  class __scoped_lock
+  {
+  public:
+    typedef __mutex __mutex_type;
+
+  private:
+    __mutex_type& _M_device;
+
+    __scoped_lock(const __scoped_lock&);
+    __scoped_lock& operator=(const __scoped_lock&);
+
+  public:
+    explicit __scoped_lock(__mutex_type& __name) : _M_device(__name)
+    { _M_device.lock(); }
+
+    ~__scoped_lock() throw()
+    { _M_device.unlock(); }
+  };
+
+#ifdef __GTHREAD_HAS_COND
+  class __cond
+  {
+  private:
+#if __GTHREADS && defined __GTHREAD_COND_INIT
+    __gthread_cond_t _M_cond = __GTHREAD_COND_INIT;
+#else
+    __gthread_cond_t _M_cond;
+#endif
+
+    __cond(const __cond&);
+    __cond& operator=(const __cond&);
+
+  public:
+    __cond() 
+    { 
+#if __GTHREADS && ! defined __GTHREAD_COND_INIT
+      if (__gthread_active_p())
+	__GTHREAD_COND_INIT_FUNCTION(&_M_cond);
+#endif
+    }
+
+#if __GTHREADS && ! defined __GTHREAD_COND_INIT
+    ~__cond() 
+    { 
+      if (__gthread_active_p())
+	__gthread_cond_destroy(&_M_cond); 
+    }
+#endif 
+
+    void broadcast()
+    {
+#if __GTHREADS
+      if (__gthread_active_p())
+	{
+	  if (__gthread_cond_broadcast(&_M_cond) != 0)
+	    __throw_concurrence_broadcast_error();
+	}
+#endif
+    }
+
+    void wait(__mutex *mutex)
+    {
+#if __GTHREADS
+      {
+	  if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0)
+	    __throw_concurrence_wait_error();
+      }
+#endif
+    }
+
+    void wait_recursive(__recursive_mutex *mutex)
+    {
+#if __GTHREADS
+      {
+	  if (__gthread_cond_wait_recursive(&_M_cond,
+					    mutex->gthread_recursive_mutex())
+	      != 0)
+	    __throw_concurrence_wait_error();
+      }
+#endif
+    }
+  };
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/debug_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/debug_allocator.h
new file mode 100644
index 0000000..ffdfee6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/debug_allocator.h
@@ -0,0 +1,191 @@
+// Allocators -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/debug_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _DEBUG_ALLOCATOR_H
+#define _DEBUG_ALLOCATOR_H 1
+
+#include <stdexcept>
+#include <bits/functexcept.h>
+#include <ext/alloc_traits.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+
+  /**
+   *  @brief  A meta-allocator with debugging bits.
+   *  @ingroup allocators
+   *
+   *  This is precisely the allocator defined in the C++03 Standard.
+   */
+  template<typename _Alloc>
+    class debug_allocator
+    {
+      template<typename> friend class debug_allocator;
+
+      typedef __alloc_traits<_Alloc> _Traits;
+
+    public:
+      typedef typename _Traits::size_type       	size_type;
+      typedef typename _Traits::difference_type	difference_type;
+      typedef typename _Traits::pointer       	pointer;
+      typedef typename _Traits::const_pointer    const_pointer;
+      typedef typename _Traits::reference       	reference;
+      typedef typename _Traits::const_reference  const_reference;
+      typedef typename _Traits::value_type       value_type;
+
+      template<typename _Up>
+	class rebind
+	{
+	  typedef typename _Traits::template rebind<_Up>::other __other;
+
+	public:
+	  typedef debug_allocator<__other> other;
+	};
+
+    private:
+      // _M_extra is the number of objects that correspond to the
+      // extra space where debug information is stored.
+      size_type 		_M_extra;
+      
+      _Alloc			_M_allocator;
+
+      template<typename _Alloc2,
+	       typename = typename _Alloc2::template rebind<value_type>::other>
+	struct __convertible
+	{ };
+
+      template<typename _Alloc2>
+	struct __convertible<_Alloc2, _Alloc>
+	{
+	  typedef void* __type;
+	};
+
+      size_type _S_extra()
+      {
+	const size_t __obj_size = sizeof(value_type);
+	return (sizeof(size_type) + __obj_size - 1) / __obj_size; 
+      }
+
+    public:
+      debug_allocator() : _M_extra(_S_extra()) { }
+
+      template<typename _Alloc2>
+	debug_allocator(const debug_allocator<_Alloc2>& __a2,
+			typename __convertible<_Alloc2>::__type = 0)
+	: _M_allocator(__a2._M_allocator), _M_extra(_S_extra()) { }
+
+      debug_allocator(const _Alloc& __a)
+      : _M_allocator(__a), _M_extra(_S_extra()) { }
+
+      pointer
+      allocate(size_type __n)
+      {
+        pointer __res = _M_allocator.allocate(__n + _M_extra);      
+	size_type* __ps = reinterpret_cast<size_type*>(__res);
+	*__ps = __n;
+        return __res + _M_extra;
+      }
+
+      pointer
+      allocate(size_type __n, const void* __hint)
+      {
+        pointer __res = _M_allocator.allocate(__n + _M_extra, __hint);
+	size_type* __ps = reinterpret_cast<size_type*>(__res);
+	*__ps = __n;
+        return __res + _M_extra;
+      }
+
+      void
+      deallocate(pointer __p, size_type __n)
+      {
+	using std::__throw_runtime_error;
+	if (__p)
+	  {
+	    pointer __real_p = __p - _M_extra;
+	    if (*reinterpret_cast<size_type*>(__real_p) != __n)
+	      __throw_runtime_error("debug_allocator::deallocate wrong size");
+	    _M_allocator.deallocate(__real_p, __n + _M_extra);
+	  }
+	else
+	  __throw_runtime_error("debug_allocator::deallocate null pointer");
+      }
+
+      void
+      construct(pointer __p, const value_type& __val)
+      { _Traits::construct(_M_allocator, __p, __val); }
+
+#if __cplusplus >= 201103L
+      template<typename _Tp, typename... _Args>
+	void
+	construct(_Tp* __p, _Args&&... __args)
+	{
+	  _Traits::construct(_M_allocator, __p,
+			     std::forward<_Args>(__args)...);
+	}
+#endif
+
+      template<typename _Tp>
+	void
+	destroy(_Tp* __p)
+	{ _Traits::destroy(_M_allocator, __p); }
+
+      size_type
+      max_size() const throw()
+      { return _Traits::max_size(_M_allocator) - _M_extra; }
+
+      friend bool
+      operator==(const debug_allocator& __lhs, const debug_allocator& __rhs)
+      { return __lhs._M_allocator == __rhs._M_allocator; }
+    };
+
+  template<typename _Alloc>
+    inline bool
+    operator!=(const debug_allocator<_Alloc>& __lhs,
+	       const debug_allocator<_Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/enc_filebuf.h b/gcc-4.9/libstdc++-v3/include/ext/enc_filebuf.h
new file mode 100644
index 0000000..2a181fc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/enc_filebuf.h
@@ -0,0 +1,65 @@
+// filebuf with encoding state type -*- C++ -*-
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/enc_filebuf.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _EXT_ENC_FILEBUF_H
+#define _EXT_ENC_FILEBUF_H 1
+
+#include <fstream>
+#include <locale>
+#include <ext/codecvt_specializations.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// class enc_filebuf.
+  template<typename _CharT>
+    class enc_filebuf
+    : public std::basic_filebuf<_CharT, encoding_char_traits<_CharT> >
+    {
+    public:
+      typedef encoding_char_traits<_CharT>     	traits_type;
+      typedef typename traits_type::state_type	state_type;
+      typedef typename traits_type::pos_type	pos_type;
+
+      enc_filebuf(state_type& __state)
+      : std::basic_filebuf<_CharT, encoding_char_traits<_CharT> >()
+      { this->_M_state_beg = __state; }
+
+    private:
+      // concept requirements:
+      // Set state type to something useful.
+      // Something more than copyconstructible is needed here, so
+      // require default and copy constructible + assignment operator.
+      __glibcxx_class_requires(state_type, _SGIAssignableConcept)
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/extptr_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/extptr_allocator.h
new file mode 100644
index 0000000..1b8bdc7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/extptr_allocator.h
@@ -0,0 +1,197 @@
+// <extptr_allocator.h> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file ext/extptr_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ *
+ *  @author Bob Walters
+ *
+ * An example allocator which uses an alternative pointer type from
+ * bits/pointer.h.  Supports test cases which confirm container support
+ * for alternative pointers.
+ */
+
+#ifndef _EXTPTR_ALLOCATOR_H
+#define _EXTPTR_ALLOCATOR_H 1
+
+#include <memory>
+#include <ext/numeric_traits.h>
+#include <ext/pointer.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @brief An example allocator which uses a non-standard pointer type.
+   * @ingroup allocators
+   *
+   * This allocator specifies that containers use a 'relative pointer' as it's
+   * pointer type.  (See ext/pointer.h)  Memory allocation in this example
+   * is still performed using std::allocator.
+   */
+  template<typename _Tp>
+    class _ExtPtr_allocator
+    {
+    public:
+      typedef std::size_t     size_type;
+      typedef std::ptrdiff_t  difference_type;
+
+      // Note the non-standard pointer types.
+      typedef _Pointer_adapter<_Relative_pointer_impl<_Tp> >       pointer;
+      typedef _Pointer_adapter<_Relative_pointer_impl<const _Tp> > 
+                                                             const_pointer;
+
+      typedef _Tp&       reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp        value_type;
+
+      template<typename _Up>
+        struct rebind
+        { typedef _ExtPtr_allocator<_Up> other; };
+
+      _ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT 
+      : _M_real_alloc() { }
+
+      _ExtPtr_allocator(const _ExtPtr_allocator& __rarg) _GLIBCXX_USE_NOEXCEPT
+      : _M_real_alloc(__rarg._M_real_alloc) { }
+
+      template<typename _Up>
+        _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg)
+	_GLIBCXX_USE_NOEXCEPT
+        : _M_real_alloc(__rarg._M_getUnderlyingImp()) { }
+
+      ~_ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT
+      { }
+
+      pointer address(reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      const_pointer address(const_reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      pointer allocate(size_type __n, void* __hint = 0)
+      { return _M_real_alloc.allocate(__n,__hint); }
+
+      void deallocate(pointer __p, size_type __n)
+      { _M_real_alloc.deallocate(__p.get(), __n); }
+
+      size_type max_size() const _GLIBCXX_USE_NOEXCEPT
+      { return __numeric_traits<size_type>::__max / sizeof(_Tp); }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args>
+        void
+        construct(pointer __p, _Args&&... __args)
+	{ construct(__p.get(), std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p)
+        { __p->~_Up(); }
+
+      void destroy(pointer __p)
+      { destroy(__p.get()); }
+
+#else
+
+      void construct(pointer __p, const _Tp& __val)
+      { ::new(__p.get()) _Tp(__val); }
+
+      void destroy(pointer __p)
+      { __p->~_Tp(); }
+#endif
+
+      template<typename _Up>
+        inline bool
+        operator==(const _ExtPtr_allocator<_Up>& __rarg)
+        { return _M_real_alloc == __rarg._M_getUnderlyingImp(); }
+
+      inline bool
+      operator==(const _ExtPtr_allocator& __rarg)
+      { return _M_real_alloc == __rarg._M_real_alloc; }
+
+      template<typename _Up>
+        inline bool
+        operator!=(const _ExtPtr_allocator<_Up>& __rarg)
+        { return _M_real_alloc != __rarg._M_getUnderlyingImp(); }
+
+      inline bool
+      operator!=(const _ExtPtr_allocator& __rarg)
+      { return _M_real_alloc != __rarg._M_real_alloc; }
+
+      template<typename _Up>
+        inline friend void
+        swap(_ExtPtr_allocator<_Up>&, _ExtPtr_allocator<_Up>&);
+
+      // A method specific to this implementation.
+      const std::allocator<_Tp>&
+      _M_getUnderlyingImp() const
+      { return _M_real_alloc; }
+
+    private:
+      std::allocator<_Tp>  _M_real_alloc;
+    };
+
+  // _ExtPtr_allocator<void> specialization.
+  template<>
+    class _ExtPtr_allocator<void>
+    {
+    public:
+      typedef std::size_t      size_type;
+      typedef std::ptrdiff_t   difference_type;
+      typedef void             value_type;
+
+      // Note the non-standard pointer types
+      typedef _Pointer_adapter<_Relative_pointer_impl<void> >       pointer;
+      typedef _Pointer_adapter<_Relative_pointer_impl<const void> >
+                                                              const_pointer;
+
+      template<typename _Up>
+        struct rebind
+        { typedef _ExtPtr_allocator<_Up> other; };
+
+    private:
+      std::allocator<void>  _M_real_alloc;
+    };
+
+  template<typename _Tp>
+    inline void
+    swap(_ExtPtr_allocator<_Tp>& __larg, _ExtPtr_allocator<_Tp>& __rarg)
+    {
+      std::allocator<_Tp> __tmp( __rarg._M_real_alloc );
+      __rarg._M_real_alloc = __larg._M_real_alloc;
+      __larg._M_real_alloc = __tmp;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _EXTPTR_ALLOCATOR_H */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/functional b/gcc-4.9/libstdc++-v3/include/ext/functional
new file mode 100644
index 0000000..ccdc85a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/functional
@@ -0,0 +1,430 @@
+// Functional extensions -*- C++ -*-
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/functional
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _EXT_FUNCTIONAL
+#define _EXT_FUNCTIONAL 1
+
+#pragma GCC system_header
+
+#include <functional>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::unary_function;
+  using std::binary_function;
+  using std::mem_fun1_t;
+  using std::const_mem_fun1_t;
+  using std::mem_fun1_ref_t;
+  using std::const_mem_fun1_ref_t;
+
+  /** The @c identity_element functions are not part of the C++
+   *  standard; SGI provided them as an extension.  Its argument is an
+   *  operation, and its return value is the identity element for that
+   *  operation.  It is overloaded for addition and multiplication,
+   *  and you can overload it for your own nefarious operations.
+   *
+   *  @addtogroup SGIextensions
+   *  @{
+   */
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Tp>
+    inline _Tp
+    identity_element(std::plus<_Tp>)
+    { return _Tp(0); }
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Tp>
+    inline _Tp
+    identity_element(std::multiplies<_Tp>)
+    { return _Tp(1); }
+  /** @}  */
+  
+  /** As an extension to the binders, SGI provided composition functors and
+   *  wrapper functions to aid in their creation.  The @c unary_compose
+   *  functor is constructed from two functions/functors, @c f and @c g.
+   *  Calling @c operator() with a single argument @c x returns @c f(g(x)).
+   *  The function @c compose1 takes the two functions and constructs a
+   *  @c unary_compose variable for you.
+   *
+   *  @c binary_compose is constructed from three functors, @c f, @c g1,
+   *  and @c g2.  Its @c operator() returns @c f(g1(x),g2(x)).  The function
+   *  compose2 takes f, g1, and g2, and constructs the @c binary_compose
+   *  instance for you.  For example, if @c f returns an int, then
+   *  \code
+   *  int answer = (compose2(f,g1,g2))(x);
+   *  \endcode
+   *  is equivalent to
+   *  \code
+   *  int temp1 = g1(x);
+   *  int temp2 = g2(x);
+   *  int answer = f(temp1,temp2);
+   *  \endcode
+   *  But the first form is more compact, and can be passed around as a
+   *  functor to other algorithms.
+   *
+   *  @addtogroup SGIextensions
+   *  @{
+   */
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Operation1, class _Operation2>
+    class unary_compose
+    : public unary_function<typename _Operation2::argument_type,
+			    typename _Operation1::result_type>
+    {
+    protected:
+      _Operation1 _M_fn1;
+      _Operation2 _M_fn2;
+
+    public:
+      unary_compose(const _Operation1& __x, const _Operation2& __y)
+      : _M_fn1(__x), _M_fn2(__y) {}
+
+      typename _Operation1::result_type
+      operator()(const typename _Operation2::argument_type& __x) const
+      { return _M_fn1(_M_fn2(__x)); }
+    };
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Operation1, class _Operation2>
+    inline unary_compose<_Operation1, _Operation2>
+    compose1(const _Operation1& __fn1, const _Operation2& __fn2)
+    { return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); }
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Operation1, class _Operation2, class _Operation3>
+    class binary_compose
+    : public unary_function<typename _Operation2::argument_type,
+			    typename _Operation1::result_type>
+    {
+    protected:
+      _Operation1 _M_fn1;
+      _Operation2 _M_fn2;
+      _Operation3 _M_fn3;
+      
+    public:
+      binary_compose(const _Operation1& __x, const _Operation2& __y,
+		     const _Operation3& __z)
+      : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
+
+      typename _Operation1::result_type
+      operator()(const typename _Operation2::argument_type& __x) const
+      { return _M_fn1(_M_fn2(__x), _M_fn3(__x)); }
+    };
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Operation1, class _Operation2, class _Operation3>
+    inline binary_compose<_Operation1, _Operation2, _Operation3>
+    compose2(const _Operation1& __fn1, const _Operation2& __fn2,
+	     const _Operation3& __fn3)
+    { return binary_compose<_Operation1, _Operation2, _Operation3>
+	(__fn1, __fn2, __fn3); }
+  /** @}  */
+
+  /** As an extension, SGI provided a functor called @c identity.  When a
+   *  functor is required but no operations are desired, this can be used as a
+   *  pass-through.  Its @c operator() returns its argument unchanged.
+   *
+   *  @addtogroup SGIextensions
+   */
+  template <class _Tp>
+    struct identity
+    : public std::_Identity<_Tp> {};
+
+  /** @c select1st and @c select2nd are extensions provided by SGI.  Their
+   *  @c operator()s
+   *  take a @c std::pair as an argument, and return either the first member
+   *  or the second member, respectively.  They can be used (especially with
+   *  the composition functors) to @a strip data from a sequence before
+   *  performing the remainder of an algorithm.
+   *
+   *  @addtogroup SGIextensions
+   *  @{
+   */
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Pair>
+    struct select1st
+    : public std::_Select1st<_Pair> {};
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Pair>
+    struct select2nd
+    : public std::_Select2nd<_Pair> {};
+
+  /** @}  */
+
+  // extension documented next
+  template <class _Arg1, class _Arg2>
+    struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1>
+    {
+      _Arg1
+      operator()(const _Arg1& __x, const _Arg2&) const
+      { return __x; }
+    };
+
+  template <class _Arg1, class _Arg2>
+    struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2>
+    {
+      _Arg2
+      operator()(const _Arg1&, const _Arg2& __y) const
+      { return __y; }
+    };
+
+  /** The @c operator() of the @c project1st functor takes two arbitrary
+   *  arguments and returns the first one, while @c project2nd returns the
+   *  second one.  They are extensions provided by SGI.
+   *
+   *  @addtogroup SGIextensions
+   *  @{
+   */
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Arg1, class _Arg2>
+    struct project1st : public _Project1st<_Arg1, _Arg2> {};
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Arg1, class _Arg2>
+    struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
+  /** @}  */
+
+  // extension documented next
+  template <class _Result>
+    struct _Constant_void_fun
+    {
+      typedef _Result result_type;
+      result_type _M_val;
+
+      _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
+
+      const result_type&
+      operator()() const
+      { return _M_val; }
+    };
+
+  template <class _Result, class _Argument>
+    struct _Constant_unary_fun
+    {
+      typedef _Argument argument_type;
+      typedef  _Result  result_type;
+      result_type _M_val;
+      
+      _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
+
+      const result_type&
+      operator()(const _Argument&) const
+      { return _M_val; }
+    };
+
+  template <class _Result, class _Arg1, class _Arg2>
+    struct _Constant_binary_fun
+    {
+      typedef  _Arg1   first_argument_type;
+      typedef  _Arg2   second_argument_type;
+      typedef  _Result result_type;
+      _Result _M_val;
+
+      _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
+      
+      const result_type&
+      operator()(const _Arg1&, const _Arg2&) const
+      { return _M_val; }
+    };
+
+  /** These three functors are each constructed from a single arbitrary
+   *  variable/value.  Later, their @c operator()s completely ignore any
+   *  arguments passed, and return the stored value.
+   *  - @c constant_void_fun's @c operator() takes no arguments
+   *  - @c constant_unary_fun's @c operator() takes one argument (ignored)
+   *  - @c constant_binary_fun's @c operator() takes two arguments (ignored)
+   *
+   *  The helper creator functions @c constant0, @c constant1, and
+   *  @c constant2 each take a @a result argument and construct variables of
+   *  the appropriate functor type.
+   *
+   *  @addtogroup SGIextensions
+   *  @{
+   */
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Result>
+    struct constant_void_fun
+    : public _Constant_void_fun<_Result>
+    {
+      constant_void_fun(const _Result& __v)
+      : _Constant_void_fun<_Result>(__v) {}
+    };
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Result, class _Argument = _Result>
+    struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
+    {
+      constant_unary_fun(const _Result& __v)
+      : _Constant_unary_fun<_Result, _Argument>(__v) {}
+    };
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Result, class _Arg1 = _Result, class _Arg2 = _Arg1>
+    struct constant_binary_fun
+    : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
+    {
+      constant_binary_fun(const _Result& __v)
+      : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
+    };
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Result>
+    inline constant_void_fun<_Result>
+    constant0(const _Result& __val)
+    { return constant_void_fun<_Result>(__val); }
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Result>
+    inline constant_unary_fun<_Result, _Result>
+    constant1(const _Result& __val)
+    { return constant_unary_fun<_Result, _Result>(__val); }
+
+  /// An \link SGIextensions SGI extension \endlink.
+  template <class _Result>
+    inline constant_binary_fun<_Result,_Result,_Result>
+    constant2(const _Result& __val)
+    { return constant_binary_fun<_Result, _Result, _Result>(__val); }
+  /** @}  */
+
+  /** The @c subtractive_rng class is documented on
+   *  <a href="http://www.sgi.com/tech/stl/">SGI's site</a>.
+   *  Note that this code assumes that @c int is 32 bits.
+   *
+   *  @ingroup SGIextensions
+   */
+  class subtractive_rng
+  : public unary_function<unsigned int, unsigned int>
+  {
+  private:
+    unsigned int _M_table[55];
+    size_t _M_index1;
+    size_t _M_index2;
+
+  public:
+    /// Returns a number less than the argument.
+    unsigned int
+    operator()(unsigned int __limit)
+    {
+      _M_index1 = (_M_index1 + 1) % 55;
+      _M_index2 = (_M_index2 + 1) % 55;
+      _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
+      return _M_table[_M_index1] % __limit;
+    }
+
+    void
+    _M_initialize(unsigned int __seed)
+    {
+      unsigned int __k = 1;
+      _M_table[54] = __seed;
+      size_t __i;
+      for (__i = 0; __i < 54; __i++)
+	{
+	  size_t __ii = (21 * (__i + 1) % 55) - 1;
+	  _M_table[__ii] = __k;
+	  __k = __seed - __k;
+	  __seed = _M_table[__ii];
+	}
+      for (int __loop = 0; __loop < 4; __loop++)
+	{
+	  for (__i = 0; __i < 55; __i++)
+            _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
+	}
+      _M_index1 = 0;
+      _M_index2 = 31;
+    }
+
+    /// Ctor allowing you to initialize the seed.
+    subtractive_rng(unsigned int __seed)
+    { _M_initialize(__seed); }
+
+    /// Default ctor; initializes its state with some number you don't see.
+    subtractive_rng()
+    { _M_initialize(161803398u); }
+  };
+
+  // Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref,
+  // provided for backward compatibility, they are no longer part of
+  // the C++ standard.
+  
+  template <class _Ret, class _Tp, class _Arg>
+    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun1(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template <class _Ret, class _Tp, class _Arg>
+    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template <class _Ret, class _Tp, class _Arg>
+    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+  template <class _Ret, class _Tp, class _Arg>
+    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/iterator b/gcc-4.9/libstdc++-v3/include/ext/iterator
new file mode 100644
index 0000000..c751e49
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/iterator
@@ -0,0 +1,116 @@
+// HP/SGI iterator extensions -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/iterator
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _EXT_ITERATOR
+#define _EXT_ITERATOR 1
+
+#pragma GCC system_header
+
+#include <bits/concept_check.h>
+#include <iterator>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // There are two signatures for distance.  In addition to the one
+  // taking two iterators and returning a result, there is another
+  // taking two iterators and a reference-to-result variable, and
+  // returning nothing.  The latter seems to be an SGI extension.
+  // -- pedwards
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    __distance(_InputIterator __first, _InputIterator __last,
+	       _Distance& __n, std::input_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
+      while (__first != __last)
+	{
+	  ++__first;
+	  ++__n;
+	}
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline void
+    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	       _Distance& __n, std::random_access_iterator_tag)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __n += __last - __first;
+    }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    distance(_InputIterator __first, _InputIterator __last,
+             _Distance& __n)
+    {
+      // concept requirements -- taken care of in __distance
+      __distance(__first, __last, __n, std::__iterator_category(__first));
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/malloc_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/malloc_allocator.h
new file mode 100644
index 0000000..83b65f1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/malloc_allocator.h
@@ -0,0 +1,152 @@
+// Allocator that wraps "C" malloc -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/malloc_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _MALLOC_ALLOCATOR_H
+#define _MALLOC_ALLOCATOR_H 1
+
+#include <cstdlib>
+#include <new>
+#include <bits/functexcept.h>
+#include <bits/move.h>
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::ptrdiff_t;
+
+  /**
+   *  @brief  An allocator that uses malloc.
+   *  @ingroup allocators
+   *
+   *  This is precisely the allocator defined in the C++ Standard. 
+   *    - all allocation calls malloc
+   *    - all deallocation calls free
+   */
+  template<typename _Tp>
+    class malloc_allocator
+    {
+    public:
+      typedef size_t     size_type;
+      typedef ptrdiff_t  difference_type;
+      typedef _Tp*       pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp&       reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp        value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef malloc_allocator<_Tp1> other; };
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. propagate_on_container_move_assignment
+      typedef std::true_type propagate_on_container_move_assignment;
+#endif
+
+      malloc_allocator() _GLIBCXX_USE_NOEXCEPT { }
+
+      malloc_allocator(const malloc_allocator&) _GLIBCXX_USE_NOEXCEPT { }
+
+      template<typename _Tp1>
+        malloc_allocator(const malloc_allocator<_Tp1>&)
+	_GLIBCXX_USE_NOEXCEPT { }
+
+      ~malloc_allocator() _GLIBCXX_USE_NOEXCEPT { }
+
+      pointer
+      address(reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      const_pointer
+      address(const_reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      // NB: __n is permitted to be 0.  The C++ standard says nothing
+      // about what the return value is when __n == 0.
+      pointer
+      allocate(size_type __n, const void* = 0)
+      {
+	if (__n > this->max_size())
+	  std::__throw_bad_alloc();
+
+	pointer __ret = static_cast<_Tp*>(std::malloc(__n * sizeof(_Tp)));
+	if (!__ret)
+	  std::__throw_bad_alloc();
+	return __ret;
+      }
+
+      // __p is not permitted to be a null pointer.
+      void
+      deallocate(pointer __p, size_type)
+      { std::free(static_cast<void*>(__p)); }
+
+      size_type
+      max_size() const _GLIBCXX_USE_NOEXCEPT 
+      { return size_t(-1) / sizeof(_Tp); }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p) { __p->~_Up(); }
+#else
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 402. wrong new expression in [some_] allocator::construct
+      void 
+      construct(pointer __p, const _Tp& __val) 
+      { ::new((void *)__p) value_type(__val); }
+
+      void 
+      destroy(pointer __p) { __p->~_Tp(); }
+#endif
+    };
+
+  template<typename _Tp>
+    inline bool
+    operator==(const malloc_allocator<_Tp>&, const malloc_allocator<_Tp>&)
+    { return true; }
+  
+  template<typename _Tp>
+    inline bool
+    operator!=(const malloc_allocator<_Tp>&, const malloc_allocator<_Tp>&)
+    { return false; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/memory b/gcc-4.9/libstdc++-v3/include/ext/memory
new file mode 100644
index 0000000..d36a5b4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/memory
@@ -0,0 +1,197 @@
+// Memory extensions -*- C++ -*-
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/memory
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset).
+ */
+
+#ifndef _EXT_MEMORY
+#define _EXT_MEMORY 1
+
+#pragma GCC system_header
+
+#include <memory>
+#include <bits/stl_tempbuf.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::ptrdiff_t;
+  using std::pair;
+  using std::__iterator_category;
+  using std::_Temporary_buffer;
+
+  template<typename _InputIter, typename _Size, typename _ForwardIter>
+    pair<_InputIter, _ForwardIter>
+    __uninitialized_copy_n(_InputIter __first, _Size __count,
+			   _ForwardIter __result, std::input_iterator_tag)
+    {
+      _ForwardIter __cur = __result;
+      __try
+	{
+	  for (; __count > 0 ; --__count, ++__first, ++__cur)
+	    std::_Construct(&*__cur, *__first);
+	  return pair<_InputIter, _ForwardIter>(__first, __cur);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__result, __cur);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _RandomAccessIter, typename _Size, typename _ForwardIter>
+    inline pair<_RandomAccessIter, _ForwardIter>
+    __uninitialized_copy_n(_RandomAccessIter __first, _Size __count,
+			   _ForwardIter __result,
+			   std::random_access_iterator_tag)
+    {
+      _RandomAccessIter __last = __first + __count;
+      return (pair<_RandomAccessIter, _ForwardIter>
+	      (__last, std::uninitialized_copy(__first, __last, __result)));
+    }
+
+  template<typename _InputIter, typename _Size, typename _ForwardIter>
+    inline pair<_InputIter, _ForwardIter>
+    __uninitialized_copy_n(_InputIter __first, _Size __count,
+			   _ForwardIter __result)
+    { return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result,
+					       __iterator_category(__first)); }
+
+  /**
+   *  @brief Copies the range [first,last) into result.
+   *  @param  __first  An input iterator.
+   *  @param  __count  Length
+   *  @param  __result An output iterator.
+   *  @return   __result + (__first + __count)
+   *  @ingroup SGIextensions
+   *
+   *  Like copy(), but does not require an initialized output range.
+  */
+  template<typename _InputIter, typename _Size, typename _ForwardIter>
+    inline pair<_InputIter, _ForwardIter>
+    uninitialized_copy_n(_InputIter __first, _Size __count,
+			 _ForwardIter __result)
+    { return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result,
+					       __iterator_category(__first)); }
+
+
+  // An alternative version of uninitialized_copy_n that constructs
+  // and destroys objects with a user-provided allocator.
+  template<typename _InputIter, typename _Size, typename _ForwardIter,
+           typename _Allocator>
+    pair<_InputIter, _ForwardIter>
+    __uninitialized_copy_n_a(_InputIter __first, _Size __count,
+			     _ForwardIter __result,
+			     _Allocator __alloc)
+    {
+      _ForwardIter __cur = __result;
+      __try
+	{
+	  for (; __count > 0 ; --__count, ++__first, ++__cur)
+	    __alloc.construct(&*__cur, *__first);
+	  return pair<_InputIter, _ForwardIter>(__first, __cur);
+	}
+      __catch(...)
+	{
+	  std::_Destroy(__result, __cur, __alloc);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _InputIter, typename _Size, typename _ForwardIter,
+           typename _Tp>
+    inline pair<_InputIter, _ForwardIter>
+    __uninitialized_copy_n_a(_InputIter __first, _Size __count,
+			     _ForwardIter __result,
+			     std::allocator<_Tp>)
+    {
+      return __gnu_cxx::uninitialized_copy_n(__first, __count, __result);
+    }
+
+  /**
+   *  This class provides similar behavior and semantics of the standard
+   *  functions get_temporary_buffer() and return_temporary_buffer(), but
+   *  encapsulated in a type vaguely resembling a standard container.
+   *
+   *  By default, a temporary_buffer<Iter> stores space for objects of
+   *  whatever type the Iter iterator points to.  It is constructed from a
+   *  typical [first,last) range, and provides the begin(), end(), size()
+   *  functions, as well as requested_size().  For non-trivial types, copies
+   *  of *first will be used to initialize the storage.
+   *
+   *  @c malloc is used to obtain underlying storage.
+   *
+   *  Like get_temporary_buffer(), not all the requested memory may be
+   *  available.  Ideally, the created buffer will be large enough to hold a
+   *  copy of [first,last), but if size() is less than requested_size(),
+   *  then this didn't happen.
+   *
+   *  @ingroup SGIextensions
+  */
+  template <class _ForwardIterator, class _Tp
+	    = typename std::iterator_traits<_ForwardIterator>::value_type >
+    struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
+    {
+      /// Requests storage large enough to hold a copy of [first,last).
+      temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+      : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) { }
+      
+      /// Destroys objects and frees storage.
+      ~temporary_buffer() { }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/mt_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/mt_allocator.h
new file mode 100644
index 0000000..0e6cfd9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/mt_allocator.h
@@ -0,0 +1,766 @@
+// MT-optimized allocator -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/mt_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _MT_ALLOCATOR_H
+#define _MT_ALLOCATOR_H 1
+
+#include <new>
+#include <cstdlib>
+#include <bits/functexcept.h>
+#include <ext/atomicity.h>
+#include <bits/move.h>
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::ptrdiff_t;
+
+  typedef void (*__destroy_handler)(void*);
+
+  /// Base class for pool object.
+  struct __pool_base
+  {
+    // Using short int as type for the binmap implies we are never
+    // caching blocks larger than 32768 with this allocator.
+    typedef unsigned short int _Binmap_type;
+
+    // Variables used to configure the behavior of the allocator,
+    // assigned and explained in detail below.
+    struct _Tune
+     {
+      // Compile time constants for the default _Tune values.
+      enum { _S_align = 8 };
+      enum { _S_max_bytes = 128 };
+      enum { _S_min_bin = 8 };
+      enum { _S_chunk_size = 4096 - 4 * sizeof(void*) };
+      enum { _S_max_threads = 4096 };
+      enum { _S_freelist_headroom = 10 };
+
+      // Alignment needed.
+      // NB: In any case must be >= sizeof(_Block_record), that
+      // is 4 on 32 bit machines and 8 on 64 bit machines.
+      size_t	_M_align;
+      
+      // Allocation requests (after round-up to power of 2) below
+      // this value will be handled by the allocator. A raw new/
+      // call will be used for requests larger than this value.
+      // NB: Must be much smaller than _M_chunk_size and in any
+      // case <= 32768.
+      size_t	_M_max_bytes; 
+
+      // Size in bytes of the smallest bin.
+      // NB: Must be a power of 2 and >= _M_align (and of course
+      // much smaller than _M_max_bytes).
+      size_t	_M_min_bin;
+
+      // In order to avoid fragmenting and minimize the number of
+      // new() calls we always request new memory using this
+      // value. Based on previous discussions on the libstdc++
+      // mailing list we have chosen the value below.
+      // See http://gcc.gnu.org/ml/libstdc++/2001-07/msg00077.html
+      // NB: At least one order of magnitude > _M_max_bytes. 
+      size_t	_M_chunk_size;
+
+      // The maximum number of supported threads. For
+      // single-threaded operation, use one. Maximum values will
+      // vary depending on details of the underlying system. (For
+      // instance, Linux 2.4.18 reports 4070 in
+      // /proc/sys/kernel/threads-max, while Linux 2.6.6 reports
+      // 65534)
+      size_t 	_M_max_threads;
+
+      // Each time a deallocation occurs in a threaded application
+      // we make sure that there are no more than
+      // _M_freelist_headroom % of used memory on the freelist. If
+      // the number of additional records is more than
+      // _M_freelist_headroom % of the freelist, we move these
+      // records back to the global pool.
+      size_t 	_M_freelist_headroom;
+      
+      // Set to true forces all allocations to use new().
+      bool 	_M_force_new; 
+      
+      explicit
+      _Tune()
+      : _M_align(_S_align), _M_max_bytes(_S_max_bytes), _M_min_bin(_S_min_bin),
+      _M_chunk_size(_S_chunk_size), _M_max_threads(_S_max_threads), 
+      _M_freelist_headroom(_S_freelist_headroom), 
+      _M_force_new(std::getenv("GLIBCXX_FORCE_NEW") ? true : false)
+      { }
+
+      explicit
+      _Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk, 
+	    size_t __maxthreads, size_t __headroom, bool __force) 
+      : _M_align(__align), _M_max_bytes(__maxb), _M_min_bin(__minbin),
+      _M_chunk_size(__chunk), _M_max_threads(__maxthreads),
+      _M_freelist_headroom(__headroom), _M_force_new(__force)
+      { }
+    };
+    
+    struct _Block_address
+    {
+      void* 			_M_initial;
+      _Block_address* 		_M_next;
+    };
+    
+    const _Tune&
+    _M_get_options() const
+    { return _M_options; }
+
+    void
+    _M_set_options(_Tune __t)
+    { 
+      if (!_M_init)
+	_M_options = __t;
+    }
+
+    bool
+    _M_check_threshold(size_t __bytes)
+    { return __bytes > _M_options._M_max_bytes || _M_options._M_force_new; }
+
+    size_t
+    _M_get_binmap(size_t __bytes)
+    { return _M_binmap[__bytes]; }
+
+    size_t
+    _M_get_align()
+    { return _M_options._M_align; }
+
+    explicit 
+    __pool_base() 
+    : _M_options(_Tune()), _M_binmap(0), _M_init(false) { }
+
+    explicit 
+    __pool_base(const _Tune& __options)
+    : _M_options(__options), _M_binmap(0), _M_init(false) { }
+
+  private:
+    explicit 
+    __pool_base(const __pool_base&);
+
+    __pool_base&
+    operator=(const __pool_base&);
+
+  protected:
+    // Configuration options.
+    _Tune 	       		_M_options;
+    
+    _Binmap_type* 		_M_binmap;
+
+    // Configuration of the pool object via _M_options can happen
+    // after construction but before initialization. After
+    // initialization is complete, this variable is set to true.
+    bool 			_M_init;
+  };
+
+
+  /**
+   *  @brief  Data describing the underlying memory pool, parameterized on
+   *  threading support.
+   */
+  template<bool _Thread>
+    class __pool;
+
+  /// Specialization for single thread.
+  template<>
+    class __pool<false> : public __pool_base
+    {
+    public:
+      union _Block_record
+      {
+	// Points to the block_record of the next free block.
+	_Block_record* 			_M_next;
+      };
+
+      struct _Bin_record
+      {
+	// An "array" of pointers to the first free block.
+	_Block_record**			_M_first;
+
+	// A list of the initial addresses of all allocated blocks.
+	_Block_address*		     	_M_address;
+      };
+      
+      void
+      _M_initialize_once()
+      {
+	if (__builtin_expect(_M_init == false, false))
+	  _M_initialize();
+      }
+
+      void
+      _M_destroy() throw();
+
+      char* 
+      _M_reserve_block(size_t __bytes, const size_t __thread_id);
+    
+      void
+      _M_reclaim_block(char* __p, size_t __bytes) throw ();
+    
+      size_t 
+      _M_get_thread_id() { return 0; }
+      
+      const _Bin_record&
+      _M_get_bin(size_t __which)
+      { return _M_bin[__which]; }
+      
+      void
+      _M_adjust_freelist(const _Bin_record&, _Block_record*, size_t)
+      { }
+
+      explicit __pool() 
+      : _M_bin(0), _M_bin_size(1) { }
+
+      explicit __pool(const __pool_base::_Tune& __tune) 
+      : __pool_base(__tune), _M_bin(0), _M_bin_size(1) { }
+
+    private:
+      // An "array" of bin_records each of which represents a specific
+      // power of 2 size. Memory to this "array" is allocated in
+      // _M_initialize().
+      _Bin_record*		 _M_bin;
+      
+      // Actual value calculated in _M_initialize().
+      size_t 	       	     	_M_bin_size;     
+
+      void
+      _M_initialize();
+  };
+ 
+#ifdef __GTHREADS
+  /// Specialization for thread enabled, via gthreads.h.
+  template<>
+    class __pool<true> : public __pool_base
+    {
+    public:
+      // Each requesting thread is assigned an id ranging from 1 to
+      // _S_max_threads. Thread id 0 is used as a global memory pool.
+      // In order to get constant performance on the thread assignment
+      // routine, we keep a list of free ids. When a thread first
+      // requests memory we remove the first record in this list and
+      // stores the address in a __gthread_key. When initializing the
+      // __gthread_key we specify a destructor. When this destructor
+      // (i.e. the thread dies) is called, we return the thread id to
+      // the front of this list.
+      struct _Thread_record
+      {
+	// Points to next free thread id record. NULL if last record in list.
+	_Thread_record*			_M_next;
+	
+	// Thread id ranging from 1 to _S_max_threads.
+	size_t                          _M_id;
+      };
+      
+      union _Block_record
+      {
+	// Points to the block_record of the next free block.
+	_Block_record*			_M_next;
+	
+	// The thread id of the thread which has requested this block.
+	size_t                          _M_thread_id;
+      };
+      
+      struct _Bin_record
+      {
+	// An "array" of pointers to the first free block for each
+	// thread id. Memory to this "array" is allocated in
+	// _S_initialize() for _S_max_threads + global pool 0.
+	_Block_record**			_M_first;
+	
+	// A list of the initial addresses of all allocated blocks.
+	_Block_address*		     	_M_address;
+
+	// An "array" of counters used to keep track of the amount of
+	// blocks that are on the freelist/used for each thread id.
+	// - Note that the second part of the allocated _M_used "array"
+	//   actually hosts (atomic) counters of reclaimed blocks:  in
+	//   _M_reserve_block and in _M_reclaim_block those numbers are
+	//   subtracted from the first ones to obtain the actual size
+	//   of the "working set" of the given thread.
+	// - Memory to these "arrays" is allocated in _S_initialize()
+	//   for _S_max_threads + global pool 0.
+	size_t*				_M_free;
+	size_t*			        _M_used;
+	
+	// Each bin has its own mutex which is used to ensure data
+	// integrity while changing "ownership" on a block.  The mutex
+	// is initialized in _S_initialize().
+	__gthread_mutex_t*              _M_mutex;
+      };
+      
+      // XXX GLIBCXX_ABI Deprecated
+      void
+      _M_initialize(__destroy_handler);
+
+      void
+      _M_initialize_once()
+      {
+	if (__builtin_expect(_M_init == false, false))
+	  _M_initialize();
+      }
+
+      void
+      _M_destroy() throw();
+
+      char* 
+      _M_reserve_block(size_t __bytes, const size_t __thread_id);
+    
+      void
+      _M_reclaim_block(char* __p, size_t __bytes) throw ();
+    
+      const _Bin_record&
+      _M_get_bin(size_t __which)
+      { return _M_bin[__which]; }
+      
+      void
+      _M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block, 
+			 size_t __thread_id)
+      {
+	if (__gthread_active_p())
+	  {
+	    __block->_M_thread_id = __thread_id;
+	    --__bin._M_free[__thread_id];
+	    ++__bin._M_used[__thread_id];
+	  }
+      }
+
+      // XXX GLIBCXX_ABI Deprecated
+      _GLIBCXX_CONST void 
+      _M_destroy_thread_key(void*) throw ();
+
+      size_t 
+      _M_get_thread_id();
+
+      explicit __pool() 
+      : _M_bin(0), _M_bin_size(1), _M_thread_freelist(0) 
+      { }
+
+      explicit __pool(const __pool_base::_Tune& __tune) 
+      : __pool_base(__tune), _M_bin(0), _M_bin_size(1), 
+	_M_thread_freelist(0) 
+      { }
+
+    private:
+      // An "array" of bin_records each of which represents a specific
+      // power of 2 size. Memory to this "array" is allocated in
+      // _M_initialize().
+      _Bin_record*		_M_bin;
+
+      // Actual value calculated in _M_initialize().
+      size_t 	       	     	_M_bin_size;
+
+      _Thread_record* 		_M_thread_freelist;
+      void*			_M_thread_freelist_initial;
+
+      void
+      _M_initialize();
+    };
+#endif
+
+  template<template <bool> class _PoolTp, bool _Thread>
+    struct __common_pool
+    {
+      typedef _PoolTp<_Thread> 		pool_type;
+      
+      static pool_type&
+      _S_get_pool()
+      { 
+	static pool_type _S_pool;
+	return _S_pool;
+      }
+    };
+
+  template<template <bool> class _PoolTp, bool _Thread>
+    struct __common_pool_base;
+
+  template<template <bool> class _PoolTp>
+    struct __common_pool_base<_PoolTp, false> 
+    : public __common_pool<_PoolTp, false>
+    {
+      using  __common_pool<_PoolTp, false>::_S_get_pool;
+
+      static void
+      _S_initialize_once()
+      {
+	static bool __init;
+	if (__builtin_expect(__init == false, false))
+	  {
+	    _S_get_pool()._M_initialize_once(); 
+	    __init = true;
+	  }
+      }
+    };
+
+#ifdef __GTHREADS
+  template<template <bool> class _PoolTp>
+    struct __common_pool_base<_PoolTp, true>
+    : public __common_pool<_PoolTp, true>
+    {
+      using  __common_pool<_PoolTp, true>::_S_get_pool;
+      
+      static void
+      _S_initialize() 
+      { _S_get_pool()._M_initialize_once(); }
+
+      static void
+      _S_initialize_once()
+      { 
+	static bool __init;
+	if (__builtin_expect(__init == false, false))
+	  {
+	    if (__gthread_active_p())
+	      {
+		// On some platforms, __gthread_once_t is an aggregate.
+		static __gthread_once_t __once = __GTHREAD_ONCE_INIT;
+		__gthread_once(&__once, _S_initialize);
+	      }
+
+	    // Double check initialization. May be necessary on some
+	    // systems for proper construction when not compiling with
+	    // thread flags.
+	    _S_get_pool()._M_initialize_once(); 
+	    __init = true;
+	  }
+      }
+    };
+#endif
+
+  /// Policy for shared __pool objects.
+  template<template <bool> class _PoolTp, bool _Thread>
+    struct __common_pool_policy : public __common_pool_base<_PoolTp, _Thread>
+    {
+      template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp, 
+	       bool _Thread1 = _Thread>
+        struct _M_rebind
+        { typedef __common_pool_policy<_PoolTp1, _Thread1> other; };
+
+      using  __common_pool_base<_PoolTp, _Thread>::_S_get_pool;
+      using  __common_pool_base<_PoolTp, _Thread>::_S_initialize_once;
+  };
+ 
+
+  template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
+    struct __per_type_pool
+    {
+      typedef _Tp 			value_type;
+      typedef _PoolTp<_Thread> 		pool_type;
+      
+      static pool_type&
+      _S_get_pool()
+      { 
+	// Sane defaults for the _PoolTp.
+	typedef typename pool_type::_Block_record _Block_record;
+	const static size_t __a = (__alignof__(_Tp) >= sizeof(_Block_record)
+				   ? __alignof__(_Tp) : sizeof(_Block_record));
+
+	typedef typename __pool_base::_Tune _Tune;
+	static _Tune _S_tune(__a, sizeof(_Tp) * 64,
+			     sizeof(_Tp) * 2 >= __a ? sizeof(_Tp) * 2 : __a,
+			     sizeof(_Tp) * size_t(_Tune::_S_chunk_size),
+			     _Tune::_S_max_threads,
+			     _Tune::_S_freelist_headroom,
+			     std::getenv("GLIBCXX_FORCE_NEW") ? true : false);
+	static pool_type _S_pool(_S_tune);
+	return _S_pool;
+      }
+    };
+
+  template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
+    struct __per_type_pool_base;
+
+  template<typename _Tp, template <bool> class _PoolTp>
+    struct __per_type_pool_base<_Tp, _PoolTp, false> 
+    : public __per_type_pool<_Tp, _PoolTp, false> 
+    {
+      using  __per_type_pool<_Tp, _PoolTp, false>::_S_get_pool;
+
+      static void
+      _S_initialize_once()
+      {
+	static bool __init;
+	if (__builtin_expect(__init == false, false))
+	  {
+	    _S_get_pool()._M_initialize_once(); 
+	    __init = true;
+	  }
+      }
+    };
+
+ #ifdef __GTHREADS
+ template<typename _Tp, template <bool> class _PoolTp>
+    struct __per_type_pool_base<_Tp, _PoolTp, true> 
+    : public __per_type_pool<_Tp, _PoolTp, true> 
+    {
+      using  __per_type_pool<_Tp, _PoolTp, true>::_S_get_pool;
+
+      static void
+      _S_initialize() 
+      { _S_get_pool()._M_initialize_once(); }
+
+      static void
+      _S_initialize_once()
+      { 
+	static bool __init;
+	if (__builtin_expect(__init == false, false))
+	  {
+	    if (__gthread_active_p())
+	      {
+		// On some platforms, __gthread_once_t is an aggregate.
+		static __gthread_once_t __once = __GTHREAD_ONCE_INIT;
+		__gthread_once(&__once, _S_initialize);
+	      }
+
+	    // Double check initialization. May be necessary on some
+	    // systems for proper construction when not compiling with
+	    // thread flags.
+	    _S_get_pool()._M_initialize_once(); 
+	    __init = true;
+	  }
+      }
+    };
+#endif
+
+  /// Policy for individual __pool objects.
+  template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
+    struct __per_type_pool_policy 
+    : public __per_type_pool_base<_Tp, _PoolTp, _Thread>
+    {
+      template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp, 
+	       bool _Thread1 = _Thread>
+        struct _M_rebind
+        { typedef __per_type_pool_policy<_Tp1, _PoolTp1, _Thread1> other; };
+
+      using  __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_get_pool;
+      using  __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_initialize_once;
+  };
+
+
+  /// Base class for _Tp dependent member functions.
+  template<typename _Tp>
+    class __mt_alloc_base 
+    {
+    public:
+      typedef size_t                    size_type;
+      typedef ptrdiff_t                 difference_type;
+      typedef _Tp*                      pointer;
+      typedef const _Tp*                const_pointer;
+      typedef _Tp&                      reference;
+      typedef const _Tp&                const_reference;
+      typedef _Tp                       value_type;
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. propagate_on_container_move_assignment
+      typedef std::true_type propagate_on_container_move_assignment;
+#endif
+
+      pointer
+      address(reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      const_pointer
+      address(const_reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      size_type
+      max_size() const _GLIBCXX_USE_NOEXCEPT 
+      { return size_t(-1) / sizeof(_Tp); }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p) { __p->~_Up(); }
+#else
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 402. wrong new expression in [some_] allocator::construct
+      void 
+      construct(pointer __p, const _Tp& __val) 
+      { ::new((void *)__p) _Tp(__val); }
+
+      void 
+      destroy(pointer __p) { __p->~_Tp(); }
+#endif
+    };
+
+#ifdef __GTHREADS
+#define __thread_default true
+#else
+#define __thread_default false
+#endif
+
+  /**
+   *  @brief  This is a fixed size (power of 2) allocator which - when
+   *  compiled with thread support - will maintain one freelist per
+   *  size per thread plus a @a global one. Steps are taken to limit
+   *  the per thread freelist sizes (by returning excess back to
+   *  the @a global list).
+   *  @ingroup allocators
+   *
+   *  Further details:
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch32.html
+   */
+  template<typename _Tp, 
+	   typename _Poolp = __common_pool_policy<__pool, __thread_default> >
+    class __mt_alloc : public __mt_alloc_base<_Tp>
+    {
+    public:
+      typedef size_t                    	size_type;
+      typedef ptrdiff_t                 	difference_type;
+      typedef _Tp*                      	pointer;
+      typedef const _Tp*                	const_pointer;
+      typedef _Tp&                      	reference;
+      typedef const _Tp&                	const_reference;
+      typedef _Tp                       	value_type;
+      typedef _Poolp      			__policy_type;
+      typedef typename _Poolp::pool_type	__pool_type;
+
+      template<typename _Tp1, typename _Poolp1 = _Poolp>
+        struct rebind
+        { 
+	  typedef typename _Poolp1::template _M_rebind<_Tp1>::other pol_type;
+	  typedef __mt_alloc<_Tp1, pol_type> other;
+	};
+
+      __mt_alloc() _GLIBCXX_USE_NOEXCEPT { }
+
+      __mt_alloc(const __mt_alloc&) _GLIBCXX_USE_NOEXCEPT { }
+
+      template<typename _Tp1, typename _Poolp1>
+        __mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) _GLIBCXX_USE_NOEXCEPT { }
+
+      ~__mt_alloc() _GLIBCXX_USE_NOEXCEPT { }
+
+      pointer
+      allocate(size_type __n, const void* = 0);
+
+      void
+      deallocate(pointer __p, size_type __n);
+
+      const __pool_base::_Tune
+      _M_get_options()
+      { 
+	// Return a copy, not a reference, for external consumption.
+	return __policy_type::_S_get_pool()._M_get_options();
+      }
+      
+      void
+      _M_set_options(__pool_base::_Tune __t)
+      { __policy_type::_S_get_pool()._M_set_options(__t); }
+    };
+
+  template<typename _Tp, typename _Poolp>
+    typename __mt_alloc<_Tp, _Poolp>::pointer
+    __mt_alloc<_Tp, _Poolp>::
+    allocate(size_type __n, const void*)
+    {
+      if (__n > this->max_size())
+	std::__throw_bad_alloc();
+
+      __policy_type::_S_initialize_once();
+
+      // Requests larger than _M_max_bytes are handled by operator
+      // new/delete directly.
+      __pool_type& __pool = __policy_type::_S_get_pool();
+      const size_t __bytes = __n * sizeof(_Tp);
+      if (__pool._M_check_threshold(__bytes))
+	{
+	  void* __ret = ::operator new(__bytes);
+	  return static_cast<_Tp*>(__ret);
+	}
+      
+      // Round up to power of 2 and figure out which bin to use.
+      const size_t __which = __pool._M_get_binmap(__bytes);
+      const size_t __thread_id = __pool._M_get_thread_id();
+      
+      // Find out if we have blocks on our freelist.  If so, go ahead
+      // and use them directly without having to lock anything.
+      char* __c;
+      typedef typename __pool_type::_Bin_record _Bin_record;
+      const _Bin_record& __bin = __pool._M_get_bin(__which);
+      if (__bin._M_first[__thread_id])
+	{
+	  // Already reserved.
+	  typedef typename __pool_type::_Block_record _Block_record;
+	  _Block_record* __block = __bin._M_first[__thread_id];
+	  __bin._M_first[__thread_id] = __block->_M_next;
+	  
+	  __pool._M_adjust_freelist(__bin, __block, __thread_id);
+	  __c = reinterpret_cast<char*>(__block) + __pool._M_get_align();
+	}
+      else
+	{
+	  // Null, reserve.
+	  __c = __pool._M_reserve_block(__bytes, __thread_id);
+	}
+      return static_cast<_Tp*>(static_cast<void*>(__c));
+    }
+  
+  template<typename _Tp, typename _Poolp>
+    void
+    __mt_alloc<_Tp, _Poolp>::
+    deallocate(pointer __p, size_type __n)
+    {
+      if (__builtin_expect(__p != 0, true))
+	{
+	  // Requests larger than _M_max_bytes are handled by
+	  // operators new/delete directly.
+	  __pool_type& __pool = __policy_type::_S_get_pool();
+	  const size_t __bytes = __n * sizeof(_Tp);
+	  if (__pool._M_check_threshold(__bytes))
+	    ::operator delete(__p);
+	  else
+	    __pool._M_reclaim_block(reinterpret_cast<char*>(__p), __bytes);
+	}
+    }
+  
+  template<typename _Tp, typename _Poolp>
+    inline bool
+    operator==(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
+    { return true; }
+  
+  template<typename _Tp, typename _Poolp>
+    inline bool
+    operator!=(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
+    { return false; }
+
+#undef __thread_default
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/new_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/new_allocator.h
new file mode 100644
index 0000000..996a219
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/new_allocator.h
@@ -0,0 +1,150 @@
+// Allocator that wraps operator new -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/new_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _NEW_ALLOCATOR_H
+#define _NEW_ALLOCATOR_H 1
+
+#include <bits/c++config.h>
+#include <new>
+#include <bits/functexcept.h>
+#include <bits/move.h>
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::ptrdiff_t;
+
+  /**
+   *  @brief  An allocator that uses global new, as per [20.4].
+   *  @ingroup allocators
+   *
+   *  This is precisely the allocator defined in the C++ Standard. 
+   *    - all allocation calls operator new
+   *    - all deallocation calls operator delete
+   *
+   *  @tparam  _Tp  Type of allocated object.
+   */
+  template<typename _Tp>
+    class new_allocator
+    {
+    public:
+      typedef size_t     size_type;
+      typedef ptrdiff_t  difference_type;
+      typedef _Tp*       pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp&       reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp        value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef new_allocator<_Tp1> other; };
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. propagate_on_container_move_assignment
+      typedef std::true_type propagate_on_container_move_assignment;
+#endif
+
+      new_allocator() _GLIBCXX_USE_NOEXCEPT { }
+
+      new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { }
+
+      template<typename _Tp1>
+        new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
+
+      ~new_allocator() _GLIBCXX_USE_NOEXCEPT { }
+
+      pointer
+      address(reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      const_pointer
+      address(const_reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      // NB: __n is permitted to be 0.  The C++ standard says nothing
+      // about what the return value is when __n == 0.
+      pointer
+      allocate(size_type __n, const void* = 0)
+      { 
+	if (__n > this->max_size())
+	  std::__throw_bad_alloc();
+
+	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+      }
+
+      // __p is not permitted to be a null pointer.
+      void
+      deallocate(pointer __p, size_type)
+      { ::operator delete(__p); }
+
+      size_type
+      max_size() const _GLIBCXX_USE_NOEXCEPT
+      { return size_t(-1) / sizeof(_Tp); }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p) { __p->~_Up(); }
+#else
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 402. wrong new expression in [some_] allocator::construct
+      void 
+      construct(pointer __p, const _Tp& __val) 
+      { ::new((void *)__p) _Tp(__val); }
+
+      void 
+      destroy(pointer __p) { __p->~_Tp(); }
+#endif
+    };
+
+  template<typename _Tp>
+    inline bool
+    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return true; }
+  
+  template<typename _Tp>
+    inline bool
+    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return false; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/numeric b/gcc-4.9/libstdc++-v3/include/ext/numeric
new file mode 100644
index 0000000..d957420
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/numeric
@@ -0,0 +1,152 @@
+// Numeric extensions -*- C++ -*-
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/numeric
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset). 
+ */
+
+#ifndef _EXT_NUMERIC
+#define _EXT_NUMERIC 1
+
+#pragma GCC system_header
+
+#include <bits/concept_check.h>
+#include <numeric>
+
+#include <ext/functional> // For identity_element
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Returns __x ** __n, where __n >= 0.  _Note that "multiplication"
+  // is required to be associative, but not necessarily commutative.
+  template<typename _Tp, typename _Integer, typename _MonoidOperation>
+    _Tp
+    __power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
+    {
+      if (__n == 0)
+	return identity_element(__monoid_op);
+      else
+	{
+	  while ((__n & 1) == 0)
+	    {
+	      __n >>= 1;
+	      __x = __monoid_op(__x, __x);
+	    }
+
+	  _Tp __result = __x;
+	  __n >>= 1;
+	  while (__n != 0)
+	    {
+	      __x = __monoid_op(__x, __x);
+	      if ((__n & 1) != 0)
+		__result = __monoid_op(__result, __x);
+	      __n >>= 1;
+	    }
+	  return __result;
+	}
+    }
+
+  template<typename _Tp, typename _Integer>
+    inline _Tp
+    __power(_Tp __x, _Integer __n)
+    { return __power(__x, __n, std::multiplies<_Tp>()); }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  // Alias for the internal name __power.  Note that power is an extension,
+  // not part of the C++ standard.
+  template<typename _Tp, typename _Integer, typename _MonoidOperation>
+    inline _Tp
+    power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
+    { return __power(__x, __n, __monoid_op); }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  template<typename _Tp, typename _Integer>
+    inline _Tp
+    power(_Tp __x, _Integer __n)
+    { return __power(__x, __n); }
+
+#if __cplusplus >= 201103L
+  using std::iota;
+#else
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+  */
+  // iota is not part of the C++ standard.  It is an extension.
+  template<typename _ForwardIter, typename _Tp>
+    void
+    iota(_ForwardIter __first, _ForwardIter __last, _Tp __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+      __glibcxx_function_requires(_ConvertibleConcept<_Tp,
+	    typename std::iterator_traits<_ForwardIter>::value_type>)
+
+      while (__first != __last)
+	*__first++ = __value++;
+    }
+#endif  // C++11
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/numeric_traits.h b/gcc-4.9/libstdc++-v3/include/ext/numeric_traits.h
new file mode 100644
index 0000000..72941a5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/numeric_traits.h
@@ -0,0 +1,138 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/numeric_traits.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _EXT_NUMERIC_TRAITS
+#define _EXT_NUMERIC_TRAITS 1
+
+#pragma GCC system_header
+
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Compile time constants for builtin types.
+  // Sadly std::numeric_limits member functions cannot be used for this.
+#define __glibcxx_signed(_Tp) ((_Tp)(-1) < 0)
+#define __glibcxx_digits(_Tp) \
+  (sizeof(_Tp) * __CHAR_BIT__ - __glibcxx_signed(_Tp))
+
+#define __glibcxx_min(_Tp) \
+  (__glibcxx_signed(_Tp) ? (_Tp)1 << __glibcxx_digits(_Tp) : (_Tp)0)
+
+#define __glibcxx_max(_Tp) \
+  (__glibcxx_signed(_Tp) ? \
+   (((((_Tp)1 << (__glibcxx_digits(_Tp) - 1)) - 1) << 1) + 1) : ~(_Tp)0)
+
+  template<typename _Value>
+    struct __numeric_traits_integer
+    {
+      // Only integers for initialization of member constant.
+      static const _Value __min = __glibcxx_min(_Value);
+      static const _Value __max = __glibcxx_max(_Value);
+
+      // NB: these two also available in std::numeric_limits as compile
+      // time constants, but <limits> is big and we avoid including it.
+      static const bool __is_signed = __glibcxx_signed(_Value);
+      static const int __digits = __glibcxx_digits(_Value);      
+    };
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__min;
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__max;
+
+  template<typename _Value>
+    const bool __numeric_traits_integer<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_integer<_Value>::__digits;
+
+#undef __glibcxx_signed
+#undef __glibcxx_digits
+#undef __glibcxx_min
+#undef __glibcxx_max
+
+#define __glibcxx_floating(_Tp, _Fval, _Dval, _LDval) \
+  (std::__are_same<_Tp, float>::__value ? _Fval \
+   : std::__are_same<_Tp, double>::__value ? _Dval : _LDval)
+
+#define __glibcxx_max_digits10(_Tp) \
+  (2 + __glibcxx_floating(_Tp, __FLT_MANT_DIG__, __DBL_MANT_DIG__, \
+			  __LDBL_MANT_DIG__) * 643L / 2136)
+
+#define __glibcxx_digits10(_Tp) \
+  __glibcxx_floating(_Tp, __FLT_DIG__, __DBL_DIG__, __LDBL_DIG__)
+
+#define __glibcxx_max_exponent10(_Tp) \
+  __glibcxx_floating(_Tp, __FLT_MAX_10_EXP__, __DBL_MAX_10_EXP__, \
+		     __LDBL_MAX_10_EXP__)
+
+  template<typename _Value>
+    struct __numeric_traits_floating
+    {
+      // Only floating point types. See N1822. 
+      static const int __max_digits10 = __glibcxx_max_digits10(_Value);
+
+      // See above comment...
+      static const bool __is_signed = true;
+      static const int __digits10 = __glibcxx_digits10(_Value);
+      static const int __max_exponent10 = __glibcxx_max_exponent10(_Value);
+    };
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_digits10;
+
+  template<typename _Value>
+    const bool __numeric_traits_floating<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__digits10;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_exponent10;
+
+  template<typename _Value>
+    struct __numeric_traits
+    : public __conditional_type<std::__is_integer<_Value>::__value,
+				__numeric_traits_integer<_Value>,
+				__numeric_traits_floating<_Value> >::__type
+    { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#undef __glibcxx_floating
+#undef __glibcxx_max_digits10
+#undef __glibcxx_digits10
+#undef __glibcxx_max_exponent10
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp
new file mode 100644
index 0000000..dae2e41
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp
@@ -0,0 +1,861 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file assoc_container.hpp
+ * Contains associative containers.
+ */
+
+#ifndef PB_DS_ASSOC_CNTNR_HPP
+#define PB_DS_ASSOC_CNTNR_HPP
+
+#include <bits/c++config.h>
+#include <ext/typelist.h>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <ext/pb_ds/detail/container_base_dispatch.hpp>
+#include <ext/pb_ds/detail/branch_policy/traits.hpp>
+
+namespace __gnu_pbds
+{
+  /**
+   *  @defgroup containers-pbds Containers
+   *  @ingroup pbds
+   *  @{
+   */
+
+  /**
+   *  @defgroup hash-based Hash-Based
+   *  @ingroup containers-pbds
+   *  @{
+   */
+#define PB_DS_HASH_BASE \
+  detail::container_base_dispatch<Key, Mapped, _Alloc, Tag, \
+    typename __gnu_cxx::typelist::append< \
+    typename __gnu_cxx::typelist::create4<Hash_Fn, Eq_Fn, Resize_Policy, \
+    detail::integral_constant<int, Store_Hash> >::type, Policy_Tl>::type>::type
+
+  /**
+   *  @defgroup hash-detail Base and Policy Classes
+   *  @ingroup hash-based
+   */
+
+  /**
+   *  A hashed container abstraction.
+   *
+   *  @tparam Key 	    	Key type.
+   *  @tparam Mapped 	    	Map type.
+   *  @tparam Hash_Fn	    	Hashing functor.
+   *  @tparam Eq_Fn	    	Equal functor.
+   *  @tparam Resize_Policy 	Resizes hash.
+   *  @tparam Store_Hash    	Indicates whether the hash value
+   *                            will be stored along with each key.
+   *  @tparam Tag 	    	Instantiating data structure type,
+   *			    	see container_tag.
+   *  @tparam Policy_TL	    	Policy typelist.
+   *  @tparam _Alloc 	    	Allocator type.
+   *
+   *  Base is dispatched at compile time via Tag, from the following
+   *  choices: cc_hash_tag, gp_hash_tag, and descendants of basic_hash_tag.
+   *
+   *  Base choices are: detail::cc_ht_map, detail::gp_ht_map
+   */
+  template<typename Key,
+	   typename Mapped,
+	   typename Hash_Fn,
+	   typename Eq_Fn,
+	   typename Resize_Policy,
+	   bool Store_Hash,
+	   typename Tag,
+	   typename Policy_Tl,
+	   typename _Alloc>
+  class basic_hash_table : public PB_DS_HASH_BASE
+  {
+  private:
+    typedef typename PB_DS_HASH_BASE 		base_type;
+
+  public:
+    virtual
+    ~basic_hash_table() { }
+
+  protected:
+    basic_hash_table() { }
+
+    basic_hash_table(const basic_hash_table& other)
+    : base_type((const base_type&)other) { }
+
+    template<typename T0>
+      basic_hash_table(T0 t0) : base_type(t0) { }
+
+    template<typename T0, typename T1>
+      basic_hash_table(T0 t0, T1 t1) : base_type(t0, t1) { }
+
+    template<typename T0, typename T1, typename T2>
+      basic_hash_table(T0 t0, T1 t1, T2 t2) : base_type(t0, t1, t2) { }
+
+    template<typename T0, typename T1, typename T2, typename T3>
+      basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3)
+      : base_type(t0, t1, t2, t3) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4>
+      basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4)
+      : base_type(t0, t1, t2, t3, t4) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	     typename T5>
+      basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+      : base_type(t0, t1, t2, t3, t4, t5) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	     typename T5, typename T6>
+      basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+      : base_type(t0, t1, t2, t3, t4, t5, t6) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	     typename T5, typename T6, typename T7>
+      basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
+      : base_type(t0, t1, t2, t3, t4, t5, t6, t7) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	     typename T5, typename T6, typename T7, typename T8>
+      basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6,
+		       T7 t7, T8 t8)
+      : base_type(t0, t1, t2, t3, t4, t5, t6, t7, t8)
+      { }
+
+  private:
+    basic_hash_table&
+    operator=(const base_type&);
+  };
+
+#undef PB_DS_HASH_BASE
+
+
+#define PB_DS_CC_HASH_BASE \
+  basic_hash_table<Key, Mapped,	Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, \
+		   cc_hash_tag,	\
+	  typename __gnu_cxx::typelist::create1<Comb_Hash_Fn>::type, _Alloc>
+
+
+  /**
+   *  A collision-chaining hash-based associative container.
+   *
+   *  @tparam Key 	    	Key type.
+   *  @tparam Mapped 	    	Map type.
+   *  @tparam Hash_Fn	    	Hashing functor.
+   *  @tparam Eq_Fn	    	Equal functor.
+   *  @tparam Comb_Hash_Fn	Combining hash functor.
+   *                            If Hash_Fn is not null_type, then this
+   *                            is the ranged-hash functor; otherwise,
+   *                            this is the range-hashing functor.
+   *                    XXX(See Design::Hash-Based Containers::Hash Policies.)
+   *  @tparam Resize_Policy 	Resizes hash.
+   *  @tparam Store_Hash    	Indicates whether the hash value
+   *                            will be stored along with each key.
+   *                            If Hash_Fn is null_type, then the
+   *                            container will not compile if this
+   *                            value is true
+   *  @tparam _Alloc 	    	Allocator type.
+   *
+   *  Base tag choices are: 	cc_hash_tag.
+   *
+   *  Base is basic_hash_table.
+   */
+  template<typename Key,
+	   typename Mapped,
+	   typename Hash_Fn = typename detail::default_hash_fn<Key>::type,
+	   typename Eq_Fn = typename detail::default_eq_fn<Key>::type,
+	   typename Comb_Hash_Fn = detail::default_comb_hash_fn::type,
+	   typename Resize_Policy = typename detail::default_resize_policy<Comb_Hash_Fn>::type,
+	   bool Store_Hash = detail::default_store_hash,
+	   typename _Alloc = std::allocator<char> >
+  class cc_hash_table :  public PB_DS_CC_HASH_BASE
+  {
+  private:
+    typedef PB_DS_CC_HASH_BASE 			base_type;
+
+  public:
+    typedef cc_hash_tag	       			container_category;
+    typedef Hash_Fn 				hash_fn;
+    typedef Eq_Fn 				eq_fn;
+    typedef Resize_Policy 			resize_policy;
+    typedef Comb_Hash_Fn 			comb_hash_fn;
+
+    /// Default constructor.
+    cc_hash_table() { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the Hash_Fn object of the container object.
+    cc_hash_table(const hash_fn& h)
+    : base_type(h) { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object, and
+    /// r_eq_fn will be copied by the eq_fn object of the container
+    /// object.
+    cc_hash_table(const hash_fn& h, const eq_fn& e)
+    : base_type(h, e) { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object, r_eq_fn
+    /// will be copied by the eq_fn object of the container object,
+    /// and r_comb_hash_fn will be copied by the comb_hash_fn object
+    /// of the container object.
+    cc_hash_table(const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch)
+    : base_type(h, e, ch) { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object, r_eq_fn
+    /// will be copied by the eq_fn object of the container object,
+    /// r_comb_hash_fn will be copied by the comb_hash_fn object of
+    /// the container object, and r_resize_policy will be copied by
+    /// the resize_policy object of the container object.
+    cc_hash_table(const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch,
+		  const resize_policy& rp)
+    : base_type(h, e, ch, rp) { }
+
+    /// Constructor taking __iterators to a range of value_types. The
+    /// value_types between first_it and last_it will be inserted into
+    /// the container object.
+    template<typename It>
+    cc_hash_table(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects. The value_types between first_it and
+    /// last_it will be inserted into the container object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h)
+    : base_type(h)
+    { this->copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object,
+    /// and r_eq_fn will be copied by the eq_fn object of the
+    /// container object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e)
+    : base_type(h, e)
+    { this->copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object,
+    /// r_eq_fn will be copied by the eq_fn object of the container
+    /// object, and r_comb_hash_fn will be copied by the comb_hash_fn
+    /// object of the container object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e,
+		  const comb_hash_fn& ch)
+    : base_type(h, e, ch)
+    { this->copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object,
+    /// r_eq_fn will be copied by the eq_fn object of the container
+    /// object, r_comb_hash_fn will be copied by the comb_hash_fn
+    /// object of the container object, and r_resize_policy will be
+    /// copied by the resize_policy object of the container object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e,
+		  const comb_hash_fn& ch, const resize_policy& rp)
+    : base_type(h, e, ch, rp)
+    { this->copy_from_range(first, last); }
+
+    cc_hash_table(const cc_hash_table& other)
+    : base_type((const base_type&)other)
+    { }
+
+    virtual
+    ~cc_hash_table() { }
+
+    cc_hash_table&
+    operator=(const cc_hash_table& other)
+    {
+      if (this != &other)
+	{
+	  cc_hash_table tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(cc_hash_table& other)
+    { base_type::swap(other); }
+  };
+
+#undef PB_DS_CC_HASH_BASE
+
+
+#define PB_DS_GP_HASH_BASE \
+  basic_hash_table<Key, Mapped,	Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, \
+		   gp_hash_tag, \
+  typename __gnu_cxx::typelist::create2<Comb_Probe_Fn, Probe_Fn>::type, _Alloc>
+
+
+  /**
+   *  A general-probing hash-based associative container.
+   *
+   *  @tparam Key 	    	Key type.
+   *  @tparam Mapped 	    	Map type.
+   *  @tparam Hash_Fn	    	Hashing functor.
+   *  @tparam Eq_Fn	    	Equal functor.
+   *  @tparam Comb_Probe_Fn	Combining probe functor.
+   *                            If Hash_Fn is not null_type, then this
+   *                            is the ranged-probe functor; otherwise,
+   *                            this is the range-hashing functor.
+   *                    XXX See Design::Hash-Based Containers::Hash Policies.
+   *  @tparam Probe_Fn		Probe functor.
+   *  @tparam Resize_Policy 	Resizes hash.
+   *  @tparam Store_Hash    	Indicates whether the hash value
+   *                            will be stored along with each key.
+   *                            If Hash_Fn is null_type, then the
+   *                            container will not compile if this
+   *                            value is true
+   *  @tparam _Alloc 	    	Allocator type.
+   *
+   *  Base tag choices are: 	gp_hash_tag.
+   *
+   *  Base is basic_hash_table.
+   */
+  template<typename Key,
+	   typename Mapped,
+	   typename Hash_Fn = typename detail::default_hash_fn<Key>::type,
+	   typename Eq_Fn = typename detail::default_eq_fn<Key>::type,
+	   typename Comb_Probe_Fn = detail::default_comb_hash_fn::type,
+	   typename Probe_Fn = typename detail::default_probe_fn<Comb_Probe_Fn>::type,
+	   typename Resize_Policy = typename detail::default_resize_policy<Comb_Probe_Fn>::type,
+	   bool Store_Hash = detail::default_store_hash,
+	   typename _Alloc = std::allocator<char> >
+  class gp_hash_table : public PB_DS_GP_HASH_BASE
+  {
+  private:
+    typedef PB_DS_GP_HASH_BASE 			base_type;
+
+  public:
+    typedef gp_hash_tag	       			container_category;
+    typedef Hash_Fn 				hash_fn;
+    typedef Eq_Fn 				eq_fn;
+    typedef Comb_Probe_Fn			comb_probe_fn;
+    typedef Probe_Fn 				probe_fn;
+    typedef Resize_Policy 			resize_policy;
+
+    /// Default constructor.
+    gp_hash_table() { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object.
+    gp_hash_table(const hash_fn& h)
+    : base_type(h) { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object, and
+    /// r_eq_fn will be copied by the eq_fn object of the container
+    /// object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e)
+    : base_type(h, e) { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object, r_eq_fn
+    /// will be copied by the eq_fn object of the container object,
+    /// and r_comb_probe_fn will be copied by the comb_probe_fn object
+    /// of the container object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp)
+    : base_type(h, e, cp) { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object, r_eq_fn
+    /// will be copied by the eq_fn object of the container object,
+    /// r_comb_probe_fn will be copied by the comb_probe_fn object of
+    /// the container object, and r_probe_fn will be copied by the
+    /// probe_fn object of the container object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp,
+		  const probe_fn& p)
+    : base_type(h, e, cp, p) { }
+
+    /// Constructor taking some policy objects. r_hash_fn will be
+    /// copied by the hash_fn object of the container object, r_eq_fn
+    /// will be copied by the eq_fn object of the container object,
+    /// r_comb_probe_fn will be copied by the comb_probe_fn object of
+    /// the container object, r_probe_fn will be copied by the
+    /// probe_fn object of the container object, and r_resize_policy
+    /// will be copied by the Resize_Policy object of the container
+    /// object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp,
+		  const probe_fn& p, const resize_policy& rp)
+    : base_type(h, e, cp, p, rp) { }
+
+    /// Constructor taking __iterators to a range of value_types. The
+    /// value_types between first_it and last_it will be inserted into
+    /// the container object.
+    template<typename It>
+    gp_hash_table(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects. The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h)
+    : base_type(h)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects. The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object,
+    /// and r_eq_fn will be copied by the eq_fn object of the
+    /// container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e)
+    : base_type(h, e)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects. The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object,
+    /// r_eq_fn will be copied by the eq_fn object of the container
+    /// object, and r_comb_probe_fn will be copied by the
+    /// comb_probe_fn object of the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e,
+		  const comb_probe_fn& cp)
+    : base_type(h, e, cp)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects. The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object,
+    /// r_eq_fn will be copied by the eq_fn object of the container
+    /// object, r_comb_probe_fn will be copied by the comb_probe_fn
+    /// object of the container object, and r_probe_fn will be copied
+    /// by the probe_fn object of the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e,
+		  const comb_probe_fn& cp, const probe_fn& p)
+    : base_type(h, e, cp, p)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects. The value_types between first_it and
+    /// last_it will be inserted into the container object. r_hash_fn
+    /// will be copied by the hash_fn object of the container object,
+    /// r_eq_fn will be copied by the eq_fn object of the container
+    /// object, r_comb_probe_fn will be copied by the comb_probe_fn
+    /// object of the container object, r_probe_fn will be copied by
+    /// the probe_fn object of the container object, and
+    /// r_resize_policy will be copied by the resize_policy object of
+    /// the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e,
+		  const comb_probe_fn& cp, const probe_fn& p,
+		  const resize_policy& rp)
+    : base_type(h, e, cp, p, rp)
+    { base_type::copy_from_range(first, last); }
+
+    gp_hash_table(const gp_hash_table& other)
+    : base_type((const base_type&)other)
+    { }
+
+    virtual
+    ~gp_hash_table() { }
+
+    gp_hash_table&
+    operator=(const gp_hash_table& other)
+    {
+      if (this != &other)
+	{
+	  gp_hash_table tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(gp_hash_table& other)
+    { base_type::swap(other); }
+  };
+  //@} hash-based
+#undef PB_DS_GP_HASH_BASE
+
+
+  /**
+   *  @defgroup branch-based Branch-Based
+   *  @ingroup containers-pbds
+   *  @{
+   */
+#define PB_DS_BRANCH_BASE \
+  detail::container_base_dispatch<Key, Mapped, _Alloc, Tag, Policy_Tl>::type
+
+  /**
+   *  @defgroup branch-detail Base and Policy Classes
+   *  @ingroup branch-based
+   */
+
+  /**
+   *  A branched, tree-like (tree, trie) container abstraction.
+   *
+   *  @tparam Key 	  	Key type.
+   *  @tparam Mapped 	  	Map type.
+   *  @tparam Tag 	  	Instantiating data structure type,
+   *                            see container_tag.
+   *  @tparam Node_Update 	Updates nodes, restores invariants.
+   *  @tparam Policy_TL         Policy typelist.
+   *  @tparam _Alloc 	  	Allocator type.
+   *
+   *  Base is dispatched at compile time via Tag, from the following
+   *  choices: tree_tag, trie_tag, and their descendants.
+   *
+   *  Base choices are: detail::ov_tree_map, detail::rb_tree_map,
+   *		       	detail::splay_tree_map, and detail::pat_trie_map.
+   */
+  template<typename Key, typename Mapped, typename Tag,
+	   typename Node_Update, typename Policy_Tl, typename _Alloc>
+  class basic_branch : public PB_DS_BRANCH_BASE
+  {
+  private:
+    typedef typename PB_DS_BRANCH_BASE 	       	base_type;
+
+  public:
+    typedef Node_Update 			node_update;
+
+    virtual
+    ~basic_branch() { }
+
+  protected:
+    basic_branch() { }
+
+    basic_branch(const basic_branch& other)
+    : base_type((const base_type&)other) { }
+
+    template<typename T0>
+      basic_branch(T0 t0) : base_type(t0) { }
+
+    template<typename T0, typename T1>
+      basic_branch(T0 t0, T1 t1) : base_type(t0, t1) { }
+
+    template<typename T0, typename T1, typename T2>
+      basic_branch(T0 t0, T1 t1, T2 t2) : base_type(t0, t1, t2) { }
+
+    template<typename T0, typename T1, typename T2, typename T3>
+      basic_branch(T0 t0, T1 t1, T2 t2, T3 t3)
+      : base_type(t0, t1, t2, t3) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4>
+      basic_branch(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4)
+      : base_type(t0, t1, t2, t3, t4) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	     typename T5>
+      basic_branch(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+      : base_type(t0, t1, t2, t3, t4, t5) { }
+
+    template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	     typename T5, typename T6>
+      basic_branch(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+      : base_type(t0, t1, t2, t3, t4, t5, t6) { }
+  };
+#undef PB_DS_BRANCH_BASE
+
+
+#define PB_DS_TREE_NODE_AND_IT_TRAITS \
+  detail::tree_traits<Key, Mapped,Cmp_Fn,Node_Update,Tag,_Alloc>
+
+#define PB_DS_TREE_BASE \
+  basic_branch<Key,Mapped, Tag, \
+	       typename PB_DS_TREE_NODE_AND_IT_TRAITS::node_update, \
+	       typename __gnu_cxx::typelist::create2<Cmp_Fn, \
+	       PB_DS_TREE_NODE_AND_IT_TRAITS>::type, _Alloc>
+
+
+  /**
+   *  A tree-based container.
+   *
+   *  @tparam Key 	 	Key type.
+   *  @tparam Mapped 	 	Map type.
+   *  @tparam Cmp_Fn	 	Comparison functor.
+   *  @tparam Tag 	 	Instantiating data structure type,
+   *                            see container_tag.
+   *  @tparam Node_Update 	Updates tree internal-nodes,
+   *                            restores invariants when invalidated.
+   *                     XXX See design::tree-based-containers::node invariants.
+   *  @tparam _Alloc 	 	Allocator type.
+   *
+   *  Base tag choices are: ov_tree_tag, rb_tree_tag, splay_tree_tag.
+   *
+   *  Base is basic_branch.
+   */
+  template<typename Key, typename Mapped, typename Cmp_Fn = std::less<Key>,
+	   typename Tag = rb_tree_tag,
+	   template<typename Node_CItr, typename Node_Itr,
+		    typename Cmp_Fn_, typename _Alloc_>
+	   class Node_Update = null_node_update,
+	   typename _Alloc = std::allocator<char> >
+  class tree : public PB_DS_TREE_BASE
+  {
+  private:
+    typedef PB_DS_TREE_BASE 			base_type;
+
+  public:
+    /// Comparison functor type.
+    typedef Cmp_Fn 				cmp_fn;
+
+    tree() { }
+
+    /// Constructor taking some policy objects. r_cmp_fn will be
+    /// copied by the Cmp_Fn object of the container object.
+    tree(const cmp_fn& c)
+    : base_type(c) { }
+
+    /// Constructor taking __iterators to a range of value_types. The
+    /// value_types between first_it and last_it will be inserted into
+    /// the container object.
+    template<typename It>
+    tree(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects The value_types between first_it and
+    /// last_it will be inserted into the container object. r_cmp_fn
+    /// will be copied by the cmp_fn object of the container object.
+    template<typename It>
+    tree(It first, It last, const cmp_fn& c)
+    : base_type(c)
+    { base_type::copy_from_range(first, last); }
+
+    tree(const tree& other)
+    : base_type((const base_type&)other) { }
+
+    virtual
+    ~tree() { }
+
+    tree&
+    operator=(const tree& other)
+    {
+      if (this != &other)
+	{
+	  tree tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(tree& other)
+    { base_type::swap(other); }
+  };
+
+#undef PB_DS_TREE_BASE
+#undef PB_DS_TREE_NODE_AND_IT_TRAITS
+
+
+#define PB_DS_TRIE_NODE_AND_IT_TRAITS \
+  detail::trie_traits<Key,Mapped,_ATraits,Node_Update,Tag,_Alloc>
+
+#define PB_DS_TRIE_BASE \
+  basic_branch<Key,Mapped,Tag, \
+	       typename PB_DS_TRIE_NODE_AND_IT_TRAITS::node_update, \
+	       typename __gnu_cxx::typelist::create2<_ATraits, \
+	       PB_DS_TRIE_NODE_AND_IT_TRAITS >::type, _Alloc>
+
+
+  /**
+   *  A trie-based container.
+   *
+   *  @tparam Key 	  	Key type.
+   *  @tparam Mapped 	  	Map type.
+   *  @tparam _ATraits	  	Element access traits.
+   *  @tparam Tag 	  	Instantiating data structure type,
+   *                            see container_tag.
+   *  @tparam Node_Update 	Updates trie internal-nodes,
+   *                            restores invariants when invalidated.
+   *                     XXX See design::tree-based-containers::node invariants.
+   *  @tparam _Alloc 	  	Allocator type.
+   *
+   *  Base tag choice is pat_trie_tag.
+   *
+   *  Base is basic_branch.
+   */
+  template<typename Key,
+	   typename Mapped,
+	   typename _ATraits = \
+		    typename detail::default_trie_access_traits<Key>::type,
+	   typename Tag = pat_trie_tag,
+	   template<typename Node_CItr,
+		    typename Node_Itr,
+		    typename _ATraits_,
+		    typename _Alloc_>
+	   class Node_Update = null_node_update,
+	   typename _Alloc = std::allocator<char> >
+  class trie : public PB_DS_TRIE_BASE
+  {
+  private:
+    typedef PB_DS_TRIE_BASE			base_type;
+
+  public:
+    /// Element access traits type.
+    typedef _ATraits 				access_traits;
+
+    trie() { }
+
+    /// Constructor taking some policy objects. r_access_traits will
+    /// be copied by the _ATraits object of the container object.
+    trie(const access_traits& t)
+    : base_type(t) { }
+
+    /// Constructor taking __iterators to a range of value_types. The
+    /// value_types between first_it and last_it will be inserted into
+    /// the container object.
+    template<typename It>
+    trie(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects. The value_types between first_it and
+    /// last_it will be inserted into the container object.
+    template<typename It>
+    trie(It first, It last, const access_traits& t)
+    : base_type(t)
+    { base_type::copy_from_range(first, last); }
+
+    trie(const trie& other)
+    : base_type((const base_type&)other) { }
+
+    virtual
+    ~trie() { }
+
+    trie&
+    operator=(const trie& other)
+    {
+      if (this != &other)
+	{
+	  trie tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(trie& other)
+    { base_type::swap(other); }
+  };
+  //@} branch-based
+#undef PB_DS_TRIE_BASE
+#undef PB_DS_TRIE_NODE_AND_IT_TRAITS
+
+
+  /**
+   *  @defgroup list-based List-Based
+   *  @ingroup containers-pbds
+   *  @{
+   */
+#define PB_DS_LU_BASE \
+  detail::container_base_dispatch<Key, Mapped, _Alloc, list_update_tag,	\
+    typename __gnu_cxx::typelist::create2<Eq_Fn, Update_Policy>::type>::type
+
+
+  /**
+   *  A list-update based associative container.
+   *
+   *  @tparam Key 	    	Key type.
+   *  @tparam Mapped 	    	Map type.
+   *  @tparam Eq_Fn	    	Equal functor.
+   *  @tparam Update_Policy	Update policy, determines when an element
+   *                            will be moved to the front of the list.
+   *  @tparam _Alloc 	    	Allocator type.
+   *
+   *  Base is detail::lu_map.
+   */
+  template<typename Key,
+	   typename Mapped,
+	   class Eq_Fn = typename detail::default_eq_fn<Key>::type,
+	   class Update_Policy = detail::default_update_policy::type,
+	   class _Alloc = std::allocator<char> >
+  class list_update : public PB_DS_LU_BASE
+  {
+  private:
+    typedef typename PB_DS_LU_BASE 		base_type;
+
+  public:
+    typedef list_update_tag	       		container_category;
+    typedef Eq_Fn 				eq_fn;
+    typedef Update_Policy 			update_policy;
+
+    list_update() { }
+
+    /// Constructor taking __iterators to a range of value_types. The
+    /// value_types between first_it and last_it will be inserted into
+    /// the container object.
+    template<typename It>
+    list_update(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    list_update(const list_update& other)
+    : base_type((const base_type&)other) { }
+
+    virtual
+    ~list_update() { }
+
+    list_update&
+    operator=(const list_update& other)
+    {
+      if (this !=& other)
+	{
+	  list_update tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(list_update& other)
+    { base_type::swap(other); }
+  };
+  //@} list-based
+#undef PB_DS_LU_BASE
+
+  // @} group containers-pbds
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp
new file mode 100644
index 0000000..da1e269
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp
@@ -0,0 +1,428 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ *  @file bin_search_tree_/bin_search_tree_.hpp
+ *  Contains an implementation class for binary search tree.
+ */
+
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+#include <ext/pb_ds/detail/eq_fn/eq_by_less.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/tree_trace_base.hpp>
+#ifdef _GLIBCXX_DEBUG
+#include <ext/pb_ds/detail/debug_map_base.hpp>
+#endif
+#include <utility>
+#include <functional>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+#define PB_DS_BIN_TREE_NAME bin_search_tree_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+#define PB_DS_BIN_TREE_NAME bin_search_tree_set
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Cmp_Fn, \
+	     typename Node_And_It_Traits, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    PB_DS_BIN_TREE_NAME<Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc>
+
+#define PB_DS_BIN_TREE_TRAITS_BASE \
+    types_traits<Key, Mapped, _Alloc, false>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_DEBUG_MAP_BASE_C_DEC  \
+    debug_map_base<Key,	eq_by_less<Key, Cmp_Fn>, \
+	      typename _Alloc::template rebind<Key>::other::const_reference>
+#endif
+
+#ifdef PB_DS_TREE_TRACE
+#define PB_DS_TREE_TRACE_BASE_C_DEC \
+    tree_trace_base<typename Node_And_It_Traits::node_const_iterator, \
+		    typename Node_And_It_Traits::node_iterator,	      \
+		    Cmp_Fn, true, _Alloc>
+#endif
+
+
+    /*
+     *  @brief Binary search tree (BST).
+     *
+     *  This implementation uses an idea from the SGI STL (using a @a
+     *  header node which is needed for efficient iteration).
+     */
+    template<typename Key, typename Mapped, typename Cmp_Fn,
+	     typename Node_And_It_Traits, typename _Alloc>
+    class PB_DS_BIN_TREE_NAME :
+#ifdef _GLIBCXX_DEBUG
+      public PB_DS_DEBUG_MAP_BASE_C_DEC,
+#endif
+#ifdef PB_DS_TREE_TRACE
+      public PB_DS_TREE_TRACE_BASE_C_DEC,
+#endif
+      public Cmp_Fn,
+      public PB_DS_BIN_TREE_TRAITS_BASE,
+      public Node_And_It_Traits::node_update
+    {
+      typedef Node_And_It_Traits 			traits_type;
+
+    protected:
+      typedef PB_DS_BIN_TREE_TRAITS_BASE 	       	traits_base;
+
+      typedef
+      typename _Alloc::template rebind<typename traits_type::node>::other
+      node_allocator;
+
+      typedef typename node_allocator::value_type 	node;
+      typedef typename node_allocator::pointer 		node_pointer;
+
+      typedef typename traits_type::null_node_update_pointer
+      null_node_update_pointer;
+
+    private:
+      typedef cond_dealtor<node, _Alloc> 		cond_dealtor_t;
+
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC 		debug_base;
+#endif
+
+    public:
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 	difference_type;
+      typedef typename traits_base::key_type 		key_type;
+      typedef typename traits_base::key_pointer 	key_pointer;
+      typedef typename traits_base::key_const_pointer 	key_const_pointer;
+      typedef typename traits_base::key_reference 	key_reference;
+      typedef typename traits_base::key_const_reference key_const_reference;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef typename traits_base::mapped_type 	mapped_type;
+      typedef typename traits_base::mapped_pointer 	mapped_pointer;
+      typedef typename traits_base::mapped_const_pointer mapped_const_pointer;
+      typedef typename traits_base::mapped_reference 	mapped_reference;
+      typedef typename traits_base::mapped_const_reference mapped_const_reference;
+#endif
+
+      typedef typename traits_base::value_type 		value_type;
+      typedef typename traits_base::pointer 		pointer;
+      typedef typename traits_base::const_pointer 	const_pointer;
+      typedef typename traits_base::reference 		reference;
+      typedef typename traits_base::const_reference 	const_reference;
+      typedef typename traits_type::point_const_iterator point_const_iterator;
+
+      typedef point_const_iterator 			const_iterator;
+      typedef typename traits_type::point_iterator 	point_iterator;
+      typedef point_iterator 				iterator;
+
+      typedef typename traits_type::const_reverse_iterator const_reverse_iterator;
+
+      typedef typename traits_type::reverse_iterator 	reverse_iterator;
+      typedef typename traits_type::node_const_iterator node_const_iterator;
+      typedef typename traits_type::node_iterator 	node_iterator;
+      typedef typename traits_type::node_update 	node_update;
+
+      typedef Cmp_Fn 					cmp_fn;
+      typedef _Alloc 					allocator_type;
+
+      PB_DS_BIN_TREE_NAME();
+
+      PB_DS_BIN_TREE_NAME(const Cmp_Fn&);
+
+      PB_DS_BIN_TREE_NAME(const Cmp_Fn&, const node_update&);
+
+      PB_DS_BIN_TREE_NAME(const PB_DS_CLASS_C_DEC&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      ~PB_DS_BIN_TREE_NAME();
+
+      inline bool
+      empty() const;
+
+      inline size_type
+      size() const;
+
+      inline size_type
+      max_size() const;
+
+      Cmp_Fn&
+      get_cmp_fn();
+
+      const Cmp_Fn&
+      get_cmp_fn() const;
+
+      inline point_iterator
+      lower_bound(key_const_reference);
+
+      inline point_const_iterator
+      lower_bound(key_const_reference) const;
+
+      inline point_iterator
+      upper_bound(key_const_reference);
+
+      inline point_const_iterator
+      upper_bound(key_const_reference) const;
+
+      inline point_iterator
+      find(key_const_reference);
+
+      inline point_const_iterator
+      find(key_const_reference) const;
+
+      inline iterator
+      begin();
+
+      inline const_iterator
+      begin() const;
+
+      inline iterator
+      end();
+
+      inline const_iterator
+      end() const;
+
+      inline reverse_iterator
+      rbegin();
+
+      inline const_reverse_iterator
+      rbegin() const;
+
+      inline reverse_iterator
+      rend();
+
+      inline const_reverse_iterator
+      rend() const;
+
+      /// Returns a const node_iterator corresponding to the node at the
+      /// root of the tree.
+      inline node_const_iterator
+      node_begin() const;
+
+      /// Returns a node_iterator corresponding to the node at the
+      /// root of the tree.
+      inline node_iterator
+      node_begin();
+
+      /// Returns a const node_iterator corresponding to a node just
+      /// after a leaf of the tree.
+      inline node_const_iterator
+      node_end() const;
+
+      /// Returns a node_iterator corresponding to a node just
+      /// after a leaf of the tree.
+      inline node_iterator
+      node_end();
+
+      void
+      clear();
+
+    protected:
+      void
+      value_swap(PB_DS_CLASS_C_DEC&);
+
+      void
+      initialize_min_max();
+
+      inline iterator
+      insert_imp_empty(const_reference);
+
+      inline iterator
+      insert_leaf_new(const_reference, node_pointer, bool);
+
+      inline node_pointer
+      get_new_node_for_leaf_insert(const_reference, false_type);
+
+      inline node_pointer
+      get_new_node_for_leaf_insert(const_reference, true_type);
+
+      inline void
+      actual_erase_node(node_pointer);
+
+      inline std::pair<node_pointer, bool>
+      erase(node_pointer);
+
+      inline void
+      update_min_max_for_erased_node(node_pointer);
+
+      static void
+      clear_imp(node_pointer);
+
+      inline std::pair<point_iterator, bool>
+      insert_leaf(const_reference);
+
+      inline void
+      rotate_left(node_pointer);
+
+      inline void
+      rotate_right(node_pointer);
+
+      inline void
+      rotate_parent(node_pointer);
+
+      inline void
+      apply_update(node_pointer, null_node_update_pointer);
+
+      template<typename Node_Update_>
+	inline void
+	apply_update(node_pointer, Node_Update_*);
+
+      inline void
+      update_to_top(node_pointer, null_node_update_pointer);
+
+      template<typename Node_Update_>
+	inline void
+	update_to_top(node_pointer, Node_Update_*);
+
+      bool
+      join_prep(PB_DS_CLASS_C_DEC&);
+
+      void
+      join_finish(PB_DS_CLASS_C_DEC&);
+
+      bool
+      split_prep(key_const_reference, PB_DS_CLASS_C_DEC&);
+
+      void
+      split_finish(PB_DS_CLASS_C_DEC&);
+
+      size_type
+      recursive_count(node_pointer) const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+
+      void
+      structure_only_assert_valid(const char*, int) const;
+
+      void
+      assert_node_consistent(const node_pointer, const char*, int) const;
+#endif
+
+    private:
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_iterators(const char*, int) const;
+
+      void
+      assert_consistent_with_debug_base(const char*, int) const;
+
+      void
+      assert_node_consistent_with_left(const node_pointer,
+				       const char*, int) const;
+
+      void
+      assert_node_consistent_with_right(const node_pointer,
+					const char*, int) const;
+
+      void
+      assert_consistent_with_debug_base(const node_pointer,
+					const char*, int) const;
+
+      void
+      assert_min(const char*, int) const;
+
+      void
+      assert_min_imp(const node_pointer, const char*, int) const;
+
+      void
+      assert_max(const char*, int) const;
+
+      void
+      assert_max_imp(const node_pointer, const char*, int) const;
+
+      void
+      assert_size(const char*, int) const;
+
+      typedef std::pair<const_pointer, const_pointer> node_consistent_t;
+
+      node_consistent_t
+      assert_node_consistent_(const node_pointer, const char*, int) const;
+#endif
+
+      void
+      initialize();
+
+      node_pointer
+      recursive_copy_node(const node_pointer);
+
+    protected:
+      node_pointer 		m_p_head;
+      size_type 		m_size;
+      static node_allocator 	s_node_allocator;
+    };
+
+#define PB_DS_STRUCT_ONLY_ASSERT_VALID(X)				\
+  _GLIBCXX_DEBUG_ONLY(X.structure_only_assert_valid(__FILE__, __LINE__);)
+
+#define PB_DS_ASSERT_NODE_CONSISTENT(_Node)				\
+  _GLIBCXX_DEBUG_ONLY(assert_node_consistent(_Node, __FILE__, __LINE__);)
+
+#include <ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/info_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/policy_access_fn_imps.hpp>
+
+#undef PB_DS_ASSERT_NODE_CONSISTENT
+#undef PB_DS_STRUCT_ONLY_ASSERT_VALID
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_BIN_TREE_NAME
+#undef PB_DS_BIN_TREE_TRAITS_BASE
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
+
+#ifdef PB_DS_TREE_TRACE
+#undef PB_DS_TREE_TRACE_BASE_C_DEC
+#endif
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..27c2a46
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,218 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_allocator
+PB_DS_CLASS_C_DEC::s_node_allocator;
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_BIN_TREE_NAME() : m_p_head(s_node_allocator.allocate(1)), m_size(0)
+{
+  initialize();
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_BIN_TREE_NAME(const Cmp_Fn& r_cmp_fn) :
+  Cmp_Fn(r_cmp_fn), m_p_head(s_node_allocator.allocate(1)), m_size(0)
+{
+  initialize();
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_BIN_TREE_NAME(const Cmp_Fn& r_cmp_fn, const node_update& r_node_update) :
+  Cmp_Fn(r_cmp_fn),
+  node_update(r_node_update),
+  m_p_head(s_node_allocator.allocate(1)),
+  m_size(0)
+{
+  initialize();
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_BIN_TREE_NAME(const PB_DS_CLASS_C_DEC& other) :
+#ifdef _GLIBCXX_DEBUG
+  debug_base(other),
+#endif 
+#ifdef PB_DS_TREE_TRACE
+  PB_DS_TREE_TRACE_BASE_C_DEC(other),
+#endif 
+  Cmp_Fn(other),
+  node_update(other),
+  m_p_head(s_node_allocator.allocate(1)),
+  m_size(0)
+{
+  initialize();
+  m_size = other.m_size;
+  PB_DS_STRUCT_ONLY_ASSERT_VALID(other)
+
+    __try
+      {
+        m_p_head->m_p_parent = recursive_copy_node(other.m_p_head->m_p_parent);
+        if (m_p_head->m_p_parent != 0)
+	  m_p_head->m_p_parent->m_p_parent = m_p_head;
+        m_size = other.m_size;
+        initialize_min_max();
+      }
+    __catch(...)
+      {
+        _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
+	s_node_allocator.deallocate(m_p_head, 1);
+        __throw_exception_again;
+      }
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  PB_DS_STRUCT_ONLY_ASSERT_VALID(other)
+  value_swap(other);
+  std::swap((Cmp_Fn& )(*this), (Cmp_Fn& )other);
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  PB_DS_STRUCT_ONLY_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+value_swap(PB_DS_CLASS_C_DEC& other)
+{
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
+  std::swap(m_p_head, other.m_p_head);
+  std::swap(m_size, other.m_size);
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~PB_DS_BIN_TREE_NAME()
+{
+  clear();
+  s_node_allocator.deallocate(m_p_head, 1);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize()
+{
+  m_p_head->m_p_parent = 0;
+  m_p_head->m_p_left = m_p_head;
+  m_p_head->m_p_right = m_p_head;
+  m_size = 0;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+recursive_copy_node(const node_pointer p_nd)
+{
+  if (p_nd == 0)
+    return (0);
+
+  node_pointer p_ret = s_node_allocator.allocate(1);
+  __try
+    {
+      new (p_ret) node(*p_nd);
+    }
+  __catch(...)
+    {
+      s_node_allocator.deallocate(p_ret, 1);
+      __throw_exception_again;
+    }
+
+  p_ret->m_p_left = p_ret->m_p_right = 0;
+
+  __try
+    {
+      p_ret->m_p_left = recursive_copy_node(p_nd->m_p_left);
+      p_ret->m_p_right = recursive_copy_node(p_nd->m_p_right);
+    }
+  __catch(...)
+    {
+      clear_imp(p_ret);
+      __throw_exception_again;
+    }
+
+  if (p_ret->m_p_left != 0)
+    p_ret->m_p_left->m_p_parent = p_ret;
+
+  if (p_ret->m_p_right != 0)
+    p_ret->m_p_right->m_p_parent = p_ret;
+
+  PB_DS_ASSERT_NODE_CONSISTENT(p_ret)
+  return p_ret;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize_min_max()
+{
+  if (m_p_head->m_p_parent == 0)
+    {
+      m_p_head->m_p_left = m_p_head->m_p_right = m_p_head;
+      return;
+    }
+
+  {
+    node_pointer p_min = m_p_head->m_p_parent;
+    while (p_min->m_p_left != 0)
+      p_min = p_min->m_p_left;
+    m_p_head->m_p_left = p_min;
+  }
+
+  {
+    node_pointer p_max = m_p_head->m_p_parent;
+    while (p_max->m_p_right != 0)
+      p_max = p_max->m_p_right;
+    m_p_head->m_p_right = p_max;
+  }
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp
new file mode 100644
index 0000000..cd6fd6f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp
@@ -0,0 +1,277 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/debug_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  structure_only_assert_valid(__file, __line);
+  assert_consistent_with_debug_base(__file, __line);
+  assert_size(__file, __line);
+  assert_iterators(__file, __line);
+  if (m_p_head->m_p_parent == 0)
+    {
+      PB_DS_DEBUG_VERIFY(m_size == 0);
+    }
+  else
+    {
+      PB_DS_DEBUG_VERIFY(m_size > 0);
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+structure_only_assert_valid(const char* __file, int __line) const
+{
+  PB_DS_DEBUG_VERIFY(m_p_head != 0);
+  if (m_p_head->m_p_parent == 0)
+    {
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_left == m_p_head);
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_right == m_p_head);
+    }
+  else
+    {
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_parent->m_p_parent == m_p_head);
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_left != m_p_head);
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_right != m_p_head);
+    }
+
+  if (m_p_head->m_p_parent != 0)
+    assert_node_consistent(m_p_head->m_p_parent, __file, __line);
+  assert_min(__file, __line);
+  assert_max(__file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_node_consistent(const node_pointer p_nd,
+		       const char* __file, int __line) const
+{
+  assert_node_consistent_(p_nd, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_consistent_t
+PB_DS_CLASS_C_DEC::
+assert_node_consistent_(const node_pointer p_nd,
+			const char* __file, int __line) const
+{
+  if (p_nd == 0)
+    return (std::make_pair((const_pointer)0,(const_pointer)0));
+
+  assert_node_consistent_with_left(p_nd, __file, __line);
+  assert_node_consistent_with_right(p_nd, __file, __line);
+
+  const std::pair<const_pointer, const_pointer>
+    l_range = assert_node_consistent_(p_nd->m_p_left, __file, __line);
+
+  if (l_range.second != 0)
+    PB_DS_DEBUG_VERIFY(Cmp_Fn::operator()(PB_DS_V2F(*l_range.second),
+					  PB_DS_V2F(p_nd->m_value)));
+
+  const std::pair<const_pointer, const_pointer>
+    r_range = assert_node_consistent_(p_nd->m_p_right, __file, __line);
+
+  if (r_range.first != 0)
+    PB_DS_DEBUG_VERIFY(Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value),
+					     PB_DS_V2F(*r_range.first)));
+
+  return std::make_pair((l_range.first != 0) ? l_range.first : &p_nd->m_value,
+			(r_range.second != 0)? r_range.second : &p_nd->m_value);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_node_consistent_with_left(const node_pointer p_nd,
+				 const char* __file, int __line) const
+{
+  if (p_nd->m_p_left == 0)
+    return;
+  PB_DS_DEBUG_VERIFY(p_nd->m_p_left->m_p_parent == p_nd);
+  PB_DS_DEBUG_VERIFY(!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value),
+					 PB_DS_V2F(p_nd->m_p_left->m_value)));
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_node_consistent_with_right(const node_pointer p_nd,
+				  const char* __file, int __line) const
+{
+  if (p_nd->m_p_right == 0)
+    return;
+  PB_DS_DEBUG_VERIFY(p_nd->m_p_right->m_p_parent == p_nd);
+  PB_DS_DEBUG_VERIFY(!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_p_right->m_value),
+					 PB_DS_V2F(p_nd->m_value)));
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_min(const char* __file, int __line) const
+{
+  assert_min_imp(m_p_head->m_p_parent, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_min_imp(const node_pointer p_nd, const char* __file, int __line) const
+{
+  if (p_nd == 0)
+    {
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_left == m_p_head);
+      return;
+    }
+
+  if (p_nd->m_p_left == 0)
+    {
+      PB_DS_DEBUG_VERIFY(p_nd == m_p_head->m_p_left);
+      return;
+    }
+  assert_min_imp(p_nd->m_p_left, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_max(const char* __file, int __line) const
+{
+  assert_max_imp(m_p_head->m_p_parent, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_max_imp(const node_pointer p_nd,
+	       const char* __file, int __line) const
+{
+  if (p_nd == 0)
+    {
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_right == m_p_head);
+      return;
+    }
+
+  if (p_nd->m_p_right == 0)
+    {
+      PB_DS_DEBUG_VERIFY(p_nd == m_p_head->m_p_right);
+      return;
+    }
+
+  assert_max_imp(p_nd->m_p_right, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_iterators(const char* __file, int __line) const
+{
+  size_type iterated_num = 0;
+  const_iterator prev_it = end();
+  for (const_iterator it = begin(); it != end(); ++it)
+    {
+      ++iterated_num;
+      PB_DS_DEBUG_VERIFY(lower_bound(PB_DS_V2F(*it)).m_p_nd == it.m_p_nd);
+      const_iterator upper_bound_it = upper_bound(PB_DS_V2F(*it));
+      --upper_bound_it;
+      PB_DS_DEBUG_VERIFY(upper_bound_it.m_p_nd == it.m_p_nd);
+
+      if (prev_it != end())
+	PB_DS_DEBUG_VERIFY(Cmp_Fn::operator()(PB_DS_V2F(*prev_it),
+					      PB_DS_V2F(*it)));
+      prev_it = it;
+    }
+
+  PB_DS_DEBUG_VERIFY(iterated_num == m_size);
+  size_type reverse_iterated_num = 0;
+  const_reverse_iterator reverse_prev_it = rend();
+  for (const_reverse_iterator reverse_it = rbegin(); reverse_it != rend();
+       ++reverse_it)
+    {
+      ++reverse_iterated_num;
+      PB_DS_DEBUG_VERIFY(lower_bound(
+				   PB_DS_V2F(*reverse_it)).m_p_nd == reverse_it.m_p_nd);
+
+      const_iterator upper_bound_it = upper_bound(PB_DS_V2F(*reverse_it));
+      --upper_bound_it;
+      PB_DS_DEBUG_VERIFY(upper_bound_it.m_p_nd == reverse_it.m_p_nd);
+      if (reverse_prev_it != rend())
+	PB_DS_DEBUG_VERIFY(!Cmp_Fn::operator()(PB_DS_V2F(*reverse_prev_it),
+					       PB_DS_V2F(*reverse_it)));
+      reverse_prev_it = reverse_it;
+    }
+  PB_DS_DEBUG_VERIFY(reverse_iterated_num == m_size);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_consistent_with_debug_base(const char* __file, int __line) const
+{
+  debug_base::check_size(m_size, __file, __line);
+  assert_consistent_with_debug_base(m_p_head->m_p_parent, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_consistent_with_debug_base(const node_pointer p_nd,
+				  const char* __file, int __line) const
+{
+  if (p_nd == 0)
+    return;
+  debug_base::check_key_exists(PB_DS_V2F(p_nd->m_value), __file, __line);
+  assert_consistent_with_debug_base(p_nd->m_p_left, __file, __line);
+  assert_consistent_with_debug_base(p_nd->m_p_right, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_size(const char* __file, int __line) const
+{ PB_DS_DEBUG_VERIFY(recursive_count(m_p_head->m_p_parent) == m_size); }
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp
new file mode 100644
index 0000000..919b248
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/erase_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+actual_erase_node(node_pointer p_z)
+{
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  --m_size;
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_z->m_value));)
+  p_z->~node();
+  s_node_allocator.deallocate(p_z, 1);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+update_min_max_for_erased_node(node_pointer p_z)
+{
+  if (m_size == 1)
+    {
+      m_p_head->m_p_left = m_p_head->m_p_right = m_p_head;
+      return;
+    }
+
+  if (m_p_head->m_p_left == p_z)
+    {
+      iterator it(p_z);
+      ++it;
+      m_p_head->m_p_left = it.m_p_nd;
+    }
+  else if (m_p_head->m_p_right == p_z)
+    {
+      iterator it(p_z);
+      --it;
+      m_p_head->m_p_right = it.m_p_nd;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  clear_imp(m_p_head->m_p_parent);
+  m_size = 0;
+  initialize();
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear_imp(node_pointer p_nd)
+{
+  if (p_nd == 0)
+    return;
+
+  clear_imp(p_nd->m_p_left);
+  clear_imp(p_nd->m_p_right);
+  p_nd->~node();
+  s_node_allocator.deallocate(p_nd, 1);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp
new file mode 100644
index 0000000..2b8d539
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp
@@ -0,0 +1,171 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/find_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+lower_bound(key_const_reference r_key) const
+{
+  node_pointer p_pot = m_p_head;
+  node_pointer p_nd = m_p_head->m_p_parent;
+
+  while (p_nd != 0)
+    if (Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
+      p_nd = p_nd->m_p_right;
+    else
+      {
+	p_pot = p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+  return iterator(p_pot);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+lower_bound(key_const_reference r_key)
+{
+  node_pointer p_pot = m_p_head;
+  node_pointer p_nd = m_p_head->m_p_parent;
+
+  while (p_nd != 0)
+    if (Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
+      p_nd = p_nd->m_p_right;
+    else
+      {
+	p_pot = p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+  return iterator(p_pot);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+upper_bound(key_const_reference r_key) const
+{
+  node_pointer p_pot = m_p_head;
+  node_pointer p_nd = m_p_head->m_p_parent;
+
+  while (p_nd != 0)
+    if (Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value)))
+      {
+	p_pot = p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+  return const_iterator(p_pot);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+upper_bound(key_const_reference r_key)
+{
+  node_pointer p_pot = m_p_head;
+  node_pointer p_nd = m_p_head->m_p_parent;
+
+  while (p_nd != 0)
+    if (Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value)))
+      {
+	p_pot = p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+  return point_iterator(p_pot);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key)
+{
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  node_pointer p_pot = m_p_head;
+  node_pointer p_nd = m_p_head->m_p_parent;
+
+  while (p_nd != 0)
+    if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
+      {
+	p_pot = p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+
+  node_pointer ret = p_pot;
+  if (p_pot != m_p_head)
+    {
+      const bool __cmp = Cmp_Fn::operator()(r_key, PB_DS_V2F(p_pot->m_value));
+      if (__cmp)
+	ret = m_p_head;
+    }
+  return point_iterator(ret);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key) const
+{
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  node_pointer p_pot = m_p_head;
+  node_pointer p_nd = m_p_head->m_p_parent;
+
+  while (p_nd != 0)
+    if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
+      {
+	p_pot = p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+
+  node_pointer ret = p_pot;
+  if (p_pot != m_p_head)
+    {
+      const bool __cmp = Cmp_Fn::operator()(r_key, PB_DS_V2F(p_pot->m_value));
+      if (__cmp)
+	ret = m_p_head;
+    }
+  return point_const_iterator(ret);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/info_fn_imps.hpp
new file mode 100644
index 0000000..a3e4fff
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/info_fn_imps.hpp
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/info_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{
+  return (m_size == 0);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{
+  return (m_size);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{
+  return (s_node_allocator.max_size());
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp
new file mode 100644
index 0000000..409cfee
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp
@@ -0,0 +1,180 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/insert_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert_leaf(const_reference r_value)
+{
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+
+  if (m_size == 0)
+    return std::make_pair(insert_imp_empty(r_value),
+			  true);
+
+  node_pointer p_nd = m_p_head->m_p_parent;
+  node_pointer p_pot = m_p_head;
+
+  while (p_nd != 0)
+    if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value),
+			    PB_DS_V2F(r_value)))
+      {
+	p_pot = p_nd;
+
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+
+  if (p_pot == m_p_head)
+    return std::make_pair(insert_leaf_new(r_value, m_p_head->m_p_right, false),
+			  true);
+
+  if (!Cmp_Fn::operator()(PB_DS_V2F(r_value),
+			  PB_DS_V2F(p_pot->m_value)))
+    {
+      PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+      PB_DS_CHECK_KEY_EXISTS(PB_DS_V2F(r_value))
+      return std::make_pair(p_pot, false);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(PB_DS_V2F(r_value))
+
+  p_nd = p_pot->m_p_left;
+  if (p_nd == 0)
+    return std::make_pair(insert_leaf_new(r_value, p_pot, true),
+			  true);
+
+  while (p_nd->m_p_right != 0)
+    p_nd = p_nd->m_p_right;
+
+  return std::make_pair(insert_leaf_new(r_value, p_nd, false),
+			true);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd)
+{
+  node_pointer p_new_nd =
+    get_new_node_for_leaf_insert(r_value,
+				 traits_base::m_no_throw_copies_indicator);
+
+  if (left_nd)
+    {
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left == 0);
+      _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(PB_DS_V2F(r_value),
+					       PB_DS_V2F(p_nd->m_value)));
+
+      p_nd->m_p_left = p_new_nd;
+      if (m_p_head->m_p_left == p_nd)
+	m_p_head->m_p_left = p_new_nd;
+    }
+  else
+    {
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_right == 0);
+      _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value),
+					       PB_DS_V2F(r_value)));
+
+      p_nd->m_p_right = p_new_nd;
+      if (m_p_head->m_p_right == p_nd)
+	m_p_head->m_p_right = p_new_nd;
+    }
+
+  p_new_nd->m_p_parent = p_nd;
+  p_new_nd->m_p_left = p_new_nd->m_p_right = 0;
+  PB_DS_ASSERT_NODE_CONSISTENT(p_nd)
+
+  update_to_top(p_new_nd, (node_update* )this);
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_value));)
+  return iterator(p_new_nd);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+insert_imp_empty(const_reference r_value)
+{
+  node_pointer p_new_node =
+    get_new_node_for_leaf_insert(r_value, traits_base::m_no_throw_copies_indicator);
+
+  m_p_head->m_p_left = m_p_head->m_p_right =
+    m_p_head->m_p_parent = p_new_node;
+
+  p_new_node->m_p_parent = m_p_head;
+  p_new_node->m_p_left = p_new_node->m_p_right = 0;
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_value));)
+
+  update_to_top(m_p_head->m_p_parent, (node_update*)this);
+  return iterator(p_new_node);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+get_new_node_for_leaf_insert(const_reference r_val, false_type)
+{
+  node_pointer p_new_nd = s_node_allocator.allocate(1);
+  cond_dealtor_t cond(p_new_nd);
+
+  new (const_cast<void* >(static_cast<const void* >(&p_new_nd->m_value)))
+    typename node::value_type(r_val);
+
+  cond.set_no_action();
+  p_new_nd->m_p_left = p_new_nd->m_p_right = 0;
+  ++m_size;
+  return p_new_nd;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+get_new_node_for_leaf_insert(const_reference r_val, true_type)
+{
+  node_pointer p_new_nd = s_node_allocator.allocate(1);
+
+  new (const_cast<void* >(static_cast<const void* >(&p_new_nd->m_value)))
+    typename node::value_type(r_val);
+
+  p_new_nd->m_p_left = p_new_nd->m_p_right = 0;
+  ++m_size;
+  return p_new_nd;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp
new file mode 100644
index 0000000..806ffcf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp
@@ -0,0 +1,136 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/iterators_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+begin()
+{
+  return (iterator(m_p_head->m_p_left));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin() const
+{
+  return (const_iterator(m_p_head->m_p_left));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+end()
+{
+  return (iterator(m_p_head));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end() const
+{
+  return (const_iterator(m_p_head));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reverse_iterator
+PB_DS_CLASS_C_DEC::
+rbegin() const
+{
+  return (const_reverse_iterator(m_p_head->m_p_right));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::reverse_iterator
+PB_DS_CLASS_C_DEC::
+rbegin()
+{
+  return (reverse_iterator(m_p_head->m_p_right));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::reverse_iterator
+PB_DS_CLASS_C_DEC::
+rend()
+{
+  return (reverse_iterator(m_p_head));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reverse_iterator
+PB_DS_CLASS_C_DEC::
+rend() const
+{
+  return (const_reverse_iterator(m_p_head));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+node_begin() const
+{
+  return (node_const_iterator(m_p_head->m_p_parent));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+node_begin()
+{
+  return (node_iterator(m_p_head->m_p_parent));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+node_end() const
+{
+  return (node_const_iterator(0));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+node_end()
+{
+  return (node_iterator(0));
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp
new file mode 100644
index 0000000..77c826f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp
@@ -0,0 +1,189 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/node_iterators.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+#ifndef PB_DS_BIN_SEARCH_TREE_NODE_ITERATORS_HPP
+#define PB_DS_BIN_SEARCH_TREE_NODE_ITERATORS_HPP
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC \
+    bin_search_tree_const_node_it_<Node, Const_Iterator, Iterator, _Alloc>
+
+    /// Const node iterator.
+    template<typename Node,
+	     class Const_Iterator,
+	     class Iterator,
+	     typename _Alloc>
+    class bin_search_tree_const_node_it_
+    {
+    private:
+      typedef
+      typename _Alloc::template rebind<
+      Node>::other::pointer
+      node_pointer;
+
+    public:
+      /// Category.
+      typedef trivial_iterator_tag iterator_category;
+
+      /// Difference type.
+      typedef trivial_iterator_difference_type difference_type;
+
+      /// Iterator's value type.
+      typedef Const_Iterator value_type;
+
+      /// Iterator's reference type.
+      typedef Const_Iterator reference;
+
+      /// Iterator's __const reference type.
+      typedef Const_Iterator const_reference;
+
+      /// Metadata type.
+      typedef typename Node::metadata_type metadata_type;
+
+      /// Const metadata reference type.
+      typedef
+      typename _Alloc::template rebind<metadata_type>::other::const_reference
+      metadata_const_reference;
+
+
+      bin_search_tree_const_node_it_(const node_pointer p_nd = 0)
+      : m_p_nd(const_cast<node_pointer>(p_nd))
+      { }
+
+      /// Access.
+      const_reference
+      operator*() const
+      { return Const_Iterator(m_p_nd); }
+
+      /// Metadata access.
+      metadata_const_reference
+      get_metadata() const
+      { return m_p_nd->get_metadata(); }
+
+      /// Returns the __const node iterator associated with the left node.
+      PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC
+      get_l_child() const
+      { return PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC(m_p_nd->m_p_left); }
+
+      /// Returns the __const node iterator associated with the right node.
+      PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC
+      get_r_child() const
+      { return PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC(m_p_nd->m_p_right); }
+
+      /// Compares to a different iterator object.
+      bool
+      operator==(const PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC& other) const
+      { return m_p_nd == other.m_p_nd; }
+
+      /// Compares (negatively) to a different iterator object.
+      bool
+      operator!=(const PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC& other) const
+      { return m_p_nd != other.m_p_nd; }
+
+      node_pointer m_p_nd;
+    };
+
+#define PB_DS_TREE_NODE_ITERATOR_CLASS_C_DEC \
+    bin_search_tree_node_it_<Node, Const_Iterator, Iterator, _Alloc>
+
+    /// Node iterator.
+    template<typename Node,
+	     class Const_Iterator,
+	     class Iterator,
+	     typename _Alloc>
+    class bin_search_tree_node_it_
+    : public PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC
+    {
+    private:
+      typedef
+      typename _Alloc::template rebind<
+      Node>::other::pointer
+      node_pointer;
+
+    public:
+      /// Iterator's value type.
+      typedef Iterator value_type;
+
+      /// Iterator's reference type.
+      typedef Iterator reference;
+
+      /// Iterator's __const reference type.
+      typedef Iterator const_reference;
+
+      inline
+      bin_search_tree_node_it_(const node_pointer p_nd = 0)
+      : PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC(const_cast<node_pointer>(p_nd))
+      { }
+
+      /// Access.
+      Iterator
+      operator*() const
+      { return Iterator(PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC::m_p_nd); }
+
+      /// Returns the node iterator associated with the left node.
+      PB_DS_TREE_NODE_ITERATOR_CLASS_C_DEC
+      get_l_child() const
+      {
+	return PB_DS_TREE_NODE_ITERATOR_CLASS_C_DEC(
+						    PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC::m_p_nd->m_p_left);
+      }
+
+      /// Returns the node iterator associated with the right node.
+      PB_DS_TREE_NODE_ITERATOR_CLASS_C_DEC
+      get_r_child() const
+      {
+	return PB_DS_TREE_NODE_ITERATOR_CLASS_C_DEC(
+						    PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC::m_p_nd->m_p_right);
+      }
+
+    };
+
+#undef PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC
+#undef PB_DS_TREE_NODE_ITERATOR_CLASS_C_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_BIN_SEARCH_TREE_NODE_ITERATORS_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp
new file mode 100644
index 0000000..9bc5caa
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp
@@ -0,0 +1,367 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/point_iterators.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+#ifndef PB_DS_BIN_SEARCH_TREE_FIND_ITERATORS_HPP
+#define PB_DS_BIN_SEARCH_TREE_FIND_ITERATORS_HPP
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+
+#define PB_DS_TREE_CONST_IT_C_DEC					\
+    bin_search_tree_const_it_<						\
+						Node_Pointer,		\
+						Value_Type,		\
+						Pointer,		\
+						Const_Pointer,		\
+						Reference,		\
+						Const_Reference,	\
+						Is_Forward_Iterator,	\
+						_Alloc>
+
+#define PB_DS_TREE_CONST_ODIR_IT_C_DEC					\
+    bin_search_tree_const_it_<						\
+						Node_Pointer,		\
+						Value_Type,		\
+						Pointer,		\
+						Const_Pointer,		\
+						Reference,		\
+						Const_Reference,	\
+						!Is_Forward_Iterator,	\
+						_Alloc>
+
+#define PB_DS_TREE_IT_C_DEC						\
+    bin_search_tree_it_<						\
+						Node_Pointer,		\
+						Value_Type,		\
+						Pointer,		\
+						Const_Pointer,		\
+						Reference,		\
+						Const_Reference,	\
+						Is_Forward_Iterator,	\
+						_Alloc>
+
+#define PB_DS_TREE_ODIR_IT_C_DEC					\
+    bin_search_tree_it_<						\
+							Node_Pointer,	\
+							Value_Type,	\
+							Pointer,	\
+							Const_Pointer,	\
+							Reference,	\
+							Const_Reference, \
+							!Is_Forward_Iterator, \
+							_Alloc>
+
+    /// Const iterator.
+    template<typename Node_Pointer,
+	     typename Value_Type,
+	     typename Pointer,
+	     typename Const_Pointer,
+	     typename Reference,
+	     typename Const_Reference,
+	     bool Is_Forward_Iterator,
+	     typename _Alloc>
+    class bin_search_tree_const_it_
+    {
+    public:
+      typedef std::bidirectional_iterator_tag 		iterator_category;
+      typedef typename _Alloc::difference_type 	difference_type;
+      typedef Value_Type 				value_type;
+      typedef Pointer 					pointer;
+      typedef Const_Pointer 				const_pointer;
+      typedef Reference 				reference;
+      typedef Const_Reference 				const_reference;
+
+      inline
+      bin_search_tree_const_it_(const Node_Pointer p_nd = 0) 
+      : m_p_nd(const_cast<Node_Pointer>(p_nd))
+      { }
+
+      inline
+      bin_search_tree_const_it_(const PB_DS_TREE_CONST_ODIR_IT_C_DEC& other) 
+      : m_p_nd(other.m_p_nd)
+      { }
+
+      inline
+      PB_DS_TREE_CONST_IT_C_DEC& 
+      operator=(const PB_DS_TREE_CONST_IT_C_DEC& other)
+      {
+	m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      inline
+      PB_DS_TREE_CONST_IT_C_DEC& 
+      operator=(const PB_DS_TREE_CONST_ODIR_IT_C_DEC& other)
+      {
+	m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      inline const_pointer
+      operator->() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
+	return &m_p_nd->m_value;
+      }
+
+      inline const_reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
+	return m_p_nd->m_value;
+      }
+
+      inline bool
+      operator==(const PB_DS_TREE_CONST_IT_C_DEC & other) const
+      { return m_p_nd == other.m_p_nd; }
+
+      inline bool
+      operator==(const PB_DS_TREE_CONST_ODIR_IT_C_DEC & other) const
+      { return m_p_nd == other.m_p_nd; }
+
+      inline bool
+      operator!=(const PB_DS_TREE_CONST_IT_C_DEC& other) const
+      { return m_p_nd != other.m_p_nd; }
+
+      inline bool
+      operator!=(const PB_DS_TREE_CONST_ODIR_IT_C_DEC& other) const
+      { return m_p_nd != other.m_p_nd; }
+
+      inline PB_DS_TREE_CONST_IT_C_DEC& 
+      operator++()
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
+	inc(integral_constant<int,Is_Forward_Iterator>());
+	return *this;
+      }
+
+      inline PB_DS_TREE_CONST_IT_C_DEC
+      operator++(int)
+      {
+	PB_DS_TREE_CONST_IT_C_DEC ret_it(m_p_nd);
+	operator++();
+	return ret_it;
+      }
+
+      inline PB_DS_TREE_CONST_IT_C_DEC& 
+      operator--()
+      {
+	dec(integral_constant<int,Is_Forward_Iterator>());
+	return *this;
+      }
+
+      inline PB_DS_TREE_CONST_IT_C_DEC
+      operator--(int)
+      {
+	PB_DS_TREE_CONST_IT_C_DEC ret_it(m_p_nd);
+	operator--();
+	return ret_it;
+      }
+
+    protected:
+      inline void
+      inc(false_type)
+      { dec(true_type()); }
+
+      void
+      inc(true_type)
+      {
+	if (m_p_nd->special()&& 
+	    m_p_nd->m_p_parent->m_p_parent == m_p_nd)
+	  {
+	    m_p_nd = m_p_nd->m_p_left;
+	    return;
+	  }
+
+	if (m_p_nd->m_p_right != 0)
+	  {
+	    m_p_nd = m_p_nd->m_p_right;
+	    while (m_p_nd->m_p_left != 0)
+	      m_p_nd = m_p_nd->m_p_left;
+	    return;
+	  }
+
+	Node_Pointer p_y = m_p_nd->m_p_parent;
+	while (m_p_nd == p_y->m_p_right)
+	  {
+	    m_p_nd = p_y;
+	    p_y = p_y->m_p_parent;
+	  }
+
+	if (m_p_nd->m_p_right != p_y)
+	  m_p_nd = p_y;
+      }
+
+      inline void
+      dec(false_type)
+      { inc(true_type()); }
+
+      void
+      dec(true_type)
+      {
+	if (m_p_nd->special() && m_p_nd->m_p_parent->m_p_parent == m_p_nd)
+	  {
+	    m_p_nd = m_p_nd->m_p_right;
+	    return;
+	  }
+
+	if (m_p_nd->m_p_left != 0)
+	  {
+	    Node_Pointer p_y = m_p_nd->m_p_left;
+	    while (p_y->m_p_right != 0)
+	      p_y = p_y->m_p_right;
+	    m_p_nd = p_y;
+	    return;
+	  }
+
+	Node_Pointer p_y = m_p_nd->m_p_parent;
+	while (m_p_nd == p_y->m_p_left)
+	  {
+	    m_p_nd = p_y;
+	    p_y = p_y->m_p_parent;
+	  }
+	if (m_p_nd->m_p_left != p_y)
+	  m_p_nd = p_y;
+      }
+
+    public:
+      Node_Pointer m_p_nd;
+    };
+
+    /// Iterator.
+    template<typename Node_Pointer,
+	     typename Value_Type,
+	     typename Pointer,
+	     typename Const_Pointer,
+	     typename Reference,
+	     typename Const_Reference,
+	     bool Is_Forward_Iterator,
+	     typename _Alloc>
+    class bin_search_tree_it_ : public PB_DS_TREE_CONST_IT_C_DEC
+    {
+    public:
+      inline
+      bin_search_tree_it_(const Node_Pointer p_nd = 0) 
+      : PB_DS_TREE_CONST_IT_C_DEC((Node_Pointer)p_nd)
+      { }
+
+      inline
+      bin_search_tree_it_(const PB_DS_TREE_ODIR_IT_C_DEC& other) 
+      : PB_DS_TREE_CONST_IT_C_DEC(other.m_p_nd)
+      { }
+
+      inline
+      PB_DS_TREE_IT_C_DEC& 
+      operator=(const PB_DS_TREE_IT_C_DEC& other)
+      {
+	base_it_type::m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      inline
+      PB_DS_TREE_IT_C_DEC& 
+      operator=(const PB_DS_TREE_ODIR_IT_C_DEC& other)
+      {
+	base_it_type::m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      inline typename PB_DS_TREE_CONST_IT_C_DEC::pointer
+      operator->() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != 0);
+	return &base_it_type::m_p_nd->m_value;
+      }
+
+      inline typename PB_DS_TREE_CONST_IT_C_DEC::reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != 0);
+	return base_it_type::m_p_nd->m_value;
+      }
+
+      inline PB_DS_TREE_IT_C_DEC& 
+      operator++()
+      {
+	PB_DS_TREE_CONST_IT_C_DEC:: operator++();
+	return *this;
+      }
+
+      inline PB_DS_TREE_IT_C_DEC
+      operator++(int)
+      {
+	PB_DS_TREE_IT_C_DEC ret_it(base_it_type::m_p_nd);
+	operator++();
+	return ret_it;
+      }
+
+      inline PB_DS_TREE_IT_C_DEC& 
+      operator--()
+      {
+	PB_DS_TREE_CONST_IT_C_DEC:: operator--();
+	return *this;
+      }
+
+      inline PB_DS_TREE_IT_C_DEC
+      operator--(int)
+      {
+	PB_DS_TREE_IT_C_DEC ret_it(base_it_type::m_p_nd);
+	operator--();
+	return ret_it;
+      }
+
+    protected:
+      typedef PB_DS_TREE_CONST_IT_C_DEC base_it_type;
+    };
+
+#undef PB_DS_TREE_CONST_IT_C_DEC
+#undef PB_DS_TREE_CONST_ODIR_IT_C_DEC
+#undef PB_DS_TREE_IT_C_DEC
+#undef PB_DS_TREE_ODIR_IT_C_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/policy_access_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/policy_access_fn_imps.hpp
new file mode 100644
index 0000000..e47b313
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/policy_access_fn_imps.hpp
@@ -0,0 +1,52 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/policy_access_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn()
+{ return (*this); }
+
+PB_DS_CLASS_T_DEC
+const Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn() const
+{ return (*this); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp
new file mode 100644
index 0000000..8bd0c7d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/r_erase_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+actual_erase_node(node_pointer p_z)
+{
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  --m_size;
+  _GLIBCXX_DEBUG_ONLY(erase_existing(PB_DS_V2F(p_z->m_value));)
+  p_z->~node();
+  s_node_allocator.deallocate(p_z, 1);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+update_min_max_for_erased_node(node_pointer p_z)
+{
+  if (m_size == 1)
+    {
+      m_p_head->m_p_left = m_p_head->m_p_right = m_p_head;
+      return;
+    }
+
+  if (m_p_head->m_p_left == p_z)
+    {
+      iterator it(p_z);
+      ++it;
+      m_p_head->m_p_left = it.m_p_nd;
+    }
+  else if (m_p_head->m_p_right == p_z)
+    {
+      iterator it(p_z);
+      --it;
+      m_p_head->m_p_right = it.m_p_nd;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  clear_imp(m_p_head->m_p_parent);
+  m_size = 0;
+  initialize();
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear_imp(node_pointer p_nd)
+{
+  if (p_nd == 0)
+    return;
+
+  clear_imp(p_nd->m_p_left);
+  clear_imp(p_nd->m_p_right);
+  p_nd->~Node();
+  s_node_allocator.deallocate(p_nd, 1);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp
new file mode 100644
index 0000000..355f484
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp
@@ -0,0 +1,155 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/rotate_fn_imps.hpp
+ * Contains imps for rotating nodes.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+rotate_left(node_pointer p_x)
+{
+  node_pointer p_y = p_x->m_p_right;
+
+  p_x->m_p_right = p_y->m_p_left;
+
+  if (p_y->m_p_left != 0)
+    p_y->m_p_left->m_p_parent = p_x;
+
+  p_y->m_p_parent = p_x->m_p_parent;
+
+  if (p_x == m_p_head->m_p_parent)
+    m_p_head->m_p_parent = p_y;
+  else if (p_x == p_x->m_p_parent->m_p_left)
+    p_x->m_p_parent->m_p_left = p_y;
+  else
+    p_x->m_p_parent->m_p_right = p_y;
+
+  p_y->m_p_left = p_x;
+  p_x->m_p_parent = p_y;
+
+  PB_DS_ASSERT_NODE_CONSISTENT(p_x)
+  PB_DS_ASSERT_NODE_CONSISTENT(p_y)
+
+  apply_update(p_x, (node_update* )this);
+  apply_update(p_x->m_p_parent, (node_update* )this);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+rotate_right(node_pointer p_x)
+{
+  node_pointer p_y = p_x->m_p_left;
+
+  p_x->m_p_left = p_y->m_p_right;
+
+  if (p_y->m_p_right != 0)
+    p_y->m_p_right->m_p_parent = p_x;
+
+  p_y->m_p_parent = p_x->m_p_parent;
+
+  if (p_x == m_p_head->m_p_parent)
+    m_p_head->m_p_parent = p_y;
+  else if (p_x == p_x->m_p_parent->m_p_right)
+    p_x->m_p_parent->m_p_right = p_y;
+  else
+    p_x->m_p_parent->m_p_left = p_y;
+
+  p_y->m_p_right = p_x;
+  p_x->m_p_parent = p_y;
+
+  PB_DS_ASSERT_NODE_CONSISTENT(p_x)
+  PB_DS_ASSERT_NODE_CONSISTENT(p_y)
+
+  apply_update(p_x, (node_update* )this);
+  apply_update(p_x->m_p_parent, (node_update* )this);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+rotate_parent(node_pointer p_nd)
+{
+  node_pointer p_parent = p_nd->m_p_parent;
+
+  if (p_nd == p_parent->m_p_left)
+    rotate_right(p_parent);
+  else
+    rotate_left(p_parent);
+
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_parent = p_nd);
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left == p_parent ||
+		   p_nd->m_p_right == p_parent);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+apply_update(node_pointer /*p_nd*/, null_node_update_pointer /*p_update*/)
+{ }
+
+PB_DS_CLASS_T_DEC
+template<typename Node_Update_>
+inline void
+PB_DS_CLASS_C_DEC::
+apply_update(node_pointer p_nd, Node_Update_*  /*p_update*/)
+{
+  node_update::operator()(node_iterator(p_nd),
+			  node_const_iterator(static_cast<node_pointer>(0)));
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Node_Update_>
+inline void
+PB_DS_CLASS_C_DEC::
+update_to_top(node_pointer p_nd, Node_Update_* p_update)
+{
+  while (p_nd != m_p_head)
+    {
+      apply_update(p_nd, p_update);
+
+      p_nd = p_nd->m_p_parent;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+update_to_top(node_pointer /*p_nd*/, null_node_update_pointer /*p_update*/)
+{ }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..f4f5aac
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp
@@ -0,0 +1,150 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/split_join_fn_imps.hpp
+ * Contains an implementation class for bin_search_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+join_prep(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  if (other.m_size == 0)
+    return false;
+
+  if (m_size == 0)
+    {
+      value_swap(other);
+      return false;
+    }
+
+  const bool greater =
+    Cmp_Fn::operator()(PB_DS_V2F(m_p_head->m_p_right->m_value),
+		       PB_DS_V2F(other.m_p_head->m_p_left->m_value));
+
+  const bool lesser =
+    Cmp_Fn::operator()(PB_DS_V2F(other.m_p_head->m_p_right->m_value),
+		       PB_DS_V2F(m_p_head->m_p_left->m_value));
+
+  if (!greater && !lesser)
+    __throw_join_error();
+
+  if (lesser)
+    value_swap(other);
+
+  m_size += other.m_size;
+  _GLIBCXX_DEBUG_ONLY(debug_base::join(other);)
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+join_finish(PB_DS_CLASS_C_DEC& other)
+{
+  initialize_min_max();
+  other.initialize();
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+split_prep(key_const_reference r_key, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  other.clear();
+
+  if (m_size == 0)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return false;
+    }
+
+  if (Cmp_Fn::operator()(r_key, PB_DS_V2F(m_p_head->m_p_left->m_value)))
+    {
+      value_swap(other);
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return false;
+    }
+
+  if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(m_p_head->m_p_right->m_value)))
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return false;
+    }
+
+  if (m_size == 1)
+    {
+      value_swap(other);
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return false;
+    }
+
+  _GLIBCXX_DEBUG_ONLY(debug_base::split(r_key,(Cmp_Fn& )(*this), other);)
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+split_finish(PB_DS_CLASS_C_DEC& other)
+{
+  other.initialize_min_max();
+  other.m_size = std::distance(other.begin(), other.end());
+  m_size -= other.m_size;
+  initialize_min_max();
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+recursive_count(node_pointer p) const
+{
+  if (p == 0)
+    return 0;
+  return 1 + recursive_count(p->m_p_left) + recursive_count(p->m_p_right);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/traits.hpp
new file mode 100644
index 0000000..d97b432
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/traits.hpp
@@ -0,0 +1,241 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file bin_search_tree_/traits.hpp
+ * Contains an implementation for bin_search_tree_.
+ */
+
+#ifndef PB_DS_BIN_SEARCH_TREE_NODE_AND_IT_TRAITS_HPP
+#define PB_DS_BIN_SEARCH_TREE_NODE_AND_IT_TRAITS_HPP
+
+#include <ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Binary search tree traits, primary template
+    /// @ingroup traits
+    template<typename Key,
+	     typename Mapped,
+	     class Cmp_Fn,
+	     template<typename Node_CItr,
+		      class Node_Itr,
+		      class Cmp_Fn,
+		      typename _Alloc>
+	     class Node_Update,
+	     class Node,
+	     typename _Alloc>
+    struct bin_search_tree_traits
+    {
+    private:
+      typedef types_traits<Key, Mapped, _Alloc, false> type_traits;
+
+    public:
+      typedef Node node;
+
+      typedef
+      bin_search_tree_const_it_<
+	typename _Alloc::template rebind<
+	node>::other::pointer,
+	typename type_traits::value_type,
+	typename type_traits::pointer,
+	typename type_traits::const_pointer,
+	typename type_traits::reference,
+	typename type_traits::const_reference,
+	true,
+	_Alloc>
+      point_const_iterator;
+
+      typedef
+      bin_search_tree_it_<
+	typename _Alloc::template rebind<
+	node>::other::pointer,
+	typename type_traits::value_type,
+	typename type_traits::pointer,
+	typename type_traits::const_pointer,
+	typename type_traits::reference,
+	typename type_traits::const_reference,
+	true,
+	_Alloc>
+      point_iterator;
+
+      typedef
+      bin_search_tree_const_it_<
+	typename _Alloc::template rebind<
+	node>::other::pointer,
+	typename type_traits::value_type,
+	typename type_traits::pointer,
+	typename type_traits::const_pointer,
+	typename type_traits::reference,
+	typename type_traits::const_reference,
+	false,
+	_Alloc>
+      const_reverse_iterator;
+
+      typedef
+      bin_search_tree_it_<
+	typename _Alloc::template rebind<
+	node>::other::pointer,
+	typename type_traits::value_type,
+	typename type_traits::pointer,
+	typename type_traits::const_pointer,
+	typename type_traits::reference,
+	typename type_traits::const_reference,
+	false,
+	_Alloc>
+      reverse_iterator;
+
+      /// This is an iterator to an iterator: it iterates over nodes,
+      /// and de-referencing it returns one of the tree's iterators.
+      typedef
+      bin_search_tree_const_node_it_<
+	Node,
+	point_const_iterator,
+	point_iterator,
+	_Alloc>
+      node_const_iterator;
+
+      typedef
+      bin_search_tree_node_it_<
+	Node,
+	point_const_iterator,
+	point_iterator,
+	_Alloc>
+      node_iterator;
+
+      typedef
+      Node_Update<
+	node_const_iterator,
+	node_iterator,
+	Cmp_Fn,
+	_Alloc>
+      node_update;
+
+      typedef
+      __gnu_pbds::null_node_update<
+	node_const_iterator,
+	node_iterator,
+	Cmp_Fn,
+	_Alloc>* 
+      null_node_update_pointer;
+    };
+
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     class Cmp_Fn,
+	     template<typename Node_CItr,
+		      class Node_Itr,
+		      class Cmp_Fn,
+		      typename _Alloc>
+	     class Node_Update,
+	     class Node,
+	     typename _Alloc>
+    struct bin_search_tree_traits<
+      Key,
+      null_type,
+      Cmp_Fn,
+      Node_Update,
+      Node,
+      _Alloc>
+    {
+    private:
+      typedef types_traits<Key, null_type, _Alloc, false> type_traits;
+
+    public:
+      typedef Node node;
+
+      typedef
+      bin_search_tree_const_it_<
+	typename _Alloc::template rebind<
+	node>::other::pointer,
+	typename type_traits::value_type,
+	typename type_traits::pointer,
+	typename type_traits::const_pointer,
+	typename type_traits::reference,
+	typename type_traits::const_reference,
+	true,
+	_Alloc>
+      point_const_iterator;
+
+      typedef point_const_iterator point_iterator;
+
+      typedef
+      bin_search_tree_const_it_<
+	typename _Alloc::template rebind<
+	node>::other::pointer,
+	typename type_traits::value_type,
+	typename type_traits::pointer,
+	typename type_traits::const_pointer,
+	typename type_traits::reference,
+	typename type_traits::const_reference,
+	false,
+	_Alloc>
+      const_reverse_iterator;
+
+      typedef const_reverse_iterator reverse_iterator;
+
+      /// This is an iterator to an iterator: it iterates over nodes,
+      /// and de-referencing it returns one of the tree's iterators.
+      typedef
+      bin_search_tree_const_node_it_<
+	Node,
+	point_const_iterator,
+	point_iterator,
+	_Alloc>
+      node_const_iterator;
+
+      typedef node_const_iterator node_iterator;
+
+      typedef
+      Node_Update<node_const_iterator, node_iterator, Cmp_Fn, _Alloc>
+      node_update;
+
+      typedef
+      __gnu_pbds::null_node_update<
+	node_const_iterator,
+	node_iterator,
+	Cmp_Fn,
+	_Alloc>* 
+      null_node_update_pointer;
+    };
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_BIN_SEARCH_TREE_NODE_AND_IT_TRAITS_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/binary_heap_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/binary_heap_.hpp
new file mode 100644
index 0000000..2d6842d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/binary_heap_.hpp
@@ -0,0 +1,352 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/binary_heap_.hpp
+ * Contains an implementation class for a binary heap.
+ */
+
+#ifndef PB_DS_BINARY_HEAP_HPP
+#define PB_DS_BINARY_HEAP_HPP
+
+#include <queue>
+#include <algorithm>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/binary_heap_/entry_cmp.hpp>
+#include <ext/pb_ds/detail/binary_heap_/entry_pred.hpp>
+#include <ext/pb_ds/detail/binary_heap_/resize_policy.hpp>
+#include <ext/pb_ds/detail/binary_heap_/point_const_iterator.hpp>
+#include <ext/pb_ds/detail/binary_heap_/const_iterator.hpp>
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+#include <iostream>
+#endif
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_T_DEC \
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    binary_heap<Value_Type, Cmp_Fn, _Alloc>
+
+#define PB_DS_ENTRY_CMP_DEC \
+    entry_cmp<Value_Type, Cmp_Fn, _Alloc, is_simple<Value_Type>::value>::type
+
+#define PB_DS_RESIZE_POLICY_DEC	\
+    __gnu_pbds::detail::resize_policy<typename _Alloc::size_type>
+
+    /**
+     *  Binary heaps composed of resize and compare policies.
+     *
+     *  @ingroup heap-detail
+     *
+     *  Based on CLRS.
+     */
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+    class binary_heap
+    : public PB_DS_ENTRY_CMP_DEC, public PB_DS_RESIZE_POLICY_DEC
+    {
+    public:
+      typedef Value_Type 				value_type;
+      typedef Cmp_Fn 					cmp_fn;
+      typedef _Alloc 					allocator_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+      typedef typename PB_DS_ENTRY_CMP_DEC 		entry_cmp;
+      typedef PB_DS_RESIZE_POLICY_DEC 			resize_policy;
+      typedef cond_dealtor<value_type, _Alloc> 		cond_dealtor_t;
+
+    private:
+      enum
+	{
+	  simple_value = is_simple<value_type>::value
+	};
+
+      typedef integral_constant<int, simple_value> 	no_throw_copies_t;
+
+      typedef typename _Alloc::template rebind<value_type>	__rebind_v;
+      typedef typename __rebind_v::other 		value_allocator;
+
+    public:
+      typedef typename value_allocator::pointer		pointer;
+      typedef typename value_allocator::const_pointer	const_pointer;
+      typedef typename value_allocator::reference	reference;
+      typedef typename value_allocator::const_reference	const_reference;
+
+      typedef typename __conditional_type<simple_value,
+					  value_type, pointer>::__type
+      							entry;
+
+      typedef typename _Alloc::template rebind<entry>::other
+      							entry_allocator;
+
+      typedef typename entry_allocator::pointer 	entry_pointer;
+
+      typedef binary_heap_point_const_iterator_<value_type, entry,
+						simple_value, _Alloc>
+      							point_const_iterator;
+
+      typedef point_const_iterator 			point_iterator;
+
+      typedef binary_heap_const_iterator_<value_type, entry,
+					  simple_value, _Alloc>
+      							const_iterator;
+
+      typedef const_iterator 				iterator;
+
+
+      binary_heap();
+
+      binary_heap(const cmp_fn&);
+
+      binary_heap(const binary_heap&);
+
+      void
+      swap(binary_heap&);
+
+      ~binary_heap();
+
+      inline bool
+      empty() const;
+
+      inline size_type
+      size() const;
+
+      inline size_type
+      max_size() const;
+
+      Cmp_Fn&
+      get_cmp_fn();
+
+      const Cmp_Fn&
+      get_cmp_fn() const;
+
+      inline point_iterator
+      push(const_reference);
+
+      void
+      modify(point_iterator, const_reference);
+
+      inline const_reference
+      top() const;
+
+      inline void
+      pop();
+
+      inline void
+      erase(point_iterator);
+
+      template<typename Pred>
+	size_type
+	erase_if(Pred);
+
+      inline void
+      erase_at(entry_pointer, size_type, false_type);
+
+      inline void
+      erase_at(entry_pointer, size_type, true_type);
+
+      inline iterator
+      begin();
+
+      inline const_iterator
+      begin() const;
+
+      inline iterator
+      end();
+
+      inline const_iterator
+      end() const;
+
+      void
+      clear();
+
+      template<typename Pred>
+	void
+	split(Pred, binary_heap&);
+
+      void
+      join(binary_heap&);
+
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    protected:
+      template<typename It>
+	void
+	copy_from_range(It, It);
+
+    private:
+      void
+      value_swap(binary_heap&);
+
+      inline void
+      insert_value(const_reference, false_type);
+
+      inline void
+      insert_value(value_type, true_type);
+
+      inline void
+      resize_for_insert_if_needed();
+
+      inline void
+      swap_value_imp(entry_pointer, value_type, true_type);
+
+      inline void
+      swap_value_imp(entry_pointer, const_reference, false_type);
+
+      void
+      fix(entry_pointer);
+
+      inline const_reference
+      top_imp(true_type) const;
+
+      inline const_reference
+      top_imp(false_type) const;
+
+      inline static size_type
+      left_child(size_type);
+
+      inline static size_type
+      right_child(size_type);
+
+      inline static size_type
+      parent(size_type);
+
+      inline void
+      resize_for_erase_if_needed();
+
+      template<typename Pred>
+      size_type
+      partition(Pred);
+
+      void
+      make_heap()
+      {
+	const entry_cmp& m_cmp = static_cast<entry_cmp&>(*this);
+	entry_pointer end = m_a_entries + m_size;
+	std::make_heap(m_a_entries, end, m_cmp);
+	_GLIBCXX_DEBUG_ASSERT(is_heap());
+      }
+
+      void
+      push_heap()
+      {
+	if (!is_heap())
+	  make_heap();
+	else
+	  {
+	    const entry_cmp& m_cmp = static_cast<entry_cmp&>(*this);
+	    entry_pointer end = m_a_entries + m_size;
+	    std::push_heap(m_a_entries, end, m_cmp);
+	  }
+      }
+
+      void
+      pop_heap()
+      {
+	const entry_cmp& m_cmp = static_cast<entry_cmp&>(*this);
+	entry_pointer end = m_a_entries + m_size;
+	std::pop_heap(m_a_entries, end, m_cmp);
+      }
+
+      bool
+      is_heap()
+      {
+	const entry_cmp& m_cmp = static_cast<entry_cmp&>(*this);
+	entry_pointer end = m_a_entries + m_size;
+	bool p = std::__is_heap(m_a_entries, end, m_cmp);
+	return p;
+      }
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+      void
+      trace_entry(const entry&, false_type) const;
+
+      void
+      trace_entry(const entry&, true_type) const;
+#endif
+
+      static entry_allocator 	s_entry_allocator;
+      static value_allocator 	s_value_allocator;
+      static no_throw_copies_t 	s_no_throw_copies_ind;
+
+      size_type 		m_size;
+      size_type 		m_actual_size;
+      entry_pointer 		m_a_entries;
+    };
+
+#define PB_DS_ASSERT_VALID(X) \
+  _GLIBCXX_DEBUG_ONLY(X.assert_valid(__FILE__, __LINE__);)
+
+#define PB_DS_DEBUG_VERIFY(_Cond)					\
+  _GLIBCXX_DEBUG_VERIFY_AT(_Cond,					\
+			   _M_message(#_Cond" assertion from %1;:%2;")	\
+			   ._M_string(__FILE__)._M_integer(__LINE__)	\
+			   ,__file,__line)
+
+#include <ext/pb_ds/detail/binary_heap_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/iterators_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/trace_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/info_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp>
+#include <ext/pb_ds/detail/binary_heap_/policy_access_fn_imps.hpp>
+
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_ENTRY_CMP_DEC
+#undef PB_DS_RESIZE_POLICY_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp
new file mode 100644
index 0000000..0f41db0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp
@@ -0,0 +1,139 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/const_iterator.hpp
+ * Contains an iterator class returned by the table's const find and insert
+ *     methods.
+ */
+
+#ifndef PB_DS_BINARY_HEAP_CONST_ITERATOR_HPP
+#define PB_DS_BINARY_HEAP_CONST_ITERATOR_HPP
+
+#include <ext/pb_ds/detail/binary_heap_/point_const_iterator.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_BIN_HEAP_CIT_BASE \
+    binary_heap_point_const_iterator_<Value_Type, Entry, Simple, _Alloc>
+
+    /// Const point-type iterator.
+    template<typename Value_Type,
+	     typename Entry,
+	     bool Simple,
+	     typename _Alloc>
+    class binary_heap_const_iterator_ : public PB_DS_BIN_HEAP_CIT_BASE
+    {
+    private:
+      typedef PB_DS_BIN_HEAP_CIT_BASE 		       	base_type;
+      typedef typename base_type::entry_pointer 	entry_pointer;
+
+    public:
+      /// Category.
+      typedef std::forward_iterator_tag 		iterator_category;
+
+      /// Difference type.
+      typedef typename _Alloc::difference_type 		difference_type;
+
+      /// Iterator's value type.
+      typedef typename base_type::value_type 		value_type;
+
+      /// Iterator's pointer type.
+      typedef typename base_type::pointer 		pointer;
+
+      /// Iterator's const pointer type.
+      typedef typename base_type::const_pointer 	const_pointer;
+
+      /// Iterator's reference type.
+      typedef typename base_type::reference 		reference;
+
+      /// Iterator's const reference type.
+      typedef typename base_type::const_reference 	const_reference;
+
+      inline
+      binary_heap_const_iterator_(entry_pointer p_e) : base_type(p_e)
+      { }
+
+      /// Default constructor.
+      inline
+      binary_heap_const_iterator_()
+      { }
+
+      /// Copy constructor.
+      inline
+      binary_heap_const_iterator_(const binary_heap_const_iterator_& other) 
+      : base_type(other)
+      { }
+
+      /// Compares content to a different iterator object.
+      inline bool
+      operator==(const binary_heap_const_iterator_& other) const
+      { return base_type::m_p_e == other.m_p_e; }
+
+      /// Compares content (negatively) to a different iterator object.
+      inline bool
+      operator!=(const binary_heap_const_iterator_& other) const
+      { return base_type::m_p_e != other.m_p_e; }
+
+      inline binary_heap_const_iterator_& 
+      operator++()
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_type::m_p_e != 0);
+	inc();
+	return *this;
+      }
+
+      inline binary_heap_const_iterator_
+      operator++(int)
+      {
+	binary_heap_const_iterator_ ret_it(base_type::m_p_e);
+	operator++();
+	return ret_it;
+      }
+
+    private:
+      void
+      inc()
+      { ++base_type::m_p_e; }
+    };
+
+#undef PB_DS_BIN_HEAP_CIT_BASE
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..b3aef0e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,139 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for binary_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::entry_allocator
+PB_DS_CLASS_C_DEC::s_entry_allocator;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::value_allocator
+PB_DS_CLASS_C_DEC::s_value_allocator;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::no_throw_copies_t
+PB_DS_CLASS_C_DEC::s_no_throw_copies_ind;
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    {
+      insert_value(*first_it, s_no_throw_copies_ind);
+      ++first_it;
+    }
+  make_heap();
+ PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binary_heap()
+: m_size(0), m_actual_size(resize_policy::min_size),
+  m_a_entries(s_entry_allocator.allocate(m_actual_size))
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binary_heap(const Cmp_Fn& r_cmp_fn)
+: entry_cmp(r_cmp_fn), m_size(0), m_actual_size(resize_policy::min_size),
+  m_a_entries(s_entry_allocator.allocate(m_actual_size))
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binary_heap(const PB_DS_CLASS_C_DEC& other)
+: entry_cmp(other), resize_policy(other), m_size(0),
+  m_actual_size(other.m_actual_size),
+  m_a_entries(s_entry_allocator.allocate(m_actual_size))
+{
+  PB_DS_ASSERT_VALID(other)
+  _GLIBCXX_DEBUG_ASSERT(m_a_entries != other.m_a_entries);
+
+  __try
+    {
+      copy_from_range(other.begin(), other.end());
+    }
+  __catch(...)
+    {
+      for (size_type i = 0; i < m_size; ++i)
+	erase_at(m_a_entries, i, s_no_throw_copies_ind);
+
+      s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+      __throw_exception_again;
+    }
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  _GLIBCXX_DEBUG_ASSERT(m_a_entries != other.m_a_entries);
+  value_swap(other);
+  std::swap((entry_cmp&)(*this), (entry_cmp&)other);
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+value_swap(PB_DS_CLASS_C_DEC& other)
+{
+  std::swap(m_a_entries, other.m_a_entries);
+  std::swap(m_size, other.m_size);
+  std::swap(m_actual_size, other.m_actual_size);
+  static_cast<resize_policy*>(this)->swap(other);
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~binary_heap()
+{
+  for (size_type i = 0; i < m_size; ++i)
+    erase_at(m_a_entries, i, s_no_throw_copies_ind);
+  s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/debug_fn_imps.hpp
new file mode 100644
index 0000000..b9c645c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/debug_fn_imps.hpp
@@ -0,0 +1,72 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/debug_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+#ifdef PB_DS_REGRESSION
+  s_entry_allocator.check_allocated(m_a_entries, m_actual_size);
+#endif
+
+  resize_policy::assert_valid(__file, __line);
+  PB_DS_DEBUG_VERIFY(m_size <= m_actual_size);
+  for (size_type i = 0; i < m_size; ++i)
+    {
+#ifdef PB_DS_REGRESSION
+      s_value_allocator.check_allocated(m_a_entries[i], 1);
+#endif
+
+      if (left_child(i) < m_size)
+	PB_DS_DEBUG_VERIFY(!entry_cmp::operator()(m_a_entries[i], m_a_entries[left_child(i)]));
+
+      PB_DS_DEBUG_VERIFY(parent(left_child(i)) == i);
+
+      if (right_child(i) < m_size)
+	PB_DS_DEBUG_VERIFY(!entry_cmp::operator()(m_a_entries[i], m_a_entries[right_child(i)]));
+
+      PB_DS_DEBUG_VERIFY(parent(right_child(i)) == i);
+    }
+}
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/entry_cmp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/entry_cmp.hpp
new file mode 100644
index 0000000..3908206
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/entry_cmp.hpp
@@ -0,0 +1,85 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/entry_cmp.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+#ifndef PB_DS_BINARY_HEAP_ENTRY_CMP_HPP
+#define PB_DS_BINARY_HEAP_ENTRY_CMP_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Entry compare, primary template.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc, bool No_Throw>
+      struct entry_cmp;
+
+    /// Specialization, true.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc>
+      struct entry_cmp<_VTp, Cmp_Fn, _Alloc, true>
+      {
+	/// Compare.
+	typedef Cmp_Fn 						type;
+      };
+
+    /// Specialization, false.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc>
+      struct entry_cmp<_VTp, Cmp_Fn, _Alloc, false>
+      {
+      private:
+	typedef typename _Alloc::template rebind<_VTp>		__rebind_v;
+
+      public:
+	typedef typename __rebind_v::other::const_pointer	entry;
+
+	/// Compare plus entry.
+	struct type : public Cmp_Fn
+	{
+	  type() { }
+
+	  type(const Cmp_Fn& other) : Cmp_Fn(other) { }
+
+	  bool
+	  operator()(entry lhs, entry rhs) const
+	  { return Cmp_Fn::operator()(*lhs, *rhs); }
+	};
+      };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_BINARY_HEAP_ENTRY_CMP_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/entry_pred.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/entry_pred.hpp
new file mode 100644
index 0000000..660c18a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/entry_pred.hpp
@@ -0,0 +1,85 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/entry_pred.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+#ifndef PB_DS_BINARY_HEAP_ENTRY_PRED_HPP
+#define PB_DS_BINARY_HEAP_ENTRY_PRED_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Entry predicate primary class template.
+    template<typename _VTp, typename Pred, typename _Alloc, bool No_Throw>
+      struct entry_pred;
+
+    /// Specialization, true.
+    template<typename _VTp, typename Pred, typename _Alloc>
+      struct entry_pred<_VTp, Pred, _Alloc, true>
+      {
+	typedef Pred 						type;
+      };
+
+    /// Specialization, false.
+    template<typename _VTp, typename Pred, typename _Alloc>
+      struct entry_pred<_VTp, Pred, _Alloc, false>
+      {
+      private:
+	typedef typename _Alloc::template rebind<_VTp>		__rebind_v;
+
+      public:
+	typedef typename __rebind_v::other::const_pointer	entry;
+
+	struct type : public Pred
+	{
+	  inline
+	  type() { }
+
+	  inline
+	  type(const Pred& other) : Pred(other) { }
+
+	  inline bool
+	  operator()(entry p_v) const
+	  { return Pred::operator()(*p_v); }
+	};
+      };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_BINARY_HEAP_ENTRY_PRED_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/erase_fn_imps.hpp
new file mode 100644
index 0000000..3fcf6c8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/erase_fn_imps.hpp
@@ -0,0 +1,208 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/erase_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  for (size_type i = 0; i < m_size; ++i)
+    erase_at(m_a_entries, i, s_no_throw_copies_ind);
+
+  __try
+    {
+      const size_type new_size = resize_policy::get_new_size_for_arbitrary(0);
+      entry_pointer new_entries = s_entry_allocator.allocate(new_size);
+      resize_policy::notify_arbitrary(new_size);
+      s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+      m_actual_size = new_size;
+      m_a_entries = new_entries;
+    }
+  __catch(...)
+    { }
+
+  m_size = 0;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_at(entry_pointer a_entries, size_type i, false_type)
+{
+  a_entries[i]->~value_type();
+  s_value_allocator.deallocate(a_entries[i], 1);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_at(entry_pointer, size_type, true_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+pop()
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!empty());
+
+  pop_heap();
+  erase_at(m_a_entries, m_size - 1, s_no_throw_copies_ind);
+  resize_for_erase_if_needed();
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  --m_size;
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  typedef typename entry_pred<value_type, Pred, _Alloc, simple_value>::type
+    pred_t;
+
+  const size_type left = partition(pred_t(pred));
+  _GLIBCXX_DEBUG_ASSERT(m_size >= left);
+  const size_type ersd = m_size - left;
+  for (size_type i = left; i < m_size; ++i)
+    erase_at(m_a_entries, i, s_no_throw_copies_ind);
+
+  __try
+    {
+      const size_type new_size =
+	resize_policy::get_new_size_for_arbitrary(left);
+
+      entry_pointer new_entries = s_entry_allocator.allocate(new_size);
+      std::copy(m_a_entries, m_a_entries + left, new_entries);
+      s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+      m_actual_size = new_size;
+      resize_policy::notify_arbitrary(m_actual_size);
+    }
+  __catch(...)
+    { };
+
+  m_size = left;
+  make_heap();
+  PB_DS_ASSERT_VALID((*this))
+  return ersd;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+erase(point_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!empty());
+
+  const size_type fix_pos = it.m_p_e - m_a_entries;
+  std::swap(*it.m_p_e, m_a_entries[m_size - 1]);
+  erase_at(m_a_entries, m_size - 1, s_no_throw_copies_ind);
+  resize_for_erase_if_needed();
+
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  --m_size;
+  _GLIBCXX_DEBUG_ASSERT(fix_pos <= m_size);
+
+  if (fix_pos != m_size)
+    fix(m_a_entries + fix_pos);
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+resize_for_erase_if_needed()
+{
+  if (!resize_policy::resize_needed_for_shrink(m_size))
+    return;
+
+  __try
+    {
+      const size_type new_size = resize_policy::get_new_size_for_shrink();
+      entry_pointer new_entries = s_entry_allocator.allocate(new_size);
+      resize_policy::notify_shrink_resize();
+
+      _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+      std::copy(m_a_entries, m_a_entries + m_size - 1, new_entries);
+      s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+      m_actual_size = new_size;
+      m_a_entries = new_entries;
+    }
+  __catch(...)
+    { }
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+partition(Pred pred)
+{
+  size_type left = 0;
+  size_type right = m_size - 1;
+
+  while (right + 1 != left)
+    {
+      _GLIBCXX_DEBUG_ASSERT(left <= m_size);
+
+      if (!pred(m_a_entries[left]))
+	++left;
+      else if (pred(m_a_entries[right]))
+	--right;
+      else
+	{
+	  _GLIBCXX_DEBUG_ASSERT(left < right);
+	  std::swap(m_a_entries[left], m_a_entries[right]);
+	  ++left;
+	  --right;
+	}
+    }
+
+  return left;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/find_fn_imps.hpp
new file mode 100644
index 0000000..3f61fe3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/find_fn_imps.hpp
@@ -0,0 +1,79 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/find_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reference
+PB_DS_CLASS_C_DEC::
+top() const
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!empty());
+  return top_imp(s_no_throw_copies_ind);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reference
+PB_DS_CLASS_C_DEC::
+top_imp(true_type) const
+{ return *m_a_entries; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reference
+PB_DS_CLASS_C_DEC::
+top_imp(false_type) const
+{ return **m_a_entries; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+left_child(size_type i)
+{ return i * 2 + 1; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+right_child(size_type i)
+{ return i * 2 + 2; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+parent(size_type i)
+{ return (i - 1) / 2; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/info_fn_imps.hpp
new file mode 100644
index 0000000..2f6584f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/info_fn_imps.hpp
@@ -0,0 +1,58 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/info_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{ return m_size == 0; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{ return m_size; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{ return s_entry_allocator.max_size(); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/insert_fn_imps.hpp
new file mode 100644
index 0000000..8ade3a9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/insert_fn_imps.hpp
@@ -0,0 +1,174 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/insert_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+push(const_reference r_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+  insert_value(r_val, s_no_throw_copies_ind);
+  push_heap();
+  PB_DS_ASSERT_VALID((*this))
+  return point_iterator(m_a_entries);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+insert_value(value_type val, true_type)
+{
+  resize_for_insert_if_needed();
+  m_a_entries[m_size++] = val;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+insert_value(const_reference r_val, false_type)
+{
+  resize_for_insert_if_needed();
+  pointer p_new = s_value_allocator.allocate(1);
+  cond_dealtor_t cond(p_new);
+  new (p_new) value_type(r_val);
+  cond.set_no_action();
+  m_a_entries[m_size++] = p_new;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+resize_for_insert_if_needed()
+{
+  if (!resize_policy::resize_needed_for_grow(m_size))
+    {
+      _GLIBCXX_DEBUG_ASSERT(m_size < m_actual_size);
+      return;
+    }
+
+  const size_type new_size = resize_policy::get_new_size_for_grow();
+  entry_pointer new_entries = s_entry_allocator.allocate(new_size);
+  resize_policy::notify_grow_resize();
+
+  std::copy(m_a_entries, m_a_entries + m_size, new_entries);
+  s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+  m_actual_size = new_size;
+  m_a_entries = new_entries;
+  make_heap();
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+modify(point_iterator it, const_reference r_new_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+  swap_value_imp(it.m_p_e, r_new_val, s_no_throw_copies_ind);
+  fix(it.m_p_e);
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(is_heap());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+fix(entry_pointer p_e)
+{
+  size_type i = p_e - m_a_entries;
+  if (i > 0 && entry_cmp::operator()(m_a_entries[parent(i)], m_a_entries[i]))
+    {
+      size_type parent_i = parent(i);
+      while (i > 0
+	     && entry_cmp::operator()(m_a_entries[parent_i], m_a_entries[i]))
+	{
+	  std::swap(m_a_entries[i], m_a_entries[parent_i]);
+	  i = parent_i;
+	  parent_i = parent(i);
+	}
+
+      PB_DS_ASSERT_VALID((*this))
+      return;
+    }
+
+  while (i < m_size)
+    {
+      const size_type lchild_i = left_child(i);
+      const size_type rchild_i = right_child(i);
+      _GLIBCXX_DEBUG_ASSERT(rchild_i > lchild_i);
+
+      const bool smaller_than_lchild = lchild_i < m_size &&
+	entry_cmp::operator()(m_a_entries[i], m_a_entries[lchild_i]);
+
+      const bool smaller_than_rchild = rchild_i < m_size &&
+	entry_cmp::operator()(m_a_entries[i], m_a_entries[rchild_i]);
+
+      const bool swap_with_rchild = smaller_than_rchild && (!smaller_than_lchild || entry_cmp::operator()(m_a_entries[lchild_i], m_a_entries[rchild_i]));
+
+      const bool swap_with_lchild = !swap_with_rchild && smaller_than_lchild;
+
+      if (swap_with_lchild)
+	{
+	  std::swap(m_a_entries[i], m_a_entries[lchild_i]);
+	  i = lchild_i;
+	}
+      else if (swap_with_rchild)
+	{
+	  std::swap(m_a_entries[i], m_a_entries[rchild_i]);
+	  i = rchild_i;
+	}
+      else
+	i = m_size;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+swap_value_imp(entry_pointer p_e, value_type new_val, true_type)
+{ *p_e = new_val; }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+swap_value_imp(entry_pointer p_e, const_reference r_new_val, false_type)
+{
+  value_type tmp(r_new_val);
+  (*p_e)->swap(tmp);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/iterators_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/iterators_fn_imps.hpp
new file mode 100644
index 0000000..35dd014
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/iterators_fn_imps.hpp
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/iterators_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+begin()
+{ return iterator(m_a_entries); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin() const
+{ return const_iterator(m_a_entries); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+end()
+{ return iterator(m_a_entries + m_size); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end() const
+{ return const_iterator(m_a_entries + m_size); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/point_const_iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/point_const_iterator.hpp
new file mode 100644
index 0000000..f16a001
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/point_const_iterator.hpp
@@ -0,0 +1,144 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/point_const_iterator.hpp
+ * Contains an iterator class returned by the table's const find and insert
+ * methods.
+ */
+
+#ifndef PB_DS_BINARY_HEAP_CONST_FIND_ITERATOR_HPP
+#define PB_DS_BINARY_HEAP_CONST_FIND_ITERATOR_HPP
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Const point-type iterator.
+    template<typename Value_Type, typename Entry, bool Simple, 
+	     typename _Alloc>
+    class binary_heap_point_const_iterator_
+    {
+    protected:
+      typedef typename _Alloc::template rebind<Entry>::other::pointer entry_pointer;
+
+    public:
+      /// Category.
+      typedef trivial_iterator_tag iterator_category;
+
+      /// Difference type.
+      typedef trivial_iterator_difference_type difference_type;
+
+      /// Iterator's value type.
+      typedef Value_Type value_type;
+
+      /// Iterator's pointer type.
+      typedef typename _Alloc::template rebind<value_type>::other::pointer
+      pointer;
+
+      /// Iterator's const pointer type.
+      typedef
+      typename _Alloc::template rebind<value_type>::other::const_pointer
+      const_pointer;
+
+      /// Iterator's reference type.
+      typedef
+      typename _Alloc::template rebind<value_type>::other::reference
+      reference;
+
+      /// Iterator's const reference type.
+      typedef
+      typename _Alloc::template rebind<value_type>::other::const_reference
+      const_reference;
+
+      inline
+      binary_heap_point_const_iterator_(entry_pointer p_e) : m_p_e(p_e)
+      { }
+
+      /// Default constructor.
+      inline
+      binary_heap_point_const_iterator_() : m_p_e(0) { }
+
+      /// Copy constructor.
+      inline
+      binary_heap_point_const_iterator_(const binary_heap_point_const_iterator_& other)
+      : m_p_e(other.m_p_e)
+      { }
+
+      /// Access.
+      inline const_pointer
+      operator->() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_e != 0);
+	return to_ptr(integral_constant<int, Simple>());
+      }
+
+      /// Access.
+      inline const_reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_e != 0);
+	return *to_ptr(integral_constant<int, Simple>());
+      }
+
+      /// Compares content to a different iterator object.
+      inline bool
+      operator==(const binary_heap_point_const_iterator_& other) const
+      { return m_p_e == other.m_p_e; }
+
+      /// Compares content (negatively) to a different iterator object.
+      inline bool
+      operator!=(const binary_heap_point_const_iterator_& other) const
+      { return m_p_e != other.m_p_e; }
+
+    private:
+      inline const_pointer
+      to_ptr(true_type) const
+      { return m_p_e; }
+
+      inline const_pointer
+      to_ptr(false_type) const
+      { return *m_p_e; }
+
+    public:
+      entry_pointer m_p_e;
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/policy_access_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/policy_access_fn_imps.hpp
new file mode 100644
index 0000000..805d6af
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/policy_access_fn_imps.hpp
@@ -0,0 +1,56 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/policy_access_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn()
+{
+  return (*this);
+}
+
+PB_DS_CLASS_T_DEC
+const Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn() const
+{
+  return (*this);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/resize_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/resize_policy.hpp
new file mode 100644
index 0000000..f5b7ccb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/resize_policy.hpp
@@ -0,0 +1,240 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/resize_policy.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+#ifndef PB_DS_BINARY_HEAP_RESIZE_POLICY_HPP
+#define PB_DS_BINARY_HEAP_RESIZE_POLICY_HPP
+
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Resize policy for binary heap.
+    template<typename _Tp>
+    class resize_policy
+    {
+    private:
+      enum
+	{
+	  ratio = 8,
+	  factor = 2
+	};
+
+      /// Next shrink size.
+      _Tp 		m_shrink_size;
+
+      /// Next grow size.
+      _Tp 		m_grow_size;
+
+    public:
+      typedef _Tp	size_type;
+
+      static const _Tp	min_size = 16;
+
+      resize_policy() : m_shrink_size(0), m_grow_size(min_size)
+      { PB_DS_ASSERT_VALID((*this)) }
+
+      resize_policy(const resize_policy& other)
+      : m_shrink_size(other.m_shrink_size), m_grow_size(other.m_grow_size)
+      { PB_DS_ASSERT_VALID((*this)) }
+
+      inline void
+      swap(resize_policy<_Tp>&);
+
+      inline bool
+      resize_needed_for_grow(size_type) const;
+
+      inline bool
+      resize_needed_for_shrink(size_type) const;
+
+      inline bool
+      grow_needed(size_type) const;
+
+      inline bool
+      shrink_needed(size_type) const;
+
+      inline size_type
+      get_new_size_for_grow() const;
+
+      inline size_type
+      get_new_size_for_shrink() const;
+
+      inline size_type
+      get_new_size_for_arbitrary(size_type) const;
+
+      inline void
+      notify_grow_resize();
+
+      inline void
+      notify_shrink_resize();
+
+      void
+      notify_arbitrary(size_type);
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+      void
+      trace() const;
+#endif
+    };
+
+    template<typename _Tp>
+      const _Tp resize_policy<_Tp>::min_size;
+
+    template<typename _Tp>
+    inline void
+    resize_policy<_Tp>::
+    swap(resize_policy<_Tp>& other)
+    {
+      std::swap(m_shrink_size, other.m_shrink_size);
+      std::swap(m_grow_size, other.m_grow_size);
+    }
+
+    template<typename _Tp>
+    inline bool
+    resize_policy<_Tp>::
+    resize_needed_for_grow(size_type size) const
+    {
+      _GLIBCXX_DEBUG_ASSERT(size <= m_grow_size);
+      return size == m_grow_size;
+    }
+
+    template<typename _Tp>
+    inline bool
+    resize_policy<_Tp>::
+    resize_needed_for_shrink(size_type size) const
+    {
+      _GLIBCXX_DEBUG_ASSERT(size <= m_grow_size);
+      return size == m_shrink_size;
+    }
+
+    template<typename _Tp>
+    inline typename resize_policy<_Tp>::size_type
+    resize_policy<_Tp>::
+    get_new_size_for_grow() const
+    { return m_grow_size * factor; }
+
+    template<typename _Tp>
+    inline typename resize_policy<_Tp>::size_type
+    resize_policy<_Tp>::
+    get_new_size_for_shrink() const
+    {
+      const size_type half_size = m_grow_size / factor;
+      return std::max(min_size, half_size);
+    }
+
+    template<typename _Tp>
+    inline typename resize_policy<_Tp>::size_type
+    resize_policy<_Tp>::
+    get_new_size_for_arbitrary(size_type size) const
+    {
+      size_type ret = min_size;
+      while (ret < size)
+	ret *= factor;
+      return ret;
+    }
+
+    template<typename _Tp>
+    inline void
+    resize_policy<_Tp>::
+    notify_grow_resize()
+    {
+      PB_DS_ASSERT_VALID((*this))
+      _GLIBCXX_DEBUG_ASSERT(m_grow_size >= min_size);
+      m_grow_size *= factor;
+      m_shrink_size = m_grow_size / ratio;
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    template<typename _Tp>
+    inline void
+    resize_policy<_Tp>::
+    notify_shrink_resize()
+    {
+      PB_DS_ASSERT_VALID((*this))
+      m_shrink_size /= factor;
+      if (m_shrink_size == 1)
+	m_shrink_size = 0;
+      m_grow_size = std::max(m_grow_size / factor, min_size);
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    template<typename _Tp>
+    inline void
+    resize_policy<_Tp>::
+    notify_arbitrary(size_type actual_size)
+    {
+      m_grow_size = actual_size;
+      m_shrink_size = m_grow_size / ratio;
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+#ifdef _GLIBCXX_DEBUG
+    template<typename _Tp>
+    void
+    resize_policy<_Tp>::
+    assert_valid(const char* __file, int __line) const
+    {
+      PB_DS_DEBUG_VERIFY(m_shrink_size == 0
+			 || m_shrink_size * ratio == m_grow_size);
+      PB_DS_DEBUG_VERIFY(m_grow_size >= min_size);
+    }
+#endif
+
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+    template<typename _Tp>
+    void
+    resize_policy<_Tp>::
+    trace() const
+    {
+      std::cerr << "shrink = " << m_shrink_size
+		<< " grow = " << m_grow_size << std::endl;
+    }
+#endif
+
+} // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..322ac08
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp
@@ -0,0 +1,160 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/split_join_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+void
+PB_DS_CLASS_C_DEC::
+split(Pred pred, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  typedef
+    typename entry_pred<value_type, Pred, _Alloc, simple_value>::type
+    pred_t;
+
+  const size_type left = partition(pred_t(pred));
+  _GLIBCXX_DEBUG_ASSERT(m_size >= left);
+
+  const size_type ersd = m_size - left;
+  _GLIBCXX_DEBUG_ASSERT(m_size >= ersd);
+
+  const size_type new_size = resize_policy::get_new_size_for_arbitrary(left);
+  const size_type other_actual_size = other.get_new_size_for_arbitrary(ersd);
+
+  entry_pointer a_entries = 0;
+  entry_pointer a_other_entries = 0;
+
+  __try
+    {
+      a_entries = s_entry_allocator.allocate(new_size);
+      a_other_entries = s_entry_allocator.allocate(other_actual_size);
+    }
+  __catch(...)
+    {
+      if (a_entries != 0)
+	s_entry_allocator.deallocate(a_entries, new_size);
+
+      if (a_other_entries != 0)
+	s_entry_allocator.deallocate(a_other_entries, other_actual_size);
+
+      __throw_exception_again;
+    };
+
+  for (size_type i = 0; i < other.m_size; ++i)
+    erase_at(other.m_a_entries, i, s_no_throw_copies_ind);
+
+  _GLIBCXX_DEBUG_ASSERT(new_size >= left);
+  std::copy(m_a_entries, m_a_entries + left, a_entries);
+  std::copy(m_a_entries + left, m_a_entries + m_size, a_other_entries);
+
+  s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+  s_entry_allocator.deallocate(other.m_a_entries, other.m_actual_size);
+
+  m_actual_size = new_size;
+  other.m_actual_size = other_actual_size;
+
+  m_size = left;
+  other.m_size = ersd;
+
+  m_a_entries = a_entries;
+  other.m_a_entries = a_other_entries;
+
+  make_heap();
+  other.make_heap();
+
+  resize_policy::notify_arbitrary(m_actual_size);
+  other.notify_arbitrary(other.m_actual_size);
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  const size_type len = m_size + other.m_size;
+  const size_type new_size = resize_policy::get_new_size_for_arbitrary(len);
+
+  entry_pointer a_entries = 0;
+  entry_pointer a_other_entries = 0;
+
+  __try
+    {
+      a_entries = s_entry_allocator.allocate(new_size);
+      a_other_entries = s_entry_allocator.allocate(resize_policy::min_size);
+    }
+  __catch(...)
+    {
+      if (a_entries != 0)
+	s_entry_allocator.deallocate(a_entries, new_size);
+
+      if (a_other_entries != 0)
+	s_entry_allocator.deallocate(a_other_entries, resize_policy::min_size);
+
+      __throw_exception_again;
+    }
+
+  std::copy(m_a_entries, m_a_entries + m_size, a_entries);
+  std::copy(other.m_a_entries, other.m_a_entries + other.m_size,
+	    a_entries + m_size);
+
+  s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+  m_a_entries = a_entries;
+  m_size = len;
+  m_actual_size = new_size;
+  resize_policy::notify_arbitrary(new_size);
+  make_heap();
+
+  s_entry_allocator.deallocate(other.m_a_entries, other.m_actual_size);
+  other.m_a_entries = a_other_entries;
+  other.m_size = 0;
+  other.m_actual_size = resize_policy::min_size;
+  other.notify_arbitrary(resize_policy::min_size);
+  other.make_heap();
+  
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/trace_fn_imps.hpp
new file mode 100644
index 0000000..5176a69
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/trace_fn_imps.hpp
@@ -0,0 +1,78 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binary_heap_/trace_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  std::cerr << this << std::endl;
+
+  std::cerr << m_a_entries << std::endl;
+
+  for (size_type i = 0; i < m_size; ++i)
+    trace_entry(m_a_entries[i], s_no_throw_copies_ind);
+
+  std::cerr << std::endl;
+
+  std::cerr << "size = " << m_size << " " << "actual_size = " << m_actual_size << std::endl;
+
+  resize_policy::trace();
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace_entry(const entry& r_e, false_type) const
+{
+  std::cout << r_e << " " <<* r_e << std::endl;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace_entry(const entry& r_e, true_type) const
+{
+  std::cout << r_e << std::endl;
+}
+
+#endif // #ifdef PB_DS_BINARY_HEAP_TRACE_
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/binomial_heap_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/binomial_heap_.hpp
new file mode 100644
index 0000000..ee078a8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/binomial_heap_.hpp
@@ -0,0 +1,112 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_.hpp
+ * Contains an implementation class for a binomial heap.
+ */
+
+/*
+ * Binomial heap.
+ * Vuillemin J is the mastah.
+ * Modified from CLRS.
+ */
+
+#include <debug/debug.h>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_T_DEC \
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    binomial_heap<Value_Type, Cmp_Fn, _Alloc>
+
+    /**
+     *  Binomial heap.
+     *
+     *  @ingroup heap-detail
+     */
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+    class binomial_heap
+    : public binomial_heap_base<Value_Type, Cmp_Fn, _Alloc>
+    {
+    private:
+      typedef binomial_heap_base<Value_Type, Cmp_Fn, _Alloc> 	base_type;
+      typedef typename base_type::node_pointer 		node_pointer;
+      typedef typename base_type::node_const_pointer 	node_const_pointer;
+
+    public:
+      typedef Value_Type 				value_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+      typedef typename base_type::pointer 		pointer;
+      typedef typename base_type::const_pointer 	const_pointer;
+      typedef typename base_type::reference 		reference;
+      typedef typename base_type::const_reference 	const_reference;
+      typedef typename base_type::point_const_iterator 	point_const_iterator;
+      typedef typename base_type::point_iterator 	point_iterator;
+      typedef typename base_type::const_iterator 	const_iterator;
+      typedef typename base_type::iterator 		iterator;
+      typedef typename base_type::cmp_fn 		cmp_fn;
+      typedef typename base_type::allocator_type 	allocator_type;
+
+      binomial_heap();
+
+      binomial_heap(const Cmp_Fn&);
+
+      binomial_heap(const binomial_heap&);
+
+      ~binomial_heap();
+
+    protected:
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+    };
+
+#include <ext/pb_ds/detail/binomial_heap_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/binomial_heap_/debug_fn_imps.hpp>
+
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..cd8dbca
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,60 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/binomial_heap_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation for binomial_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binomial_heap()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binomial_heap(const Cmp_Fn& r_cmp_fn)
+: base_type(r_cmp_fn)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binomial_heap(const PB_DS_CLASS_C_DEC& other)
+: base_type(other)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~binomial_heap() { }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/debug_fn_imps.hpp
new file mode 100644
index 0000000..f03ec00
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_/debug_fn_imps.hpp
@@ -0,0 +1,49 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/binomial_heap_/debug_fn_imps.hpp
+ * Contains an implementation for binomial_heap_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{ base_type::assert_valid(true, __file, __line); }
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp
new file mode 100644
index 0000000..eb916bc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp
@@ -0,0 +1,211 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_base_/binomial_heap_base_.hpp
+ * Contains an implementation class for a base of binomial heaps.
+ */
+
+#ifndef PB_DS_BINOMIAL_HEAP_BASE_HPP
+#define PB_DS_BINOMIAL_HEAP_BASE_HPP
+
+/*
+ * Binomial heap base.
+ * Vuillemin J is the mastah.
+ * Modified from CLRS.
+ */
+
+#include <debug/debug.h>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_T_DEC \
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    binomial_heap_base<Value_Type, Cmp_Fn, _Alloc>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_B_HEAP_BASE \
+  left_child_next_sibling_heap<Value_Type, Cmp_Fn, \
+				typename _Alloc::size_type,  _Alloc, false>
+#else
+#define PB_DS_B_HEAP_BASE \
+  left_child_next_sibling_heap<Value_Type, Cmp_Fn, \
+				typename _Alloc::size_type, _Alloc>
+#endif
+
+    /// Base class for binomial heap.
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+    class binomial_heap_base
+    : public PB_DS_B_HEAP_BASE
+    {
+    private:
+      typedef typename _Alloc::template rebind<Value_Type>::other __rebind_v;
+      typedef PB_DS_B_HEAP_BASE	  			base_type;
+
+    protected:
+      typedef typename base_type::node 			node;
+      typedef typename base_type::node_pointer 		node_pointer;
+      typedef typename base_type::node_const_pointer 	node_const_pointer;
+
+    public:
+      typedef Value_Type 				value_type;
+      typedef Cmp_Fn 					cmp_fn;
+      typedef _Alloc 					allocator_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+
+      typedef typename __rebind_v::pointer 		pointer;
+      typedef typename __rebind_v::const_pointer 	const_pointer;
+      typedef typename __rebind_v::reference 		reference;
+      typedef typename __rebind_v::const_reference   	const_reference;
+
+      typedef typename base_type::point_const_iterator 	point_const_iterator;
+      typedef typename base_type::point_iterator 	point_iterator;
+      typedef typename base_type::const_iterator 	const_iterator;
+      typedef typename base_type::iterator 		iterator;
+
+    public:
+
+      inline point_iterator
+      push(const_reference);
+
+      void
+      modify(point_iterator, const_reference);
+
+      inline const_reference
+      top() const;
+
+      void
+      pop();
+
+      void
+      erase(point_iterator);
+
+      inline void
+      clear();
+
+      template<typename Pred>
+      size_type
+      erase_if(Pred);
+
+      template<typename Pred>
+      void
+      split(Pred, PB_DS_CLASS_C_DEC&);
+
+      void
+      join(PB_DS_CLASS_C_DEC&);
+
+    protected:
+
+      binomial_heap_base();
+
+      binomial_heap_base(const Cmp_Fn&);
+
+      binomial_heap_base(const PB_DS_CLASS_C_DEC&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      ~binomial_heap_base();
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+      inline void
+      find_max();
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(bool, const char*, int) const;
+
+      void
+      assert_max(const char*, int) const;
+#endif
+
+    private:
+
+      inline node_pointer
+      fix(node_pointer) const;
+
+      inline void
+      insert_node(node_pointer);
+
+      inline void
+      remove_parentless_node(node_pointer);
+
+      inline node_pointer
+      join(node_pointer, node_pointer) const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_node_consistent(node_const_pointer, bool, bool,
+			     const char*, int) const;
+#endif
+
+    protected:
+      node_pointer 	m_p_max;
+    };
+
+#define PB_DS_ASSERT_VALID_COND(X, _StrictlyBinomial)			\
+  _GLIBCXX_DEBUG_ONLY(X.assert_valid(_StrictlyBinomial,__FILE__, __LINE__);)
+
+#define PB_DS_ASSERT_BASE_NODE_CONSISTENT(_Node, _Bool)			\
+  _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(_Node, _Bool,	\
+							__FILE__, __LINE__);)
+
+#include <ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp>
+
+#undef PB_DS_ASSERT_BASE_NODE_CONSISTENT
+#undef PB_DS_ASSERT_VALID_COND
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_B_HEAP_BASE
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..144b1f7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,85 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_base_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for a base of binomial heaps.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    push(*(first_it++));
+  PB_DS_ASSERT_VALID_COND((*this),false)
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binomial_heap_base() : m_p_max(0)
+{
+  PB_DS_ASSERT_VALID_COND((*this),false)
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binomial_heap_base(const Cmp_Fn& r_cmp_fn)
+: base_type(r_cmp_fn), m_p_max(0)
+{ PB_DS_ASSERT_VALID_COND((*this),false) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+binomial_heap_base(const PB_DS_CLASS_C_DEC& other)
+: base_type(other), m_p_max(0)
+{ PB_DS_ASSERT_VALID_COND((*this),false) }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID_COND((*this),false)
+  base_type::swap(other);
+  std::swap(m_p_max, other.m_p_max);
+  PB_DS_ASSERT_VALID_COND((*this),false)
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~binomial_heap_base()
+{ }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp
new file mode 100644
index 0000000..6944b2f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_base_/debug_fn_imps.hpp
+ * Contains an implementation class for a base of binomial heaps.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(bool strictly_binomial, const char* __file, int __line) const
+{
+  base_type::assert_valid(__file, __line);
+  assert_node_consistent(base_type::m_p_root, strictly_binomial, true,
+			 __file, __line);
+  assert_max(__file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_max(const char* __file, int __line) const
+{
+  if (m_p_max == 0)
+    return;
+  PB_DS_DEBUG_VERIFY(base_type::parent(m_p_max) == 0);
+  for (const_iterator it = base_type::begin(); it != base_type::end(); ++it)
+    PB_DS_DEBUG_VERIFY(!Cmp_Fn::operator()(m_p_max->m_value,
+					   it.m_p_nd->m_value));
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_node_consistent(node_const_pointer p_nd, bool strictly_binomial,
+		       bool increasing, const char* __file, int __line) const
+{
+  PB_DS_DEBUG_VERIFY(increasing || strictly_binomial);
+  base_type::assert_node_consistent(p_nd, false, __file, __line);
+  if (p_nd == 0)
+    return;
+  PB_DS_DEBUG_VERIFY(p_nd->m_metadata == base_type::degree(p_nd));
+  PB_DS_DEBUG_VERIFY(base_type::size_under_node(p_nd) ==
+		   static_cast<size_type>(1 << p_nd->m_metadata));
+  assert_node_consistent(p_nd->m_p_next_sibling, strictly_binomial, increasing,
+			 __file, __line);
+  assert_node_consistent(p_nd->m_p_l_child, true, false, __file, __line);
+  if (p_nd->m_p_next_sibling != 0)
+    {
+      if (increasing)
+	{
+	  if (strictly_binomial)
+	    PB_DS_DEBUG_VERIFY(p_nd->m_metadata
+				  < p_nd->m_p_next_sibling->m_metadata);
+	  else
+	    PB_DS_DEBUG_VERIFY(p_nd->m_metadata
+				  <= p_nd->m_p_next_sibling->m_metadata);
+	}
+      else
+	PB_DS_DEBUG_VERIFY(p_nd->m_metadata
+			      > p_nd->m_p_next_sibling->m_metadata);
+    }
+}
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp
new file mode 100644
index 0000000..f922823
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp
@@ -0,0 +1,161 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_base_/erase_fn_imps.hpp
+ * Contains an implementation class for a base of binomial heaps.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+pop()
+{
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+
+  if (m_p_max == 0)
+    find_max();
+
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
+  node_pointer p_nd = m_p_max;
+  remove_parentless_node(m_p_max);
+  base_type::actual_erase_node(p_nd);
+  m_p_max = 0;
+  PB_DS_ASSERT_VALID_COND((*this),true)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+remove_parentless_node(node_pointer p_nd)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(base_type::parent(p_nd) == 0);
+
+  node_pointer p_cur_root = p_nd == base_type::m_p_root?
+    p_nd->m_p_next_sibling : base_type::m_p_root;
+
+  if (p_cur_root != 0)
+    p_cur_root->m_p_prev_or_parent = 0;
+
+  if (p_nd->m_p_prev_or_parent != 0)
+    p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd->m_p_next_sibling;
+
+  if (p_nd->m_p_next_sibling != 0)
+    p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+
+  node_pointer p_child = p_nd->m_p_l_child;
+  if (p_child != 0)
+    {
+      p_child->m_p_prev_or_parent = 0;
+      while (p_child->m_p_next_sibling != 0)
+	p_child = p_child->m_p_next_sibling;
+    }
+
+  m_p_max = 0;
+  base_type::m_p_root = join(p_cur_root, p_child);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  base_type::clear();
+  m_p_max = 0;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase(point_iterator it)
+{
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+
+  base_type::bubble_to_top(it.m_p_nd);
+  remove_parentless_node(it.m_p_nd);
+  base_type::actual_erase_node(it.m_p_nd);
+  m_p_max = 0;
+  PB_DS_ASSERT_VALID_COND((*this),true)
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID_COND((*this),true)
+
+  if (base_type::empty())
+    {
+      PB_DS_ASSERT_VALID_COND((*this),true)
+      return 0;
+    }
+
+  base_type::to_linked_list();
+  node_pointer p_out = base_type::prune(pred);
+  size_type ersd = 0;
+  while (p_out != 0)
+    {
+      ++ersd;
+      node_pointer p_next = p_out->m_p_next_sibling;
+      base_type::actual_erase_node(p_out);
+      p_out = p_next;
+    }
+
+  node_pointer p_cur = base_type::m_p_root;
+  base_type::m_p_root = 0;
+  while (p_cur != 0)
+    {
+      node_pointer p_next = p_cur->m_p_next_sibling;
+      p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = 0;
+      p_cur->m_metadata = 0;
+      p_cur->m_p_next_sibling = base_type::m_p_root;
+
+      if (base_type::m_p_root != 0)
+	base_type::m_p_root->m_p_prev_or_parent = p_cur;
+
+      base_type::m_p_root = p_cur;
+      base_type::m_p_root = fix(base_type::m_p_root);
+      p_cur = p_next;
+    }
+
+  m_p_max = 0;
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  return ersd;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp
new file mode 100644
index 0000000..ba8f0e2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp
@@ -0,0 +1,70 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_base_/find_fn_imps.hpp
+ * Contains an implementation class for a base of binomial heaps.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reference
+PB_DS_CLASS_C_DEC::
+top() const
+{
+  PB_DS_ASSERT_VALID_COND((*this),false)
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+
+  if (m_p_max == 0)
+    const_cast<PB_DS_CLASS_C_DEC* >(this)->find_max();
+
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
+  return m_p_max->m_value;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+find_max()
+{
+  node_pointer p_cur = base_type::m_p_root;
+  m_p_max = p_cur;
+  while (p_cur != 0)
+    {
+      if (Cmp_Fn::operator()(m_p_max->m_value, p_cur->m_value))
+	m_p_max = p_cur;
+      p_cur = p_cur->m_p_next_sibling;
+    }
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp
new file mode 100644
index 0000000..7f7df13
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp
@@ -0,0 +1,178 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_base_/insert_fn_imps.hpp
+ * Contains an implementation class for a base of binomial heaps.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+push(const_reference r_val)
+{
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  node_pointer p_nd = base_type::get_new_node_for_insert(r_val);
+  insert_node(p_nd);
+  m_p_max = 0;
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  return point_iterator(p_nd);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+insert_node(node_pointer p_nd)
+{
+  if (base_type::m_p_root == 0)
+    {
+      p_nd->m_p_next_sibling = 0;
+      p_nd->m_p_prev_or_parent = 0;
+      p_nd->m_p_l_child = 0;
+      p_nd->m_metadata = 0;
+      base_type::m_p_root = p_nd;
+      return;
+    }
+
+  if (base_type::m_p_root->m_metadata > 0)
+    {
+      p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = 0;
+      p_nd->m_p_next_sibling = base_type::m_p_root;
+      base_type::m_p_root->m_p_prev_or_parent = p_nd;
+      base_type::m_p_root = p_nd;
+      p_nd->m_metadata = 0;
+      return;
+    }
+
+  if (Cmp_Fn::operator()(base_type::m_p_root->m_value, p_nd->m_value))
+    {
+      p_nd->m_p_next_sibling = base_type::m_p_root->m_p_next_sibling;
+      p_nd->m_p_prev_or_parent = 0;
+      p_nd->m_metadata = 1;
+      p_nd->m_p_l_child = base_type::m_p_root;
+      base_type::m_p_root->m_p_prev_or_parent = p_nd;
+      base_type::m_p_root->m_p_next_sibling = 0;
+      base_type::m_p_root = p_nd;
+    }
+  else
+    {
+      p_nd->m_p_next_sibling = 0;
+      p_nd->m_p_l_child = 0;
+      p_nd->m_p_prev_or_parent = base_type::m_p_root;
+      p_nd->m_metadata = 0;
+      _GLIBCXX_DEBUG_ASSERT(base_type::m_p_root->m_p_l_child == 0);
+      base_type::m_p_root->m_p_l_child = p_nd;
+      base_type::m_p_root->m_metadata = 1;
+    }
+
+  base_type::m_p_root = fix(base_type::m_p_root);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+fix(node_pointer p_nd) const
+{
+  while (p_nd->m_p_next_sibling != 0 &&
+	 p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata)
+    {
+      node_pointer p_next = p_nd->m_p_next_sibling;
+      if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value))
+	{
+	  p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+
+	  if (p_nd->m_p_prev_or_parent != 0)
+	    p_nd->m_p_prev_or_parent->m_p_next_sibling = p_next;
+
+	  base_type::make_child_of(p_nd, p_next);
+	  ++p_next->m_metadata;
+	  p_nd = p_next;
+	}
+      else
+	{
+	  p_nd->m_p_next_sibling = p_next->m_p_next_sibling;
+
+	  if (p_nd->m_p_next_sibling != 0)
+	    p_next->m_p_next_sibling = 0;
+
+	  base_type::make_child_of(p_next, p_nd);
+	  ++p_nd->m_metadata;
+	}
+    }
+
+  if (p_nd->m_p_next_sibling != 0)
+    p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd;
+
+  return p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+modify(point_iterator it, const_reference r_new_val)
+{
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  node_pointer p_nd = it.m_p_nd;
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_nd, false)
+
+  const bool bubble_up = Cmp_Fn::operator()(p_nd->m_value, r_new_val);
+  p_nd->m_value = r_new_val;
+
+  if (bubble_up)
+    {
+      node_pointer p_parent = base_type::parent(p_nd);
+      while (p_parent != 0 &&
+	     Cmp_Fn::operator()(p_parent->m_value, p_nd->m_value))
+	{
+	  base_type::swap_with_parent(p_nd, p_parent);
+	  p_parent = base_type::parent(p_nd);
+	}
+
+      if (p_nd->m_p_prev_or_parent == 0)
+	base_type::m_p_root = p_nd;
+
+      m_p_max = 0;
+      PB_DS_ASSERT_VALID_COND((*this),true)
+      return;
+    }
+
+  base_type::bubble_to_top(p_nd);
+  remove_parentless_node(p_nd);
+  insert_node(p_nd);
+  m_p_max = 0;
+  PB_DS_ASSERT_VALID_COND((*this),true)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..664e8c1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp
@@ -0,0 +1,197 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file binomial_heap_base_/split_join_fn_imps.hpp
+ * Contains an implementation class for a base of binomial heaps.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+void
+PB_DS_CLASS_C_DEC::
+split(Pred pred, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  PB_DS_ASSERT_VALID_COND(other,true)
+
+  other.clear();
+  if (base_type::empty())
+    {
+      PB_DS_ASSERT_VALID_COND((*this),true)
+      PB_DS_ASSERT_VALID_COND(other,true)
+      return;
+    }
+
+  base_type::to_linked_list();
+  node_pointer p_out = base_type::prune(pred);
+  while (p_out != 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0);
+      --base_type::m_size;
+      ++other.m_size;
+
+      node_pointer p_next = p_out->m_p_next_sibling;
+      p_out->m_p_l_child = p_out->m_p_prev_or_parent = 0;
+      p_out->m_metadata = 0;
+
+      p_out->m_p_next_sibling = other.m_p_root;
+      if (other.m_p_root != 0)
+	other.m_p_root->m_p_prev_or_parent = p_out;
+
+      other.m_p_root = p_out;
+      other.m_p_root = other.fix(other.m_p_root);
+      p_out = p_next;
+    }
+
+  PB_DS_ASSERT_VALID_COND(other,true)
+  node_pointer p_cur = base_type::m_p_root;
+  base_type::m_p_root = 0;
+
+  while (p_cur != 0)
+    {
+      node_pointer p_next = p_cur->m_p_next_sibling;
+      p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = 0;
+      p_cur->m_metadata = 0;
+      p_cur->m_p_next_sibling = base_type::m_p_root;
+
+      if (base_type::m_p_root != 0)
+	base_type::m_p_root->m_p_prev_or_parent = p_cur;
+
+      base_type::m_p_root = p_cur;
+      base_type::m_p_root = fix(base_type::m_p_root);
+      p_cur = p_next;
+    }
+
+  m_p_max = 0;
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  PB_DS_ASSERT_VALID_COND(other,true)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  PB_DS_ASSERT_VALID_COND(other,true)
+
+  node_pointer p_other = other.m_p_root;
+  if (p_other != 0)
+    do
+      {
+	node_pointer p_next = p_other->m_p_next_sibling;
+	std::swap(p_other->m_p_next_sibling, p_other->m_p_prev_or_parent);
+	p_other = p_next;
+      }
+    while (p_other != 0);
+
+  base_type::m_p_root = join(base_type::m_p_root, other.m_p_root);
+  base_type::m_size += other.m_size;
+  m_p_max = 0;
+
+  other.m_p_root = 0;
+  other.m_size = 0;
+  other.m_p_max = 0;
+
+  PB_DS_ASSERT_VALID_COND((*this),true)
+  PB_DS_ASSERT_VALID_COND(other,true)
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+join(node_pointer p_lhs, node_pointer p_rhs) const
+{
+  node_pointer p_ret = 0;
+  node_pointer p_cur = 0;
+
+  while (p_lhs != 0 || p_rhs != 0)
+    {
+      if (p_rhs == 0)
+	{
+	  if (p_cur == 0)
+	    p_ret = p_cur = p_lhs;
+	  else
+	    {
+	      p_cur->m_p_next_sibling = p_lhs;
+	      p_lhs->m_p_prev_or_parent = p_cur;
+	    }
+	  p_cur = p_lhs = 0;
+	}
+      else if (p_lhs == 0 || p_rhs->m_metadata < p_lhs->m_metadata)
+	{
+	  if (p_cur == 0)
+	    {
+	      p_ret = p_cur = p_rhs;
+	      p_rhs = p_rhs->m_p_prev_or_parent;
+	    }
+	  else
+	    {
+	      p_cur->m_p_next_sibling = p_rhs;
+	      p_rhs = p_rhs->m_p_prev_or_parent;
+	      p_cur->m_p_next_sibling->m_p_prev_or_parent = p_cur;
+	      p_cur = p_cur->m_p_next_sibling;
+	    }
+	}
+      else if (p_lhs->m_metadata < p_rhs->m_metadata)
+	{
+	  if (p_cur == 0)
+	    p_ret = p_cur = p_lhs;
+	  else
+	    {
+	      p_cur->m_p_next_sibling = p_lhs;
+	      p_lhs->m_p_prev_or_parent = p_cur;
+	      p_cur = p_cur->m_p_next_sibling;
+	    }
+	  p_lhs = p_cur->m_p_next_sibling;
+	}
+      else
+	{
+	  node_pointer p_next_rhs = p_rhs->m_p_prev_or_parent;
+	  p_rhs->m_p_next_sibling = p_lhs;
+	  p_lhs = fix(p_rhs);
+	  p_rhs = p_next_rhs;
+	}
+    }
+
+  if (p_cur != 0)
+    p_cur->m_p_next_sibling = 0;
+
+  if (p_ret != 0)
+    p_ret->m_p_prev_or_parent = 0;
+
+  return p_ret;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/branch_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/branch_policy.hpp
new file mode 100644
index 0000000..b198f94
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/branch_policy.hpp
@@ -0,0 +1,119 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file branch_policy/branch_policy.hpp
+ * Contains a base class for branch policies.
+ */
+
+#ifndef PB_DS_BRANCH_POLICY_BASE_HPP
+#define PB_DS_BRANCH_POLICY_BASE_HPP
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Primary template, base class for branch structure policies.
+    template<typename Node_CItr, typename Node_Itr, typename _Alloc>
+      struct branch_policy
+      {
+      protected:
+	typedef typename Node_Itr::value_type 		it_type;
+	typedef typename std::iterator_traits<it_type>::value_type value_type;
+	typedef typename value_type::first_type 	key_type;
+
+	typedef typename remove_const<value_type>::type	rcvalue_type;
+	typedef typename remove_const<key_type>::type	rckey_type;
+
+	typedef typename _Alloc::template rebind<rcvalue_type>::other rebind_v;
+	typedef typename _Alloc::template rebind<rckey_type>::other   rebind_k;
+
+	typedef	typename rebind_v::reference 		reference;
+	typedef	typename rebind_v::const_reference 	const_reference;
+	typedef	typename rebind_v::const_pointer	const_pointer;
+
+	typedef	typename rebind_k::const_reference 	key_const_reference;
+
+	static inline key_const_reference
+	extract_key(const_reference r_val)
+	{ return r_val.first; }
+
+	virtual it_type
+	end() = 0;
+
+	it_type
+	end_iterator() const
+	{ return const_cast<branch_policy*>(this)->end(); }
+
+	virtual
+	~branch_policy() { }
+      };
+
+    /// Specialization for const iterators.
+    template<typename Node_CItr, typename _Alloc>
+      struct branch_policy<Node_CItr, Node_CItr, _Alloc>
+      {
+      protected:
+	typedef typename Node_CItr::value_type 		   it_type;
+       	typedef typename std::iterator_traits<it_type>::value_type value_type;
+	typedef typename remove_const<value_type>::type		   rcvalue_type;
+	typedef typename _Alloc::template rebind<rcvalue_type>::other rebind_v;
+	typedef	typename rebind_v::reference 		reference;
+	typedef	typename rebind_v::const_reference 	const_reference;
+	typedef	typename rebind_v::const_pointer	const_pointer;
+
+	typedef value_type 				key_type;
+	typedef	typename rebind_v::const_reference 	key_const_reference;
+
+	static inline key_const_reference
+	extract_key(const_reference r_val)
+	{ return r_val; }
+
+	virtual it_type
+	end() const = 0;
+
+	it_type
+	end_iterator() const
+	{ return end(); }
+
+	virtual
+	~branch_policy() { }
+      };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_BRANCH_POLICY_BASE_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/null_node_metadata.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/null_node_metadata.hpp
new file mode 100644
index 0000000..e92585d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/null_node_metadata.hpp
@@ -0,0 +1,66 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file branch_policy/null_node_metadata.hpp
+ * Contains an implementation class for tree-like classes.
+ */
+
+#ifndef PB_DS_0_NODE_METADATA_HPP
+#define PB_DS_0_NODE_METADATA_HPP
+
+#include <ext/pb_ds/detail/types_traits.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Constant node iterator.
+    template<typename Key, typename Data, typename _Alloc>
+      struct dumnode_const_iterator
+      {
+      private:
+	typedef types_traits<Key, Data, _Alloc, false>	__traits_type;
+	typedef typename __traits_type::pointer        	const_iterator;
+	
+      public:
+	typedef const_iterator 				value_type;
+	typedef const_iterator 				const_reference;
+	typedef const_reference 	       		reference;
+      };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/traits.hpp
new file mode 100644
index 0000000..be1c49a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/branch_policy/traits.hpp
@@ -0,0 +1,95 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file branch_policy/traits.hpp
+ * Contains an implementation class for tree-like classes.
+ */
+
+#ifndef PB_DS_NODE_AND_IT_TRAITS_HPP
+#define PB_DS_NODE_AND_IT_TRAITS_HPP
+
+#include <ext/pb_ds/detail/types_traits.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/traits.hpp>
+#include <ext/pb_ds/detail/tree_policy/node_metadata_selector.hpp>
+#include <ext/pb_ds/detail/trie_policy/node_metadata_selector.hpp>
+
+#define PB_DS_DEBUG_VERIFY(_Cond)					\
+  _GLIBCXX_DEBUG_VERIFY_AT(_Cond,					\
+			   _M_message(#_Cond" assertion from %1;:%2;")	\
+			   ._M_string(__FILE__)._M_integer(__LINE__)	\
+			   ,__file,__line)
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Tree traits class, primary template.
+    template<typename Key,
+	     typename Data,
+	     typename Cmp_Fn,
+	     template<typename Node_CItr,
+		      typename Node_Itr,
+		      typename Cmp_Fn_,
+		      typename _Alloc>
+	     class Node_Update,
+	     typename Tag,
+	     typename _Alloc>
+    struct tree_traits;
+
+    /// Trie traits class, primary template.
+    template<typename Key,
+	     typename Data,
+	     typename _ATraits,
+	     template<typename Node_CItr,
+		      typename Node_Itr,
+		      typename _ATraits_,
+		      typename _Alloc>
+	     class Node_Update,
+	     typename Tag,
+	     typename _Alloc>
+    struct trie_traits;
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#include <ext/pb_ds/detail/rb_tree_map_/traits.hpp>
+#include <ext/pb_ds/detail/splay_tree_/traits.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/traits.hpp>
+#include <ext/pb_ds/detail/pat_trie_/traits.hpp>
+
+#undef PB_DS_DEBUG_VERIFY
+
+#endif // #ifndef PB_DS_NODE_AND_IT_TRAITS_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
new file mode 100644
index 0000000..d2cda4b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
@@ -0,0 +1,679 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/cc_ht_map_.hpp
+ * Contains an implementation class for cc_ht_map_.
+ */
+
+#include <utility>
+#include <iterator>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/hash_fn/ranged_hash_fn.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp>
+#ifdef _GLIBCXX_DEBUG
+#include <ext/pb_ds/detail/debug_map_base.hpp>
+#endif
+#ifdef PB_DS_HT_MAP_TRACE_
+#include <iostream>
+#endif
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+#define PB_DS_CC_HASH_NAME cc_ht_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+#define PB_DS_CC_HASH_NAME cc_ht_set
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Hash_Fn, \
+	     typename Eq_Fn, typename _Alloc, bool Store_Hash, \
+	     typename Comb_Hash_Fn, typename Resize_Policy>
+
+#define PB_DS_CLASS_C_DEC \
+    PB_DS_CC_HASH_NAME<Key, Mapped, Hash_Fn, Eq_Fn, _Alloc,	\
+		     Store_Hash, Comb_Hash_Fn, Resize_Policy>
+
+#define PB_DS_HASH_EQ_FN_C_DEC \
+    hash_eq_fn<Key, Eq_Fn, _Alloc, Store_Hash>
+
+#define PB_DS_RANGED_HASH_FN_C_DEC \
+    ranged_hash_fn<Key,	Hash_Fn, _Alloc, Comb_Hash_Fn, Store_Hash>
+
+#define PB_DS_CC_HASH_TRAITS_BASE \
+    types_traits<Key, Mapped, _Alloc, Store_Hash>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key,	Eq_Fn, \
+		  typename _Alloc::template rebind<Key>::other::const_reference>
+#endif
+
+
+    /**
+     *  A collision-chaining hash-based container.
+     *
+     *
+     *  @ingroup hash-detail
+     *
+     *  @tparam Key 	    	Key type.
+     *
+     *  @tparam Mapped 	    	Map type.
+     *
+     *  @tparam Hash_Fn	      	Hashing functor.
+     *                          Default is __gnu_cxx::hash.
+     *
+     *  @tparam Eq_Fn	      	Equal functor.
+     *                          Default std::equal_to<Key>
+     *
+     *  @tparam _Alloc 	    	Allocator type.
+     *
+     *  @tparam Store_Hash    	If key type stores extra metadata.
+     *                          Defaults to false.
+     *
+     *  @tparam Comb_Hash_Fn	Combining hash functor.
+     *                          If Hash_Fn is not null_type, then this
+     *                          is the ranged-hash functor; otherwise,
+     *                          this is the range-hashing functor.
+     *                    XXX(See Design::Hash-Based Containers::Hash Policies.)
+     *                          Default direct_mask_range_hashing.
+     *
+     *  @tparam Resize_Policy 	Resizes hash.
+     *                          Defaults to hash_standard_resize_policy,
+     *                          using hash_exponential_size_policy and
+     *                          hash_load_check_resize_trigger.
+     *
+     *
+     *  Bases are: detail::hash_eq_fn, Resize_Policy, detail::ranged_hash_fn,
+     *             detail::types_traits. (Optional: detail::debug_map_base.)
+     */
+    template<typename Key,
+	     typename Mapped,
+	     typename Hash_Fn,
+	     typename Eq_Fn,
+	     typename _Alloc,
+	     bool Store_Hash,
+	     typename Comb_Hash_Fn,
+	     typename Resize_Policy >
+    class PB_DS_CC_HASH_NAME:
+#ifdef _GLIBCXX_DEBUG
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
+#endif
+      public PB_DS_HASH_EQ_FN_C_DEC,
+      public Resize_Policy,
+      public PB_DS_RANGED_HASH_FN_C_DEC,
+      public PB_DS_CC_HASH_TRAITS_BASE
+    {
+    private:
+      typedef PB_DS_CC_HASH_TRAITS_BASE	       	traits_base;
+      typedef typename traits_base::comp_hash 	comp_hash;
+      typedef typename traits_base::value_type 	value_type_;
+      typedef typename traits_base::pointer 	pointer_;
+      typedef typename traits_base::const_pointer const_pointer_;
+      typedef typename traits_base::reference 	reference_;
+      typedef typename traits_base::const_reference const_reference_;
+
+      struct entry : public traits_base::stored_data_type
+      {
+	typename _Alloc::template rebind<entry>::other::pointer m_p_next;
+      };
+
+      typedef cond_dealtor<entry, _Alloc> 	cond_dealtor_t;
+
+      typedef typename _Alloc::template rebind<entry>::other entry_allocator;
+      typedef typename entry_allocator::pointer entry_pointer;
+      typedef typename entry_allocator::const_pointer const_entry_pointer;
+      typedef typename entry_allocator::reference entry_reference;
+      typedef typename entry_allocator::const_reference const_entry_reference;
+
+      typedef typename _Alloc::template rebind<entry_pointer>::other entry_pointer_allocator;
+      typedef typename entry_pointer_allocator::pointer entry_pointer_array;
+
+      typedef PB_DS_RANGED_HASH_FN_C_DEC ranged_hash_fn_base;
+      typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base;
+      typedef Resize_Policy resize_base;
+
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC 	debug_base;
+#endif
+
+#define PB_DS_GEN_POS std::pair<entry_pointer, typename _Alloc::size_type>
+
+#include <ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/point_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/const_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/iterator.hpp>
+
+#undef PB_DS_GEN_POS
+
+    public:
+      typedef _Alloc 				allocator_type;
+      typedef typename _Alloc::size_type 	size_type;
+      typedef typename _Alloc::difference_type 	difference_type;
+      typedef Hash_Fn 				hash_fn;
+      typedef Eq_Fn 				eq_fn;
+      typedef Comb_Hash_Fn 			comb_hash_fn;
+      typedef Resize_Policy 			resize_policy;
+
+      /// Value stores hash, true or false.
+      enum
+	{
+	  store_hash = Store_Hash
+	};
+
+      typedef typename traits_base::key_type key_type;
+      typedef typename traits_base::key_pointer key_pointer;
+      typedef typename traits_base::key_const_pointer key_const_pointer;
+      typedef typename traits_base::key_reference key_reference;
+      typedef typename traits_base::key_const_reference key_const_reference;
+      typedef typename traits_base::mapped_type mapped_type;
+      typedef typename traits_base::mapped_pointer mapped_pointer;
+      typedef typename traits_base::mapped_const_pointer mapped_const_pointer;
+      typedef typename traits_base::mapped_reference mapped_reference;
+      typedef typename traits_base::mapped_const_reference mapped_const_reference;
+      typedef typename traits_base::value_type 	value_type;
+      typedef typename traits_base::pointer 	pointer;
+      typedef typename traits_base::const_pointer const_pointer;
+      typedef typename traits_base::reference 	reference;
+      typedef typename traits_base::const_reference const_reference;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef point_iterator_ 			point_iterator;
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+      typedef point_const_iterator_ 		point_iterator;
+#endif
+
+      typedef point_const_iterator_ 		point_const_iterator;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef iterator_ 			iterator;
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+      typedef const_iterator_ 			iterator;
+#endif
+
+      typedef const_iterator_ 			const_iterator;
+
+      PB_DS_CC_HASH_NAME();
+
+      PB_DS_CC_HASH_NAME(const Hash_Fn&);
+
+      PB_DS_CC_HASH_NAME(const Hash_Fn&, const Eq_Fn&);
+
+      PB_DS_CC_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&);
+
+      PB_DS_CC_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&,
+		       const Resize_Policy&);
+
+      PB_DS_CC_HASH_NAME(const PB_DS_CLASS_C_DEC&);
+
+      virtual
+      ~PB_DS_CC_HASH_NAME();
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+      void
+      initialize();
+
+      inline size_type
+      size() const;
+
+      inline size_type
+      max_size() const;
+
+      /// True if size() == 0.
+      inline bool
+      empty() const;
+
+      /// Return current hash_fn.
+      Hash_Fn&
+      get_hash_fn();
+
+      /// Return current const hash_fn.
+      const Hash_Fn&
+      get_hash_fn() const;
+
+      /// Return current eq_fn.
+      Eq_Fn&
+      get_eq_fn();
+
+      /// Return current const eq_fn.
+      const Eq_Fn&
+      get_eq_fn() const;
+
+      /// Return current comb_hash_fn.
+      Comb_Hash_Fn&
+      get_comb_hash_fn();
+
+      /// Return current const comb_hash_fn.
+      const Comb_Hash_Fn&
+      get_comb_hash_fn() const;
+
+      /// Return current resize_policy.
+      Resize_Policy&
+      get_resize_policy();
+
+      /// Return current const resize_policy.
+      const Resize_Policy&
+      get_resize_policy() const;
+
+      inline std::pair<point_iterator, bool>
+      insert(const_reference r_val)
+      { return insert_imp(r_val, traits_base::m_store_extra_indicator); }
+
+      inline mapped_reference
+      operator[](key_const_reference r_key)
+      {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+	return (subscript_imp(r_key, traits_base::m_store_extra_indicator));
+#else
+	insert(r_key);
+	return traits_base::s_null_type;
+#endif
+      }
+
+      inline point_iterator
+      find(key_const_reference);
+
+      inline point_const_iterator
+      find(key_const_reference) const;
+
+      inline point_iterator
+      find_end();
+
+      inline point_const_iterator
+      find_end() const;
+
+      inline bool
+      erase(key_const_reference);
+
+      template<typename Pred>
+      inline size_type
+      erase_if(Pred);
+
+      void
+      clear();
+
+      inline iterator
+      begin();
+
+      inline const_iterator
+      begin() const;
+
+      inline iterator
+      end();
+
+      inline const_iterator
+      end() const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+
+#ifdef PB_DS_HT_MAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    private:
+      void
+      deallocate_all();
+
+      inline bool
+      do_resize_if_needed();
+
+      inline void
+      do_resize_if_needed_no_throw();
+
+      void
+      resize_imp(size_type);
+
+      void
+      do_resize(size_type);
+
+      void
+      resize_imp_no_exceptions(size_type, entry_pointer_array, size_type);
+
+      inline entry_pointer
+      resize_imp_no_exceptions_reassign_pointer(entry_pointer,
+						entry_pointer_array,
+						false_type);
+
+      inline entry_pointer
+      resize_imp_no_exceptions_reassign_pointer(entry_pointer,
+						entry_pointer_array,
+						true_type);
+
+      void
+      deallocate_links_in_list(entry_pointer);
+
+      inline entry_pointer
+      get_entry(const_reference, false_type);
+
+      inline entry_pointer
+      get_entry(const_reference, true_type);
+
+      inline void
+      rels_entry(entry_pointer);
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      inline mapped_reference
+      subscript_imp(key_const_reference r_key, false_type)
+      {
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	const size_type pos = ranged_hash_fn_base::operator()(r_key);
+	entry_pointer p_e = m_entries[pos];
+	resize_base::notify_insert_search_start();
+
+	while (p_e != 0
+	       && !hash_eq_fn_base::operator()(p_e->m_value.first, r_key))
+	  {
+	    resize_base::notify_insert_search_collision();
+	    p_e = p_e->m_p_next;
+	  }
+
+	resize_base::notify_insert_search_end();
+	if (p_e != 0)
+	  {
+	    PB_DS_CHECK_KEY_EXISTS(r_key)
+	    return (p_e->m_value.second);
+	  }
+
+	PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	return insert_new_imp(value_type(r_key, mapped_type()), pos)->second;
+      }
+
+      inline mapped_reference
+      subscript_imp(key_const_reference r_key, true_type)
+      {
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key);
+	entry_pointer p_e = m_entries[pos_hash_pair.first];
+	resize_base::notify_insert_search_start();
+	while (p_e != 0 &&
+	       !hash_eq_fn_base::operator()(p_e->m_value.first, p_e->m_hash,
+					    r_key, pos_hash_pair.second))
+	  {
+	    resize_base::notify_insert_search_collision();
+	    p_e = p_e->m_p_next;
+	  }
+
+	resize_base::notify_insert_search_end();
+	if (p_e != 0)
+	  {
+	    PB_DS_CHECK_KEY_EXISTS(r_key)
+	    return p_e->m_value.second;
+	  }
+
+	PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	return insert_new_imp(value_type(r_key, mapped_type()),
+			      pos_hash_pair)->second;
+      }
+#endif
+
+      inline std::pair<point_iterator, bool>
+      insert_imp(const_reference, false_type);
+
+      inline std::pair<point_iterator, bool>
+      insert_imp(const_reference, true_type);
+
+      inline pointer
+      insert_new_imp(const_reference r_val, size_type pos)
+      {
+	if (do_resize_if_needed())
+	  pos = ranged_hash_fn_base::operator()(PB_DS_V2F(r_val));
+
+	// Following lines might throw an exception.
+	entry_pointer p_e = get_entry(r_val,
+				      traits_base::m_no_throw_copies_indicator);
+
+	// At this point no exceptions can be thrown.
+	p_e->m_p_next = m_entries[pos];
+	m_entries[pos] = p_e;
+	resize_base::notify_inserted(++m_num_used_e);
+
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	return &p_e->m_value;
+      }
+
+      inline pointer
+      insert_new_imp(const_reference r_val, comp_hash& r_pos_hash_pair)
+      {
+	// Following lines might throw an exception.
+	if (do_resize_if_needed())
+	  r_pos_hash_pair = ranged_hash_fn_base::operator()(PB_DS_V2F(r_val));
+
+	entry_pointer p_e = get_entry(r_val,
+				      traits_base::m_no_throw_copies_indicator);
+
+	// At this point no exceptions can be thrown.
+	p_e->m_hash = r_pos_hash_pair.second;
+	p_e->m_p_next = m_entries[r_pos_hash_pair.first];
+	m_entries[r_pos_hash_pair.first] = p_e;
+	resize_base::notify_inserted(++m_num_used_e);
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	return &p_e->m_value;
+      }
+
+      inline pointer
+      find_key_pointer(key_const_reference r_key, false_type)
+      {
+	entry_pointer p_e = m_entries[ranged_hash_fn_base::operator()(r_key)];
+	resize_base::notify_find_search_start();
+	while (p_e != 0 &&
+	       !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
+	  {
+	    resize_base::notify_find_search_collision();
+	    p_e = p_e->m_p_next;
+	  }
+
+	resize_base::notify_find_search_end();
+
+#ifdef _GLIBCXX_DEBUG
+	if (p_e == 0)
+	  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	else
+	  PB_DS_CHECK_KEY_EXISTS(r_key)
+#endif
+	return &p_e->m_value;
+      }
+
+      inline pointer
+      find_key_pointer(key_const_reference r_key, true_type)
+      {
+	comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key);
+	entry_pointer p_e = m_entries[pos_hash_pair.first];
+	resize_base::notify_find_search_start();
+	while (p_e != 0 &&
+	       !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
+					    p_e->m_hash,
+					    r_key, pos_hash_pair.second))
+	  {
+	    resize_base::notify_find_search_collision();
+	    p_e = p_e->m_p_next;
+	  }
+
+	resize_base::notify_find_search_end();
+
+#ifdef _GLIBCXX_DEBUG
+	if (p_e == 0)
+	  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	else
+	  PB_DS_CHECK_KEY_EXISTS(r_key)
+#endif
+	return &p_e->m_value;
+      }
+
+      inline bool
+      erase_in_pos_imp(key_const_reference, size_type);
+
+      inline bool
+      erase_in_pos_imp(key_const_reference, const comp_hash&);
+
+      inline void
+      erase_entry_pointer(entry_pointer&);
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      void
+      inc_it_state(pointer& r_p_value,
+		   std::pair<entry_pointer, size_type>& r_pos) const
+      {
+	inc_it_state((mapped_const_pointer& )r_p_value, r_pos);
+      }
+#endif
+
+      void
+      inc_it_state(const_pointer& r_p_value,
+		   std::pair<entry_pointer, size_type>& r_pos) const
+      {
+	_GLIBCXX_DEBUG_ASSERT(r_p_value != 0);
+	r_pos.first = r_pos.first->m_p_next;
+	if (r_pos.first != 0)
+	  {
+	    r_p_value = &r_pos.first->m_value;
+	    return;
+	  }
+
+	for (++r_pos.second; r_pos.second < m_num_e; ++r_pos.second)
+	  if (m_entries[r_pos.second] != 0)
+	    {
+	      r_pos.first = m_entries[r_pos.second];
+	      r_p_value = &r_pos.first->m_value;
+	      return;
+	    }
+	r_p_value = 0;
+      }
+
+      void
+      get_start_it_state(pointer& r_p_value,
+			 std::pair<entry_pointer, size_type>& r_pos) const
+      {
+	for (r_pos.second = 0; r_pos.second < m_num_e; ++r_pos.second)
+	  if (m_entries[r_pos.second] != 0)
+	    {
+	      r_pos.first = m_entries[r_pos.second];
+	      r_p_value = &r_pos.first->m_value;
+	      return;
+	    }
+	r_p_value = 0;
+      }
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_entry_pointer_array_valid(const entry_pointer_array,
+				       const char*, int) const;
+
+      void
+      assert_entry_pointer_valid(const entry_pointer, true_type,
+				 const char*, int) const;
+
+      void
+      assert_entry_pointer_valid(const entry_pointer, false_type,
+				 const char*, int) const;
+#endif
+
+#ifdef PB_DS_HT_MAP_TRACE_
+      void
+      trace_list(const_entry_pointer) const;
+#endif
+
+    private:
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      friend class iterator_;
+#endif
+
+      friend class const_iterator_;
+
+      static entry_allocator 		s_entry_allocator;
+      static entry_pointer_allocator 	s_entry_pointer_allocator;
+      static iterator 			s_end_it;
+      static const_iterator 		s_const_end_it;
+      static point_iterator 		s_find_end_it;
+      static point_const_iterator 	s_const_find_end_it;
+
+      size_type 			m_num_e;
+      size_type 			m_num_used_e;
+      entry_pointer_array 		m_entries;
+
+      enum
+	{
+	  store_hash_ok = !Store_Hash
+			  || !is_same<Hash_Fn, __gnu_pbds::null_type>::value
+	};
+
+      PB_DS_STATIC_ASSERT(sth, store_hash_ok);
+    };
+
+#include <ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/size_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/policy_access_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/iterators_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_HASH_EQ_FN_C_DEC
+#undef PB_DS_RANGED_HASH_FN_C_DEC
+#undef PB_DS_CC_HASH_TRAITS_BASE
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
+#undef PB_DS_CC_HASH_NAME
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp
new file mode 100644
index 0000000..dd2da87
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp
@@ -0,0 +1,83 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/cmp_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s entire container comparison related
+ *    functions.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename Other_HT_Map_Type>
+bool
+PB_DS_CLASS_C_DEC::
+operator==(const Other_HT_Map_Type& other) const
+{ return cmp_with_other(other); }
+
+PB_DS_CLASS_T_DEC
+template<typename Other_Map_Type>
+bool
+PB_DS_CLASS_C_DEC::
+cmp_with_other(const Other_Map_Type& other) const
+{
+  if (size() != other.size())
+    return false;
+
+  for (typename Other_Map_Type::const_iterator it = other.begin();
+       it != other.end(); ++it)
+    {
+      key_const_reference r_key = key_const_reference(PB_DS_V2F(*it));
+
+      mapped_const_pointer p_mapped_value =
+	const_cast<PB_DS_CLASS_C_DEC& >(*this).
+	find_key_pointer(r_key, traits_base::m_store_extra_indicator);
+
+      if (p_mapped_value == 0)
+	return false;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      if (p_mapped_value->second != it->second)
+	return false;
+#endif
+    }
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Other_HT_Map_Type>
+bool
+PB_DS_CLASS_C_DEC::
+operator!=(const Other_HT_Map_Type& other) const
+{ return !operator==(other); }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cond_key_dtor_entry_dealtor.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cond_key_dtor_entry_dealtor.hpp
new file mode 100644
index 0000000..a38d423
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cond_key_dtor_entry_dealtor.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/cond_key_dtor_entry_dealtor.hpp
+ * Contains a conditional key destructor, used for exception handling.
+ */
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Conditional dey destructor, cc_hash.
+    template<typename HT_Map>
+    class cond_dealtor
+    {
+    public:
+      typedef typename HT_Map::entry 		entry;
+      typedef typename HT_Map::entry_allocator 	entry_allocator;
+      typedef typename HT_Map::key_type 	key_type;
+
+      cond_dealtor(entry_allocator* p_a, entry* p_e)
+      : m_p_a(p_a), m_p_e(p_e), m_key_destruct(false),
+	m_no_action_destructor(false)
+      { }
+
+      inline
+      ~cond_dealtor();
+
+      void
+      set_key_destruct()
+      { m_key_destruct = true; }
+
+      void
+      set_no_action_destructor()
+      { m_no_action_destructor = true; }
+
+    protected:
+      entry_allocator* const 			m_p_a;
+      entry* const 				m_p_e;
+
+      bool 					m_key_destruct;
+      bool 					m_no_action_destructor;
+    };
+
+    template<typename HT_Map>
+    inline
+    cond_dealtor<HT_Map>::
+    ~cond_dealtor()
+    {
+      if (m_no_action_destructor)
+	return;
+      if (m_key_destruct)
+	m_p_e->m_value.first.~key_type();
+      m_p_a->deallocate(m_p_e, 1);
+    }
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
new file mode 100644
index 0000000..3b54c30
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
@@ -0,0 +1,191 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/constructor_destructor_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s constructors, destructor,
+ * and related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::entry_allocator
+PB_DS_CLASS_C_DEC::s_entry_allocator;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::entry_pointer_allocator
+PB_DS_CLASS_C_DEC::s_entry_pointer_allocator;
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    insert(*(first_it++));
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_CC_HASH_NAME() :
+  ranged_hash_fn_base(resize_base::get_nearest_larger_size(1)),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_pointer_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_CC_HASH_NAME(const Hash_Fn& r_hash_fn) :
+  ranged_hash_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_pointer_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_CC_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) :
+  PB_DS_HASH_EQ_FN_C_DEC(r_eq_fn),
+  ranged_hash_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_pointer_allocator.allocate(m_num_e))
+{
+  std::fill(m_entries, m_entries + m_num_e, (entry_pointer)0);
+  Resize_Policy::notify_cleared();
+  ranged_hash_fn_base::notify_resized(m_num_e);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_CC_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, 
+		   const Comb_Hash_Fn& r_comb_hash_fn) :
+  PB_DS_HASH_EQ_FN_C_DEC(r_eq_fn),
+  ranged_hash_fn_base(resize_base::get_nearest_larger_size(1),
+		      r_hash_fn, r_comb_hash_fn),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_pointer_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_CC_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, 
+		   const Comb_Hash_Fn& r_comb_hash_fn, 
+		   const Resize_Policy& r_resize_policy) :
+  PB_DS_HASH_EQ_FN_C_DEC(r_eq_fn),
+  Resize_Policy(r_resize_policy),
+  ranged_hash_fn_base(resize_base::get_nearest_larger_size(1),
+		      r_hash_fn, r_comb_hash_fn),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_pointer_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_CC_HASH_NAME(const PB_DS_CLASS_C_DEC& other) :
+  PB_DS_HASH_EQ_FN_C_DEC(other),
+  resize_base(other), ranged_hash_fn_base(other),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_pointer_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+    __try
+      {
+	copy_from_range(other.begin(), other.end());
+      }
+    __catch(...)
+      {
+	deallocate_all();
+	__throw_exception_again;
+      }
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~PB_DS_CC_HASH_NAME()
+{ deallocate_all(); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  std::swap(m_entries, other.m_entries);
+  std::swap(m_num_e, other.m_num_e);
+  std::swap(m_num_used_e, other.m_num_used_e);
+  ranged_hash_fn_base::swap(other);
+  hash_eq_fn_base::swap(other);
+  resize_base::swap(other);
+
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other));
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+deallocate_all()
+{
+  clear();
+  s_entry_pointer_allocator.deallocate(m_entries, m_num_e);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize()
+{
+  std::fill(m_entries, m_entries + m_num_e, entry_pointer(0));
+  Resize_Policy::notify_resized(m_num_e);
+  Resize_Policy::notify_cleared();
+  ranged_hash_fn_base::notify_resized(m_num_e);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..90f7808
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
@@ -0,0 +1,55 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s constructors, destructor,
+ *    and related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+constructor_insert_new_imp(mapped_const_reference r_val, size_type pos, 
+			   false_type)
+{
+  // Following lines might throw an exception.
+  entry_pointer p = get_entry(r_val, traits_base::s_no_throw_copies_indicator);
+
+  // At this point no exceptions can be thrown.
+  p->m_p_next = m_entries[pos];
+  m_entries[pos] = p;
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(r_key);)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..db36fd1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
@@ -0,0 +1,56 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s constructors, destructor,
+ * and related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+constructor_insert_new_imp(const_reference r_val, size_type pos, true_type)
+{
+  // Following lines might throw an exception.
+  entry_pointer p = get_entry(r_val, traits_base::s_no_throw_copies_indicator);
+
+  // At this point no exceptions can be thrown.
+  p->m_p_next = m_entries[pos];
+  p->m_hash = ranged_hash_fn_base::operator()((key_const_reference)(PB_DS_V2F(p->m_value))).second;
+
+  m_entries[pos] = p;
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(r_key);)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
new file mode 100644
index 0000000..a86face
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
@@ -0,0 +1,76 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/debug_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s debug-mode functions.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  debug_base::check_size(m_num_used_e, __file, __line);
+  assert_entry_pointer_array_valid(m_entries, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_entry_pointer_array_valid(const entry_pointer_array a_p_entries,
+				 const char* __file, int __line) const
+{
+  size_type iterated_num_used_e = 0;
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    {
+      entry_pointer p_e = a_p_entries[pos];
+      while (p_e != 0)
+        {
+	  ++iterated_num_used_e;
+	  assert_entry_pointer_valid(p_e, traits_base::m_store_extra_indicator,
+				     __file, __line);
+	  p_e = p_e->m_p_next;
+        }
+    }
+  PB_DS_DEBUG_VERIFY(iterated_num_used_e == m_num_used_e);
+}
+
+#include <ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp>
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..d1c6905
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp
@@ -0,0 +1,50 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s debug-mode functions.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_entry_pointer_valid(const entry_pointer p, false_type,
+			   const char* __file, int __line) const
+{ debug_base::check_key_exists(PB_DS_V2F(p->m_value), __file, __line); }
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..d686bbb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/debug_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s debug-mode functions.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_entry_pointer_valid(const entry_pointer p_e, true_type,
+			   const char* __file, int __line) const
+{
+  debug_base::check_key_exists(PB_DS_V2F(p_e->m_value), __file, __line);
+  comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(PB_DS_V2F(p_e->m_value));
+  PB_DS_DEBUG_VERIFY(p_e->m_hash == pos_hash_pair.second);
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp
new file mode 100644
index 0000000..be2086d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp
@@ -0,0 +1,91 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/entry_list_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s entry-list related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+deallocate_links_in_list(entry_pointer p_e)
+{
+  while (p_e != 0)
+    {
+      entry_pointer p_dealloc_e = p_e;
+      p_e = p_e->m_p_next;
+      s_entry_allocator.deallocate(p_dealloc_e, 1);
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::entry_pointer
+PB_DS_CLASS_C_DEC::
+get_entry(const_reference r_val, true_type)
+{
+  // Following line might throw an exception.
+  entry_pointer p_e = s_entry_allocator.allocate(1);
+
+  // Following lines* cannot* throw an exception.
+  new (&p_e->m_value) value_type(r_val);
+  return p_e;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::entry_pointer
+PB_DS_CLASS_C_DEC::
+get_entry(const_reference r_val, false_type)
+{
+  // Following line might throw an exception.
+  entry_pointer p_e = s_entry_allocator.allocate(1);
+  cond_dealtor_t cond(p_e);
+
+  // Following lines might throw an exception.
+  new (&p_e->m_value) value_type(r_val);
+  cond.set_no_action();
+  return p_e;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+rels_entry(entry_pointer p_e)
+{
+  // The following lines cannot throw exceptions (unless if key-data dtors do).
+  p_e->m_value.~value_type();
+  s_entry_allocator.deallocate(p_e, 1);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
new file mode 100644
index 0000000..e9d9ded
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/erase_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s erase related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+erase_entry_pointer(entry_pointer& r_p_e)
+{
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(r_p_e->m_value)));
+
+  entry_pointer p_e = r_p_e;
+  r_p_e = r_p_e->m_p_next;
+  rels_entry(p_e);
+  _GLIBCXX_DEBUG_ASSERT(m_num_used_e > 0);
+  resize_base::notify_erased(--m_num_used_e);
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  size_type num_ersd = 0;
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    {
+      while (m_entries[pos] != 0 && pred(m_entries[pos]->m_value))
+        {
+	  ++num_ersd;
+	  entry_pointer p_next_e = m_entries[pos]->m_p_next;
+	  erase_entry_pointer(m_entries[pos]);
+	  m_entries[pos] = p_next_e;
+        }
+
+      entry_pointer p_e = m_entries[pos];
+      while (p_e != 0 && p_e->m_p_next != 0)
+        {
+	  if (pred(p_e->m_p_next->m_value))
+            {
+	      ++num_ersd;
+	      erase_entry_pointer(p_e->m_p_next);
+            }
+	  else
+	    p_e = p_e->m_p_next;
+        }
+    }
+
+  do_resize_if_needed_no_throw();
+  return num_ersd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    while (m_entries[pos] != 0)
+      erase_entry_pointer(m_entries[pos]);
+  do_resize_if_needed_no_throw();
+  resize_base::notify_cleared();
+}
+
+#include <ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp>
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..e8a9749
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s erase related functions,
+ * when the hash value is not stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase(key_const_reference r_key)
+{
+  PB_DS_ASSERT_VALID((*this))
+  return erase_in_pos_imp(r_key, ranged_hash_fn_base::operator()(r_key));
+}
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase_in_pos_imp(key_const_reference r_key, size_type pos)
+{
+  PB_DS_ASSERT_VALID((*this))
+  entry_pointer p_e = m_entries[pos];
+  resize_base::notify_erase_search_start();
+  if (p_e == 0)
+    {
+      resize_base::notify_erase_search_end();
+      PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+      PB_DS_ASSERT_VALID((*this))
+      return false;
+    }
+
+  if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
+    {
+      resize_base::notify_erase_search_end();
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      erase_entry_pointer(m_entries[pos]);
+      do_resize_if_needed_no_throw();
+      PB_DS_ASSERT_VALID((*this))
+      return true;
+    }
+
+  while (true)
+    {
+      entry_pointer p_next_e = p_e->m_p_next;
+      if (p_next_e == 0)
+	{
+	  resize_base::notify_erase_search_end();
+	  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	  PB_DS_ASSERT_VALID((*this))
+	  return false;
+	}
+
+      if (hash_eq_fn_base::operator()(PB_DS_V2F(p_next_e->m_value), r_key))
+	{
+	  resize_base::notify_erase_search_end();
+	  PB_DS_CHECK_KEY_EXISTS(r_key)
+	  erase_entry_pointer(p_e->m_p_next);
+	  do_resize_if_needed_no_throw();
+	  PB_DS_ASSERT_VALID((*this))
+	  return true;
+	}
+      resize_base::notify_erase_search_collision();
+      p_e = p_next_e;
+    }
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..a1840e5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
@@ -0,0 +1,94 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/erase_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s erase related functions,
+ * when the hash value is stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase_in_pos_imp(key_const_reference r_key, const comp_hash& r_pos_hash_pair)
+{
+  PB_DS_ASSERT_VALID((*this))
+  entry_pointer p_e = m_entries[r_pos_hash_pair.first];
+  resize_base::notify_erase_search_start();
+  if (p_e == 0)
+    {
+      resize_base::notify_erase_search_end();
+      PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+      PB_DS_ASSERT_VALID((*this))
+      return false;
+    }
+
+  if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash,
+				  r_key, r_pos_hash_pair.second))
+    {
+      resize_base::notify_erase_search_end();
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      erase_entry_pointer(m_entries[r_pos_hash_pair.first]);
+      do_resize_if_needed_no_throw();
+      PB_DS_ASSERT_VALID((*this))
+      return true;
+    }
+
+  while (true)
+    {
+      entry_pointer p_next_e = p_e->m_p_next;
+      if (p_next_e == 0)
+	{
+	  resize_base::notify_erase_search_end();
+	  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	  PB_DS_ASSERT_VALID((*this))
+	  return false;
+	}
+
+      if (hash_eq_fn_base::operator()(PB_DS_V2F(p_next_e->m_value),
+				      p_next_e->m_hash, r_key,
+				      r_pos_hash_pair.second))
+	{
+	  resize_base::notify_erase_search_end();
+	  PB_DS_CHECK_KEY_EXISTS(r_key)
+	  erase_entry_pointer(p_e->m_p_next);
+	  do_resize_if_needed_no_throw();
+	  PB_DS_ASSERT_VALID((*this))
+	  return true;
+	}
+      resize_base::notify_erase_search_collision();
+      p_e = p_next_e;
+    }
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp
new file mode 100644
index 0000000..fe8bc6a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp
@@ -0,0 +1,71 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/find_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s find related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key)
+{
+  PB_DS_ASSERT_VALID((*this))
+  return find_key_pointer(r_key, traits_base::m_store_extra_indicator);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key) const
+{
+  PB_DS_ASSERT_VALID((*this))
+  return const_cast<PB_DS_CLASS_C_DEC& >(*this).find_key_pointer(r_key, 
+					traits_base::m_store_extra_indicator);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+find_end()
+{ return 0; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+find_end() const
+{ return 0; }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..ce727a1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_store_hash_fn_imps.hpp
@@ -0,0 +1,41 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/find_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s find related functions,
+ * when the hash value is stored.
+ */
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp
new file mode 100644
index 0000000..a87f2b6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/info_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s entire container info related
+ * functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{ return m_num_used_e; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{ return m_entry_allocator.max_size(); }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{ return (size() == 0); }
+
+PB_DS_CLASS_T_DEC
+template<typename Other_HT_Map_Type>
+bool
+PB_DS_CLASS_C_DEC::
+operator==(const Other_HT_Map_Type& other) const
+{ return cmp_with_other(other); }
+
+PB_DS_CLASS_T_DEC
+template<typename Other_Map_Type>
+bool
+PB_DS_CLASS_C_DEC::
+cmp_with_other(const Other_Map_Type& other) const
+{
+  if (size() != other.size())
+    return false;
+
+  for (typename Other_Map_Type::const_iterator it = other.begin();
+       it != other.end(); ++it)
+    {
+      key_const_reference r_key =(key_const_reference)PB_DS_V2F(*it);
+      mapped_const_pointer p_mapped_value =
+	const_cast<PB_DS_CLASS_C_DEC& >(*this).
+	find_key_pointer(r_key, traits_base::m_store_extra_indicator);
+
+      if (p_mapped_value == 0)
+	return false;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      if (p_mapped_value->second != it->second)
+	return false;
+#endif 
+    }
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Other_HT_Map_Type>
+bool
+PB_DS_CLASS_C_DEC::
+operator!=(const Other_HT_Map_Type& other) const
+{ return !operator==(other); }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_fn_imps.hpp
new file mode 100644
index 0000000..4553662
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_fn_imps.hpp
@@ -0,0 +1,43 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/insert_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s insert related functions.
+ */
+
+#include <ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp>
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..1257f48
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
@@ -0,0 +1,70 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s insert related functions,
+ * when the hash value is not stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert_imp(const_reference r_val, false_type)
+{
+  PB_DS_ASSERT_VALID((*this))
+  key_const_reference r_key = PB_DS_V2F(r_val);
+  const size_type pos = ranged_hash_fn_base::operator()(r_key);
+  entry_pointer p_e = m_entries[pos];
+  resize_base::notify_insert_search_start();
+
+  while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), 
+						     r_key))
+    {
+      resize_base::notify_insert_search_collision();
+      p_e = p_e->m_p_next;
+    }
+
+  resize_base::notify_insert_search_end();
+  if (p_e != 0)
+    {
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      return std::make_pair(&p_e->m_value, false);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+  return std::make_pair(insert_new_imp(r_val, pos), true);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..ef7d102
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
@@ -0,0 +1,71 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/insert_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s insert related functions,
+ * when the hash value is stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert_imp(const_reference r_val, true_type)
+{
+  PB_DS_ASSERT_VALID((*this))
+  key_const_reference key = PB_DS_V2F(r_val);
+  comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(key);
+  entry_pointer p_e = m_entries[pos_hash_pair.first];
+  resize_base::notify_insert_search_start();
+
+  while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
+						     p_e->m_hash,
+						    key, pos_hash_pair.second))
+    {
+      resize_base::notify_insert_search_collision();
+      p_e = p_e->m_p_next;
+    }
+
+  resize_base::notify_insert_search_end();
+  if (p_e != 0)
+    {
+      PB_DS_CHECK_KEY_EXISTS(key)
+      return std::make_pair(&p_e->m_value, false);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(key)
+  return std::make_pair(insert_new_imp(r_val, pos_hash_pair), true);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/iterators_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/iterators_fn_imps.hpp
new file mode 100644
index 0000000..821c6d5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/iterators_fn_imps.hpp
@@ -0,0 +1,83 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/iterators_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s iterators related functions, e.g.,
+ * begin().
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::s_end_it;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::s_const_end_it;
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+begin()
+{
+  pointer p_value;
+  std::pair<entry_pointer, size_type> pos;
+  get_start_it_state(p_value, pos);
+  return iterator(p_value, pos, this);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+end()
+{ return s_end_it; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin() const
+{
+  pointer p_value;
+  std::pair<entry_pointer, size_type> pos;
+  get_start_it_state(p_value, pos);
+  return const_iterator(p_value, pos, this);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end() const
+{ return s_const_end_it; }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/policy_access_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/policy_access_fn_imps.hpp
new file mode 100644
index 0000000..7f547c3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/policy_access_fn_imps.hpp
@@ -0,0 +1,88 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/policy_access_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s policy access
+ *    functions.
+ */
+
+PB_DS_CLASS_T_DEC
+Hash_Fn& 
+PB_DS_CLASS_C_DEC::
+get_hash_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Hash_Fn& 
+PB_DS_CLASS_C_DEC::
+get_hash_fn() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Eq_Fn& 
+PB_DS_CLASS_C_DEC::
+get_eq_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Eq_Fn& 
+PB_DS_CLASS_C_DEC::
+get_eq_fn() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Comb_Hash_Fn& 
+PB_DS_CLASS_C_DEC::
+get_comb_hash_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Comb_Hash_Fn& 
+PB_DS_CLASS_C_DEC::
+get_comb_hash_fn() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Resize_Policy& 
+PB_DS_CLASS_C_DEC::
+get_resize_policy()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Resize_Policy& 
+PB_DS_CLASS_C_DEC::
+get_resize_policy() const
+{ return *this; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp
new file mode 100644
index 0000000..c4889d3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp
@@ -0,0 +1,134 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/resize_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s resize related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+do_resize_if_needed()
+{
+  if (!resize_base::is_resize_needed())
+    return false;
+  resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e));
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+do_resize(size_type len)
+{ resize_imp(resize_base::get_nearest_larger_size(len)); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+do_resize_if_needed_no_throw()
+{
+  if (!resize_base::is_resize_needed())
+    return;
+
+  __try
+    {
+      resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e));
+    }
+  __catch(...)
+    { }
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+resize_imp(size_type new_size)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (new_size == m_num_e)
+    return;
+
+  const size_type old_size = m_num_e;
+  entry_pointer_array a_p_entries_resized;
+
+  // Following line might throw an exception.
+  ranged_hash_fn_base::notify_resized(new_size);
+
+  __try
+    {
+      // Following line might throw an exception.
+      a_p_entries_resized = s_entry_pointer_allocator.allocate(new_size);
+      m_num_e = new_size;
+    }
+  __catch(...)
+    {
+      ranged_hash_fn_base::notify_resized(old_size);
+      __throw_exception_again;
+    }
+
+  // At this point no exceptions can be thrown.
+  resize_imp_no_exceptions(new_size, a_p_entries_resized, old_size);
+  Resize_Policy::notify_resized(new_size);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+resize_imp_no_exceptions(size_type new_size, entry_pointer_array a_p_entries_resized, size_type old_size)
+{
+  std::fill(a_p_entries_resized, a_p_entries_resized + m_num_e,
+	    entry_pointer(0));
+
+  for (size_type pos = 0; pos < old_size; ++pos)
+    {
+      entry_pointer p_e = m_entries[pos];
+      while (p_e != 0)
+	p_e = resize_imp_no_exceptions_reassign_pointer(p_e, a_p_entries_resized,  traits_base::m_store_extra_indicator);
+    }
+
+  m_num_e = new_size;
+  _GLIBCXX_DEBUG_ONLY(assert_entry_pointer_array_valid(a_p_entries_resized,
+						       __FILE__, __LINE__);)
+  s_entry_pointer_allocator.deallocate(m_entries, old_size);
+  m_entries = a_p_entries_resized;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+#include <ext/pb_ds/detail/cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/resize_store_hash_fn_imps.hpp>
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..d316b2d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s resize related functions, when the
+ * hash value is not stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::entry_pointer
+PB_DS_CLASS_C_DEC::
+resize_imp_no_exceptions_reassign_pointer(entry_pointer p_e, entry_pointer_array a_p_entries_resized, false_type)
+{
+  const size_type hash_pos =
+    ranged_hash_fn_base::operator()(PB_DS_V2F(p_e->m_value));
+
+  entry_pointer const p_next_e = p_e->m_p_next;
+  p_e->m_p_next = a_p_entries_resized[hash_pos];
+  a_p_entries_resized[hash_pos] = p_e;
+  return p_next_e;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..19d2c92
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_store_hash_fn_imps.hpp
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/resize_store_hash_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s resize related functions, when the
+ * hash value is stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::entry_pointer
+PB_DS_CLASS_C_DEC::
+resize_imp_no_exceptions_reassign_pointer(entry_pointer p_e, entry_pointer_array a_p_entries_resized, true_type)
+{
+  const comp_hash pos_hash_pair =
+    ranged_hash_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash);
+
+  entry_pointer const p_next_e = p_e->m_p_next;
+  p_e->m_p_next = a_p_entries_resized[pos_hash_pair.first];
+  a_p_entries_resized[pos_hash_pair.first] = p_e;
+  return p_next_e;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/size_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/size_fn_imps.hpp
new file mode 100644
index 0000000..ca0089e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/size_fn_imps.hpp
@@ -0,0 +1,59 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/size_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s entire container size related
+ * functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{ return m_num_used_e; }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{ return (size() == 0); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{ return s_entry_allocator.max_size(); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp
new file mode 100644
index 0000000..bf53ed1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp
@@ -0,0 +1,72 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_table_map_/trace_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s trace-mode functions.
+ */
+
+#ifdef PB_DS_HT_MAP_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  std::cerr << static_cast<unsigned long>(m_num_e) << " " 
+	    << static_cast<unsigned long>(m_num_used_e) << std::endl;
+
+  for (size_type i = 0; i < m_num_e; ++i)
+    {
+      std::cerr << static_cast<unsigned long>(i) << " ";
+      trace_list(m_entries[i]);
+      std::cerr << std::endl;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace_list(const_entry_pointer p_l) const
+{
+  size_type iterated_num_used_e = 0;
+  while (p_l != 0)
+    {
+      std::cerr << PB_DS_V2F(p_l->m_value) << " ";
+      p_l = p_l->m_p_next;
+    }
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cond_dealtor.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cond_dealtor.hpp
new file mode 100644
index 0000000..c776fe4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/cond_dealtor.hpp
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/cond_dealtor.hpp
+ * Contains a conditional deallocator.
+ */
+
+#ifndef PB_DS_COND_DEALTOR_HPP
+#define PB_DS_COND_DEALTOR_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Conditional deallocate constructor argument.
+    template<typename Entry, typename _Alloc>
+      class cond_dealtor
+      {
+	typedef typename _Alloc::template rebind<Entry>	__rebind_e;
+
+      public:
+	typedef typename __rebind_e::other 		entry_allocator;
+	typedef typename entry_allocator::pointer 	entry_pointer;
+
+	cond_dealtor(entry_pointer p_e)
+	: m_p_e(p_e), m_no_action_destructor(false) { }
+
+	~cond_dealtor()
+	{
+	  if (m_no_action_destructor)
+	    return;
+	  s_alloc.deallocate(m_p_e, 1);
+	}
+
+	void
+	set_no_action()
+	{ m_no_action_destructor = true; }
+
+      private:
+	entry_pointer 		m_p_e;
+	bool 			m_no_action_destructor;
+	static entry_allocator 	s_alloc;
+      };
+
+    template<typename Entry, class _Alloc>
+      typename cond_dealtor<Entry, _Alloc>::entry_allocator
+      cond_dealtor<Entry, _Alloc>::s_alloc;
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_COND_DEALTOR_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/container_base_dispatch.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/container_base_dispatch.hpp
new file mode 100644
index 0000000..764a1de
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/container_base_dispatch.hpp
@@ -0,0 +1,352 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file container_base_dispatch.hpp
+ * Contains associative container dispatching.
+ */
+
+#ifndef PB_DS_ASSOC_CNTNR_BASE_DS_DISPATCHER_HPP
+#define PB_DS_ASSOC_CNTNR_BASE_DS_DISPATCHER_HPP
+
+#include <ext/typelist.h>
+
+#define PB_DS_ASSERT_VALID(X)						\
+  _GLIBCXX_DEBUG_ONLY(X.assert_valid(__FILE__, __LINE__);)
+
+#define PB_DS_DEBUG_VERIFY(_Cond)					\
+  _GLIBCXX_DEBUG_VERIFY_AT(_Cond,					\
+			   _M_message(#_Cond" assertion from %1;:%2;")	\
+			   ._M_string(__FILE__)._M_integer(__LINE__)	\
+			   ,__file,__line)
+
+#define PB_DS_CHECK_KEY_EXISTS(_Key)					\
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(_Key, __FILE__, __LINE__);)
+
+#define PB_DS_CHECK_KEY_DOES_NOT_EXIST(_Key)				\
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(_Key,	\
+							   __FILE__, __LINE__);)
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#define PB_DS_V2F(X) (X).first
+#define PB_DS_V2S(X) (X).second
+#define PB_DS_EP2VP(X)& ((X)->m_value)
+#include <ext/pb_ds/detail/list_update_map_/lu_map_.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp>
+#include <ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp>
+#include <ext/pb_ds/detail/splay_tree_/splay_tree_.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp>
+#include <ext/pb_ds/detail/pat_trie_/pat_trie_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+#undef PB_DS_V2F
+#undef PB_DS_V2S
+#undef PB_DS_EP2VP
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#define PB_DS_V2F(X) (X)
+#define PB_DS_V2S(X) Mapped_Data()
+#define PB_DS_EP2VP(X)& ((X)->m_value.first)
+#include <ext/pb_ds/detail/list_update_map_/lu_map_.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp>
+#include <ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp>
+#include <ext/pb_ds/detail/splay_tree_/splay_tree_.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp>
+#include <ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp>
+#include <ext/pb_ds/detail/pat_trie_/pat_trie_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+#undef PB_DS_V2F
+#undef PB_DS_V2S
+#undef PB_DS_EP2VP
+
+#undef PB_DS_CHECK_KEY_DOES_NOT_EXIST
+#undef PB_DS_CHECK_KEY_EXISTS
+#undef PB_DS_DEBUG_VERIFY
+#undef PB_DS_ASSERT_VALID
+
+namespace __gnu_pbds
+{
+namespace detail
+{
+  /// Specialization for list-update map.
+  template<typename Key, typename Mapped, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, Mapped, _Alloc, list_update_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef lu_map<Key, Mapped, at0t, _Alloc, at1t>	type;
+    };
+
+  /// Specialization for list-update set.
+  template<typename Key, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, null_type, _Alloc, list_update_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef lu_set<Key, null_type, at0t, _Alloc, at1t> type;
+    };
+
+  /// Specialization for PATRICIA trie map.
+  template<typename Key, typename Mapped, typename _Alloc, typename Policy_Tl>
+  struct container_base_dispatch<Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef pat_trie_map<Key, Mapped, at1t, _Alloc> 		type;
+    };
+
+  /// Specialization for PATRICIA trie set.
+  template<typename Key, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, null_type, _Alloc, pat_trie_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef pat_trie_set<Key, null_type, at1t, _Alloc> type;
+    };
+
+  /// Specialization for R-B tree map.
+  template<typename Key, typename Mapped, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef rb_tree_map<Key, Mapped, at0t, at1t, _Alloc> 	type;
+    };
+
+  /// Specialization for R-B tree set.
+  template<typename Key, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, null_type, _Alloc, rb_tree_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef rb_tree_set<Key, null_type, at0t, at1t, _Alloc> type;
+    };
+
+  /// Specialization splay tree map.
+  template<typename Key, typename Mapped, typename _Alloc, typename Policy_Tl>
+  struct container_base_dispatch<Key, Mapped, _Alloc, splay_tree_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef splay_tree_map<Key, Mapped, at0t, at1t, _Alloc> 	type;
+    };
+
+  /// Specialization splay tree set.
+  template<typename Key, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, null_type, _Alloc, splay_tree_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef splay_tree_set<Key, null_type, at0t, at1t, _Alloc> type;
+  };
+
+    /// Specialization ordered-vector tree map.
+  template<typename Key, typename Mapped, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef ov_tree_map<Key, Mapped, at0t, at1t, _Alloc> 	type;
+  };
+
+    /// Specialization ordered-vector tree set.
+  template<typename Key, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, null_type, _Alloc, ov_tree_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      /// Dispatched type.
+      typedef ov_tree_set<Key, null_type, at0t, at1t, _Alloc> type;
+  };
+
+    /// Specialization colision-chaining hash map.
+  template<typename Key, typename Mapped, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+
+    public:
+      /// Dispatched type.
+      typedef cc_ht_map<Key, Mapped, at0t, at1t, _Alloc, 
+			at3t::value, at4t, at2t> 	       	type;
+  };
+
+    /// Specialization colision-chaining hash set.
+  template<typename Key, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, null_type, _Alloc, cc_hash_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+
+    public:
+      /// Dispatched type.
+      typedef cc_ht_set<Key, null_type, at0t, at1t, _Alloc,
+				 at3t::value, at4t, at2t>    	type;
+  };
+
+    /// Specialization general-probe hash map.
+  template<typename Key, typename Mapped, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 5> 	at5;
+      typedef typename at5::type			    	at5t;
+
+    public:
+      /// Dispatched type.
+      typedef gp_ht_map<Key, Mapped, at0t, at1t, _Alloc, 
+			at3t::value, at4t, at5t, at2t> 		type;
+  };
+
+    /// Specialization general-probe hash set.
+  template<typename Key, typename _Alloc, typename Policy_Tl>
+    struct container_base_dispatch<Key, null_type, _Alloc, gp_hash_tag,
+				   Policy_Tl>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 5> 	at5;
+      typedef typename at5::type			    	at5t;
+
+    public:
+      /// Dispatched type.
+      typedef gp_ht_set<Key, null_type, at0t, at1t, _Alloc,
+			at3t::value, at4t, at5t, at2t>		type;
+  };
+} // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
new file mode 100644
index 0000000..cb7324d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
@@ -0,0 +1,349 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/debug_map_base.hpp
+ * Contains a debug-mode base for all maps.
+ */
+
+#ifndef PB_DS_DEBUG_MAP_BASE_HPP
+#define PB_DS_DEBUG_MAP_BASE_HPP
+
+#ifdef _GLIBCXX_DEBUG
+
+#include <list>
+#include <utility>
+#include <cstdlib>
+#include <iostream>
+#include <ext/throw_allocator.h>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    // Need std::pair ostream extractor.
+    template<typename _CharT, typename _Traits, typename _Tp1, typename _Tp2>
+    inline std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __out,
+	       const std::pair<_Tp1, _Tp2>& p)
+    { return (__out << '(' << p.first << ',' << p.second << ')'); }
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Eq_Fn, typename Const_Key_Reference>
+
+#define PB_DS_CLASS_C_DEC \
+    debug_map_base<Key, Eq_Fn, Const_Key_Reference>
+
+    /// Debug base class.
+    template<typename Key, typename Eq_Fn, typename Const_Key_Reference>
+    class debug_map_base
+    {
+    private:
+      typedef Const_Key_Reference 			key_const_reference;
+      typedef std::_GLIBCXX_STD_C::list<Key> 		key_repository;
+      typedef typename key_repository::size_type       	size_type;
+      typedef typename key_repository::iterator	       	iterator;
+      typedef typename key_repository::const_iterator  	const_iterator;
+
+    protected:
+      debug_map_base();
+
+      debug_map_base(const PB_DS_CLASS_C_DEC&);
+
+      ~debug_map_base();
+
+      inline void
+      insert_new(key_const_reference);
+
+      inline void
+      erase_existing(key_const_reference);
+
+      void
+      clear();
+
+      inline void
+      check_key_exists(key_const_reference, const char*, int) const;
+
+      inline void
+      check_key_does_not_exist(key_const_reference, const char*, int) const;
+
+      inline void
+      check_size(size_type, const char*, int) const;
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      template<typename Cmp_Fn>
+      void
+      split(key_const_reference, Cmp_Fn, PB_DS_CLASS_C_DEC&);
+
+      void
+      join(PB_DS_CLASS_C_DEC&, bool with_cleanup = true);
+
+    private:
+      void
+      assert_valid(const char*, int) const;
+
+      const_iterator
+      find(key_const_reference) const;
+
+      iterator
+      find(key_const_reference);
+
+      key_repository 	m_keys;
+      Eq_Fn 		m_eq;
+    };
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    debug_map_base()
+    { PB_DS_ASSERT_VALID((*this)) }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    debug_map_base(const PB_DS_CLASS_C_DEC& other)
+    : m_keys(other.m_keys), m_eq(other.m_eq)
+    { PB_DS_ASSERT_VALID((*this)) }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ~debug_map_base()
+    { PB_DS_ASSERT_VALID((*this)) }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    insert_new(key_const_reference r_key)
+    {
+      PB_DS_ASSERT_VALID((*this))
+
+      if (find(r_key) != m_keys.end())
+	{
+	  std::cerr << "insert_new key already present " << r_key << std::endl;
+	  std::abort();
+	}
+
+      __try
+	{
+	  m_keys.push_back(r_key);
+	}
+      __catch(...)
+	{
+	  std::cerr << "insert_new " << r_key << std::endl;
+	  std::abort();
+	}
+
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    erase_existing(key_const_reference r_key)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      iterator it = find(r_key);
+      if (it == m_keys.end())
+	{
+	  std::cerr << "erase_existing" << r_key << std::endl;
+	  std::abort();
+	}
+      m_keys.erase(it);
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    clear()
+    {
+      PB_DS_ASSERT_VALID((*this))
+      m_keys.clear();
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    check_key_exists(key_const_reference r_key,
+		     const char* __file, int __line) const
+    {
+      assert_valid(__file, __line);
+      if (find(r_key) == m_keys.end())
+	{
+	  std::cerr << __file << ':' << __line << ": check_key_exists "
+		    << r_key << std::endl;
+	  std::abort();
+	}
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    check_key_does_not_exist(key_const_reference r_key,
+			     const char* __file, int __line) const
+    {
+      assert_valid(__file, __line);
+      if (find(r_key) != m_keys.end())
+	{
+	  using std::cerr;
+	  using std::endl;
+	  cerr << __file << ':' << __line << ": check_key_does_not_exist "
+	       << r_key << endl;
+	  std::abort();
+	}
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    check_size(size_type size, const char* __file, int __line) const
+    {
+      assert_valid(__file, __line);
+      const size_type keys_size = m_keys.size();
+      if (size != keys_size)
+	{
+	  std::cerr << __file << ':' << __line << ": check_size "
+		    << size << " != " << keys_size << std::endl;
+	  std::abort();
+	}
+     }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      m_keys.swap(other.m_keys);
+      std::swap(m_eq, other.m_eq);
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::const_iterator
+    PB_DS_CLASS_C_DEC::
+    find(key_const_reference r_key) const
+    {
+      PB_DS_ASSERT_VALID((*this))
+      typedef const_iterator iterator_type;
+      for (iterator_type it = m_keys.begin(); it != m_keys.end(); ++it)
+	if (m_eq(*it, r_key))
+	  return it;
+      return m_keys.end();
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::iterator
+    PB_DS_CLASS_C_DEC::
+    find(key_const_reference r_key)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      iterator it = m_keys.begin();
+      while (it != m_keys.end())
+	{
+	  if (m_eq(*it, r_key))
+	    return it;
+	  ++it;
+	}
+      return it;
+     }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    assert_valid(const char* __file, int __line) const
+    {
+      const_iterator prime_it = m_keys.begin();
+      while (prime_it != m_keys.end())
+	{
+	  const_iterator sec_it = prime_it;
+	  ++sec_it;
+	  while (sec_it != m_keys.end())
+	    {
+	      PB_DS_DEBUG_VERIFY(!m_eq(*sec_it, *prime_it));
+	      PB_DS_DEBUG_VERIFY(!m_eq(*prime_it, *sec_it));
+	      ++sec_it;
+	    }
+	  ++prime_it;
+	}
+    }
+
+    PB_DS_CLASS_T_DEC
+    template<typename Cmp_Fn>
+    void
+    PB_DS_CLASS_C_DEC::
+    split(key_const_reference r_key, Cmp_Fn cmp_fn, PB_DS_CLASS_C_DEC& other)
+    {
+      other.clear();
+      iterator it = m_keys.begin();
+      while (it != m_keys.end())
+	if (cmp_fn(r_key, *it))
+	  {
+	    other.insert_new(*it);
+	    it = m_keys.erase(it);
+	  }
+	else
+	  ++it;
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    join(PB_DS_CLASS_C_DEC& other, bool with_cleanup)
+    {
+      iterator it = other.m_keys.begin();
+      while (it != other.m_keys.end())
+	{
+	  insert_new(*it);
+	  if (with_cleanup)
+	    it = other.m_keys.erase(it);
+	  else
+	    ++it;
+	}
+      _GLIBCXX_DEBUG_ASSERT(!with_cleanup || other.m_keys.empty());
+    }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+} // namespace detail
+} // namespace __gnu_pbds
+
+
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/eq_fn/eq_by_less.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/eq_fn/eq_by_less.hpp
new file mode 100644
index 0000000..5d54fa2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/eq_fn/eq_by_less.hpp
@@ -0,0 +1,69 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file eq_by_less.hpp
+ * Contains an equivalence function.
+ */
+
+#ifndef PB_DS_EQ_BY_LESS_HPP
+#define PB_DS_EQ_BY_LESS_HPP
+
+#include <utility>
+#include <functional>
+#include <vector>
+#include <assert.h>
+#include <ext/pb_ds/detail/types_traits.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Equivalence function.
+    template<typename Key, class Cmp_Fn>
+    struct eq_by_less : private Cmp_Fn
+    {
+      bool
+      operator()(const Key& r_lhs, const Key& r_rhs) const
+      {
+	const bool l = Cmp_Fn::operator()(r_lhs, r_rhs);
+	const bool g = Cmp_Fn::operator()(r_rhs, r_lhs);
+	return !(l || g);
+      }
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_EQ_BY_LESS_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp
new file mode 100644
index 0000000..7ba0098
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp
@@ -0,0 +1,110 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_eq_fn.hpp
+ * Contains 2 eqivalence functions, one employing a hash value,
+ * and one ignoring it.
+ */
+
+#ifndef PB_DS_HASH_EQ_FN_HPP
+#define PB_DS_HASH_EQ_FN_HPP
+
+#include <utility>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Primary template.
+    template<typename Key, typename Eq_Fn, typename _Alloc, bool Store_Hash>
+      struct hash_eq_fn;
+
+    /// Specialization 1 - The client requests that hash values not be stored.
+    template<typename Key, typename Eq_Fn, typename _Alloc>
+    struct hash_eq_fn<Key, Eq_Fn, _Alloc, false> : public Eq_Fn
+    {
+      typedef Eq_Fn 					   eq_fn_base;
+      typedef typename _Alloc::template rebind<Key>::other key_allocator;
+      typedef typename key_allocator::const_reference 	   key_const_reference;
+
+      hash_eq_fn() { }
+
+      hash_eq_fn(const Eq_Fn& r_eq_fn) : Eq_Fn(r_eq_fn) { }
+
+      bool
+      operator()(key_const_reference r_lhs_key, 
+		 key_const_reference r_rhs_key) const
+      { return eq_fn_base::operator()(r_lhs_key, r_rhs_key); }
+
+      void
+      swap(const hash_eq_fn& other)
+      { std::swap((Eq_Fn&)(*this), (Eq_Fn&)other); }
+    };
+
+
+    /// Specialization 2 - The client requests that hash values be stored.
+    template<typename Key, class Eq_Fn, class _Alloc>
+    struct hash_eq_fn<Key, Eq_Fn, _Alloc, true> : public Eq_Fn
+    {
+      typedef typename _Alloc::size_type 		   size_type;
+      typedef Eq_Fn 					   eq_fn_base;
+      typedef typename _Alloc::template rebind<Key>::other key_allocator;
+      typedef typename key_allocator::const_reference 	   key_const_reference;
+
+      hash_eq_fn() { }
+
+      hash_eq_fn(const Eq_Fn& r_eq_fn) : Eq_Fn(r_eq_fn) { }
+
+      bool
+      operator()(key_const_reference r_lhs_key, size_type lhs_hash, 
+		 key_const_reference r_rhs_key, size_type rhs_hash) const
+      {
+	_GLIBCXX_DEBUG_ASSERT(!eq_fn_base::operator()(r_lhs_key, r_rhs_key) 
+			      || lhs_hash == rhs_hash);
+
+	return (lhs_hash == rhs_hash && 
+		eq_fn_base::operator()(r_lhs_key, r_rhs_key));
+      }
+
+      void
+      swap(const hash_eq_fn& other)
+      { std::swap((Eq_Fn&)(*this), (Eq_Fn&)(other)); }
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
new file mode 100644
index 0000000..1b957a5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
@@ -0,0 +1,223 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/constructor_destructor_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s constructors, destructor,
+ * and related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::entry_allocator
+PB_DS_CLASS_C_DEC::s_entry_allocator;
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    insert(*(first_it++));
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_GP_HASH_NAME() 
+: ranged_probe_fn_base(resize_base::get_nearest_larger_size(1)),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_GP_HASH_NAME(const Hash_Fn& r_hash_fn)    
+: ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_GP_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) 
+: hash_eq_fn_base(r_eq_fn),
+  ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_GP_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, 
+		 const Comb_Probe_Fn& r_comb_hash_fn) 
+: hash_eq_fn_base(r_eq_fn),
+  ranged_probe_fn_base(resize_base::get_nearest_larger_size(1),
+		       r_hash_fn, r_comb_hash_fn),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_GP_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, 
+		 const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& prober) 
+: hash_eq_fn_base(r_eq_fn),
+  ranged_probe_fn_base(resize_base::get_nearest_larger_size(1),
+		       r_hash_fn, comb_hash_fn, prober),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_GP_HASH_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, 
+		 const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& prober, 
+		 const Resize_Policy& r_resize_policy) 
+: hash_eq_fn_base(r_eq_fn), resize_base(r_resize_policy),
+  ranged_probe_fn_base(resize_base::get_nearest_larger_size(1),
+		       r_hash_fn, comb_hash_fn, prober),
+  m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0),
+  m_entries(s_entry_allocator.allocate(m_num_e))
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_GP_HASH_NAME(const PB_DS_CLASS_C_DEC& other) :
+#ifdef _GLIBCXX_DEBUG
+  debug_base(other),
+#endif 
+  hash_eq_fn_base(other),
+  resize_base(other),
+  ranged_probe_fn_base(other),
+  m_num_e(other.m_num_e),
+  m_num_used_e(other.m_num_used_e),
+  m_entries(s_entry_allocator.allocate(m_num_e))
+{
+  for (size_type i = 0; i < m_num_e; ++i)
+    m_entries[i].m_stat = (entry_status)empty_entry_status;
+
+  __try
+    {
+      for (size_type i = 0; i < m_num_e; ++i)
+        {
+	  m_entries[i].m_stat = other.m_entries[i].m_stat;
+	  if (m_entries[i].m_stat == valid_entry_status)
+	    new (m_entries + i) entry(other.m_entries[i]);
+        }
+    }
+  __catch(...)
+    {
+      deallocate_all();
+      __throw_exception_again;
+    }
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~PB_DS_GP_HASH_NAME()
+{ deallocate_all(); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  std::swap(m_num_e, other.m_num_e);
+  std::swap(m_num_used_e, other.m_num_used_e);
+  std::swap(m_entries, other.m_entries);
+  ranged_probe_fn_base::swap(other);
+  hash_eq_fn_base::swap(other);
+  resize_base::swap(other);
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other));
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+deallocate_all()
+{
+  clear();
+  erase_all_valid_entries(m_entries, m_num_e);
+  s_entry_allocator.deallocate(m_entries, m_num_e);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_all_valid_entries(entry_array a_entries_resized, size_type len)
+{
+  for (size_type pos = 0; pos < len; ++pos)
+    {
+      entry_pointer p_e = &a_entries_resized[pos];
+      if (p_e->m_stat == valid_entry_status)
+	p_e->m_value.~value_type();
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize()
+{
+  Resize_Policy::notify_resized(m_num_e);
+  Resize_Policy::notify_cleared();
+  ranged_probe_fn_base::notify_resized(m_num_e);
+  for (size_type i = 0; i < m_num_e; ++i)
+    m_entries[i].m_stat = empty_entry_status;
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..af5a8c4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
@@ -0,0 +1,53 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s constructors, destructor,
+ *    and related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+constructor_insert_new_imp(mapped_const_reference r_val, size_type pos, 
+			   false_type)
+{
+  _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status)k;
+  entry* const p_e = m_entries + pos;
+  new (&p_e->m_value) mapped_value_type(r_val);
+  p_e->m_stat = valid_entry_status;
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(p_e->m_value.first);)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..7ce74f2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s constructors, destructor,
+ * and related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+constructor_insert_new_imp(mapped_const_reference r_val, size_type pos, 
+			   true_type)
+{
+  _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status);
+  entry* const p_e = m_entries + pos;
+  new (&p_e->m_value) mapped_value_type(r_val);
+  p_e->m_hash = ranged_probe_fn_base::operator()(PB_DS_V2F(r_val)).second;
+  p_e->m_stat = valid_entry_status;
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(p_e->m_value.first);)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
new file mode 100644
index 0000000..6965ebf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
@@ -0,0 +1,56 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/debug_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s debug-mode functions.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  debug_base::check_size(m_num_used_e, __file, __line);
+  assert_entry_array_valid(m_entries, traits_base::m_store_extra_indicator,
+			   __file, __line);
+}
+
+#include <ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp>
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..1535d6c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp
@@ -0,0 +1,72 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s debug-mode functions.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_entry_array_valid(const entry_array a_entries, false_type,
+			 const char* __file, int __line) const
+{
+  size_type iterated_num_used_e = 0;
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    {
+      const_entry_pointer p_e = &a_entries[pos];
+      switch(p_e->m_stat)
+        {
+        case empty_entry_status:
+        case erased_entry_status:
+	  break;
+        case valid_entry_status:
+	  {
+	    key_const_reference r_key = PB_DS_V2F(p_e->m_value);
+	    debug_base::check_key_exists(r_key, __file, __line);
+	    ++iterated_num_used_e;
+	    break;
+	  }
+        default:
+	  PB_DS_DEBUG_VERIFY(0);
+        };
+    }
+  PB_DS_DEBUG_VERIFY(iterated_num_used_e == m_num_used_e);
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..cae4352
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp
@@ -0,0 +1,78 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/debug_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s debug-mode functions.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_entry_array_valid(const entry_array a_entries, true_type,
+			 const char* __file, int __line) const
+{
+  size_type iterated_num_used_e = 0;
+
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    {
+      const_entry_pointer p_e =& a_entries[pos];
+      switch(p_e->m_stat)
+        {
+        case empty_entry_status:
+        case erased_entry_status:
+	  break;
+        case valid_entry_status:
+	  {
+	    key_const_reference r_key = PB_DS_V2F(p_e->m_value);
+	    debug_base::check_key_exists(r_key, __file, __line);
+
+	    const comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key);
+
+	    PB_DS_DEBUG_VERIFY(p_e->m_hash == pos_hash_pair.second);
+	    ++iterated_num_used_e;
+	    break;
+	  }
+        default:
+	  PB_DS_DEBUG_VERIFY(0);
+        };
+    }
+
+  PB_DS_DEBUG_VERIFY(iterated_num_used_e == m_num_used_e);
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
new file mode 100644
index 0000000..a4bc92e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/erase_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s erase related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+erase_entry(entry_pointer p_e)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_e->m_stat = valid_entry_status);
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_e->m_value));)
+  p_e->m_value.~value_type();
+  p_e->m_stat = erased_entry_status;
+  _GLIBCXX_DEBUG_ASSERT(m_num_used_e > 0);
+  resize_base::notify_erased(--m_num_used_e);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    {
+      entry_pointer p_e = &m_entries[pos];
+      if (p_e->m_stat == valid_entry_status)
+	erase_entry(p_e);
+    }
+  do_resize_if_needed_no_throw();
+  resize_base::notify_cleared();
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+  size_type num_ersd = 0;
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    {
+      entry_pointer p_e = &m_entries[pos];
+      if (p_e->m_stat == valid_entry_status)
+	if (pred(p_e->m_value))
+	  {
+	    ++num_ersd;
+	    erase_entry(p_e);
+	  }
+    }
+
+  do_resize_if_needed_no_throw();
+  PB_DS_ASSERT_VALID((*this))
+  return num_ersd;
+}
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase(key_const_reference r_key)
+{ return erase_imp(r_key, traits_base::m_store_extra_indicator); }
+
+#include <ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp>
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..a8555f7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s erase related functions,
+ * when the hash value is not stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase_imp(key_const_reference r_key,  false_type)
+{
+  PB_DS_ASSERT_VALID((*this))
+  size_type hash = ranged_probe_fn_base::operator()(r_key);
+  size_type i;
+  resize_base::notify_erase_search_start();
+
+  for (i = 0; i < m_num_e; ++i)
+    {
+      const size_type pos = ranged_probe_fn_base::operator()(r_key,  hash, i);
+      entry* const p_e = m_entries + pos;
+      switch(p_e->m_stat)
+        {
+        case empty_entry_status:
+	  {
+	    resize_base::notify_erase_search_end();
+	    PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	    return false;
+	  }
+	  break;
+        case valid_entry_status:
+	  if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
+            {
+	      resize_base::notify_erase_search_end();
+	      erase_entry(p_e);
+	      do_resize_if_needed_no_throw();
+	      return true;
+            }
+	  break;
+        case erased_entry_status:
+	  break;
+        default:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+        };
+      resize_base::notify_erase_search_collision();
+    }
+  resize_base::notify_erase_search_end();
+  return false;
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..f483e11
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
@@ -0,0 +1,85 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/erase_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s erase related functions,
+ * when the hash value is stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase_imp(key_const_reference r_key, true_type)
+{
+  const comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key);
+  size_type i;
+  resize_base::notify_erase_search_start();
+  for (i = 0; i < m_num_e; ++i)
+    {
+      const size_type pos = ranged_probe_fn_base::operator()(r_key, pos_hash_pair.second, i);
+
+      entry* const p_e = m_entries + pos;
+      switch(p_e->m_stat)
+        {
+        case empty_entry_status:
+	  {
+	    resize_base::notify_erase_search_end();
+	    PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	    return false;
+	  }
+	  break;
+        case valid_entry_status:
+	  if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash,
+					  r_key, pos_hash_pair.second))
+            {
+	      resize_base::notify_erase_search_end();
+	      erase_entry(p_e);
+	      do_resize_if_needed_no_throw();
+	      return true;
+            }
+	  break;
+        case erased_entry_status:
+	  break;
+        default:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+        };
+
+      resize_base::notify_erase_search_collision();
+    }
+  resize_base::notify_erase_search_end();
+  return false;
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp
new file mode 100644
index 0000000..2ef1569
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp
@@ -0,0 +1,70 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/find_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s find related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key)
+{
+  PB_DS_ASSERT_VALID((*this))
+  return find_key_pointer(r_key, traits_base::m_store_extra_indicator);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key) const
+{
+  PB_DS_ASSERT_VALID((*this))
+  return const_cast<PB_DS_CLASS_C_DEC&>(*this).find_key_pointer(r_key, traits_base::m_store_extra_indicator);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+find_end()
+{ return 0; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+find_end() const
+{ return 0; }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..485389c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_no_store_hash_fn_imps.hpp
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/find_no_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s find related functions,
+ * when the hash value is not stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::pointer
+PB_DS_CLASS_C_DEC::
+find_key_pointer(key_const_reference r_key, false_type)
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..6f7e4c2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_store_hash_fn_imps.hpp
@@ -0,0 +1,40 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/find_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s insert related functions,
+ * when the hash value is stored.
+ */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
new file mode 100644
index 0000000..881d26e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
@@ -0,0 +1,713 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/gp_ht_map_.hpp
+ * Contains an implementation class for general probing hash.
+ */
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp>
+#include <utility>
+#ifdef PB_DS_HT_MAP_TRACE_
+#include <iostream>
+#endif
+#ifdef _GLIBCXX_DEBUG
+#include <ext/pb_ds/detail/debug_map_base.hpp>
+#endif
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+#define PB_DS_GP_HASH_NAME gp_ht_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+#define PB_DS_GP_HASH_NAME gp_ht_set
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+   template<typename Key, typename Mapped, typename Hash_Fn, typename Eq_Fn, \
+	    typename _Alloc, bool Store_Hash, typename Comb_Probe_Fn, \
+	    typename Probe_Fn,	typename Resize_Policy>
+
+#define PB_DS_CLASS_C_DEC \
+   PB_DS_GP_HASH_NAME<Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, \
+		    Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy>
+
+#define PB_DS_HASH_EQ_FN_C_DEC \
+    hash_eq_fn<Key, Eq_Fn, _Alloc, Store_Hash>
+
+#define PB_DS_RANGED_PROBE_FN_C_DEC \
+   ranged_probe_fn<Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, Store_Hash>
+
+#define PB_DS_GP_HASH_TRAITS_BASE \
+   types_traits<Key, Mapped, _Alloc, Store_Hash>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+   debug_map_base<Key, Eq_Fn, \
+		  typename _Alloc::template rebind<Key>::other::const_reference>
+#endif
+
+
+    /**
+     *  A general-probing hash-based container.
+     *
+     *
+     *  @ingroup hash-detail
+     *
+     *  @tparam Key 	    	Key type.
+     *
+     *  @tparam Mapped 	    	Map type.
+     *
+     *  @tparam Hash_Fn	      	Hashing functor.
+     *                          Default is __gnu_cxx::hash.
+     *
+     *  @tparam Eq_Fn	      	Equal functor.
+     *                          Default std::equal_to<Key>
+     *
+     *  @tparam _Alloc 	    	Allocator type.
+     *
+     *  @tparam Store_Hash    	If key type stores extra metadata.
+     *                          Defaults to false.
+     *
+     *  @tparam Comb_Probe_Fn	Combining probe functor.
+     *                          If Hash_Fn is not null_type, then this
+     *                          is the ranged-probe functor; otherwise,
+     *                          this is the range-hashing functor.
+     *                    XXX See Design::Hash-Based Containers::Hash Policies.
+     *                          Default direct_mask_range_hashing.
+     *
+     *  @tparam Probe_Fn       	Probe functor.
+     *                          Defaults to linear_probe_fn,
+     *                          also quadratic_probe_fn.
+     *
+     *  @tparam Resize_Policy 	Resizes hash.
+     *                          Defaults to hash_standard_resize_policy,
+     *                          using hash_exponential_size_policy and
+     *                          hash_load_check_resize_trigger.
+     *
+     *
+     *  Bases are: detail::hash_eq_fn, Resize_Policy, detail::ranged_probe_fn,
+     *             detail::types_traits. (Optional: detail::debug_map_base.)
+     */
+    template<typename Key,
+	     typename Mapped,
+	     typename Hash_Fn,
+	     typename Eq_Fn,
+	     typename _Alloc,
+	     bool Store_Hash,
+	     typename Comb_Probe_Fn,
+	     typename Probe_Fn,
+	     typename Resize_Policy>
+    class PB_DS_GP_HASH_NAME :
+#ifdef _GLIBCXX_DEBUG
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
+#endif
+      public PB_DS_HASH_EQ_FN_C_DEC,
+      public Resize_Policy,
+      public PB_DS_RANGED_PROBE_FN_C_DEC,
+      public PB_DS_GP_HASH_TRAITS_BASE
+    {
+    private:
+      typedef PB_DS_GP_HASH_TRAITS_BASE	       	traits_base;
+      typedef typename traits_base::value_type 	value_type_;
+      typedef typename traits_base::pointer 	pointer_;
+      typedef typename traits_base::const_pointer const_pointer_;
+      typedef typename traits_base::reference 	reference_;
+      typedef typename traits_base::const_reference const_reference_;
+      typedef typename traits_base::comp_hash	comp_hash;
+
+      enum entry_status
+	{
+	  empty_entry_status,
+	  valid_entry_status,
+	  erased_entry_status
+	} __attribute__ ((packed));
+
+      struct entry : public traits_base::stored_data_type
+      {
+	entry_status m_stat;
+      };
+
+      typedef typename _Alloc::template rebind<entry>::other entry_allocator;
+      typedef typename entry_allocator::pointer entry_pointer;
+      typedef typename entry_allocator::const_pointer const_entry_pointer;
+      typedef typename entry_allocator::reference entry_reference;
+      typedef typename entry_allocator::const_reference const_entry_reference;
+      typedef typename entry_allocator::pointer entry_array;
+
+      typedef PB_DS_RANGED_PROBE_FN_C_DEC 	ranged_probe_fn_base;
+
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC 	debug_base;
+#endif
+
+      typedef PB_DS_HASH_EQ_FN_C_DEC 		hash_eq_fn_base;
+      typedef Resize_Policy 			resize_base;
+
+#define PB_DS_GEN_POS typename _Alloc::size_type
+
+#include <ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/point_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/const_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/iterator.hpp>
+
+#undef PB_DS_GEN_POS
+
+    public:
+      typedef _Alloc 				allocator_type;
+      typedef typename _Alloc::size_type 	size_type;
+      typedef typename _Alloc::difference_type 	difference_type;
+      typedef Hash_Fn 				hash_fn;
+      typedef Eq_Fn 				eq_fn;
+      typedef Probe_Fn 				probe_fn;
+      typedef Comb_Probe_Fn 			comb_probe_fn;
+      typedef Resize_Policy 			resize_policy;
+
+      /// Value stores hash, true or false.
+      enum
+	{
+	  store_hash = Store_Hash
+	};
+
+      typedef typename traits_base::key_type 	key_type;
+      typedef typename traits_base::key_pointer key_pointer;
+      typedef typename traits_base::key_const_pointer key_const_pointer;
+      typedef typename traits_base::key_reference key_reference;
+      typedef typename traits_base::key_const_reference key_const_reference;
+      typedef typename traits_base::mapped_type mapped_type;
+      typedef typename traits_base::mapped_pointer mapped_pointer;
+      typedef typename traits_base::mapped_const_pointer mapped_const_pointer;
+      typedef typename traits_base::mapped_reference mapped_reference;
+      typedef typename traits_base::mapped_const_reference mapped_const_reference;
+      typedef typename traits_base::value_type value_type;
+      typedef typename traits_base::pointer pointer;
+      typedef typename traits_base::const_pointer const_pointer;
+      typedef typename traits_base::reference reference;
+      typedef typename traits_base::const_reference const_reference;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef point_iterator_ 			point_iterator;
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+      typedef point_const_iterator_ 		point_iterator;
+#endif
+
+      typedef point_const_iterator_ 		point_const_iterator;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef iterator_ 			iterator;
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+      typedef const_iterator_ 			iterator;
+#endif
+
+      typedef const_iterator_ 			const_iterator;
+
+      PB_DS_GP_HASH_NAME();
+
+      PB_DS_GP_HASH_NAME(const PB_DS_CLASS_C_DEC&);
+
+      PB_DS_GP_HASH_NAME(const Hash_Fn&);
+
+      PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&);
+
+      PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&);
+
+      PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&,
+			 const Probe_Fn&);
+
+      PB_DS_GP_HASH_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&,
+			 const Probe_Fn&, const Resize_Policy&);
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+      virtual
+      ~PB_DS_GP_HASH_NAME();
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      inline size_type
+      size() const;
+
+      inline size_type
+      max_size() const;
+
+      /// True if size() == 0.
+      inline bool
+      empty() const;
+
+      /// Return current hash_fn.
+      Hash_Fn&
+      get_hash_fn();
+
+      /// Return current const hash_fn.
+      const Hash_Fn&
+      get_hash_fn() const;
+
+      /// Return current eq_fn.
+      Eq_Fn&
+      get_eq_fn();
+
+      /// Return current const eq_fn.
+      const Eq_Fn&
+      get_eq_fn() const;
+
+      /// Return current probe_fn.
+      Probe_Fn&
+      get_probe_fn();
+
+      /// Return current const probe_fn.
+      const Probe_Fn&
+      get_probe_fn() const;
+
+      /// Return current comb_probe_fn.
+      Comb_Probe_Fn&
+      get_comb_probe_fn();
+
+      /// Return current const comb_probe_fn.
+      const Comb_Probe_Fn&
+      get_comb_probe_fn() const;
+
+      /// Return current resize_policy.
+      Resize_Policy&
+      get_resize_policy();
+
+      /// Return current const resize_policy.
+      const Resize_Policy&
+      get_resize_policy() const;
+
+      inline std::pair<point_iterator, bool>
+      insert(const_reference r_val)
+      {
+       _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid(__FILE__, __LINE__);)
+	return insert_imp(r_val, traits_base::m_store_extra_indicator);
+      }
+
+      inline mapped_reference
+      operator[](key_const_reference r_key)
+      {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+	return subscript_imp(r_key, traits_base::m_store_extra_indicator);
+#else
+	insert(r_key);
+	return traits_base::s_null_type;
+#endif
+      }
+
+      inline point_iterator
+      find(key_const_reference);
+
+      inline point_const_iterator
+      find(key_const_reference) const;
+
+      inline point_iterator
+      find_end();
+
+      inline point_const_iterator
+      find_end() const;
+
+      inline bool
+      erase(key_const_reference);
+
+      template<typename Pred>
+        inline size_type
+        erase_if(Pred);
+
+      void
+      clear();
+
+      inline iterator
+      begin();
+
+      inline const_iterator
+      begin() const;
+
+      inline iterator
+      end();
+      
+      inline const_iterator
+      end() const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+
+#ifdef PB_DS_HT_MAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    private:
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      friend class iterator_;
+#endif
+
+      friend class const_iterator_;
+
+      void
+      deallocate_all();
+
+      void
+      initialize();
+
+      void
+      erase_all_valid_entries(entry_array, size_type);
+
+      inline bool
+      do_resize_if_needed();
+
+      inline void
+      do_resize_if_needed_no_throw();
+
+      void
+      resize_imp(size_type);
+
+      virtual void
+      do_resize(size_type);
+
+      void
+      resize_imp(entry_array, size_type);
+
+      inline void
+      resize_imp_reassign(entry_pointer, entry_array, false_type);
+
+      inline void
+      resize_imp_reassign(entry_pointer, entry_array, true_type);
+
+      inline size_type
+      find_ins_pos(key_const_reference, false_type);
+
+      inline comp_hash
+      find_ins_pos(key_const_reference, true_type);
+
+      inline std::pair<point_iterator, bool>
+      insert_imp(const_reference, false_type);
+
+      inline std::pair<point_iterator, bool>
+      insert_imp(const_reference, true_type);
+
+      inline pointer
+      insert_new_imp(const_reference r_val, size_type pos)
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status);
+
+	if (do_resize_if_needed())
+	  pos = find_ins_pos(PB_DS_V2F(r_val),
+			     traits_base::m_store_extra_indicator);
+
+	_GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status);
+	entry* const p_e = m_entries + pos;
+	new (&p_e->m_value) value_type(r_val);
+	p_e->m_stat = valid_entry_status;
+	resize_base::notify_inserted(++m_num_used_e);
+
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	return &p_e->m_value;
+      }
+
+      inline pointer
+      insert_new_imp(const_reference r_val, comp_hash& r_pos_hash_pair)
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_entries[r_pos_hash_pair.first].m_stat !=
+			      valid_entry_status);
+
+	if (do_resize_if_needed())
+	  r_pos_hash_pair = find_ins_pos(PB_DS_V2F(r_val),
+					 traits_base::m_store_extra_indicator);
+
+	_GLIBCXX_DEBUG_ASSERT(m_entries[r_pos_hash_pair.first].m_stat !=
+			      valid_entry_status);
+
+	entry* const p_e = m_entries + r_pos_hash_pair.first;
+	new (&p_e->m_value) value_type(r_val);
+	p_e->m_hash = r_pos_hash_pair.second;
+	p_e->m_stat = valid_entry_status;
+
+	resize_base::notify_inserted(++m_num_used_e);
+
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	return &p_e->m_value;
+      }
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      inline mapped_reference
+      subscript_imp(key_const_reference key, false_type)
+      {
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+
+	const size_type pos = find_ins_pos(key,
+					 traits_base::m_store_extra_indicator);
+
+	entry_pointer p_e = &m_entries[pos];
+	if (p_e->m_stat != valid_entry_status)
+	  return insert_new_imp(value_type(key, mapped_type()), pos)->second;
+
+	PB_DS_CHECK_KEY_EXISTS(key)
+	return p_e->m_value.second;
+      }
+
+      inline mapped_reference
+      subscript_imp(key_const_reference key, true_type)
+      {
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+
+	comp_hash pos_hash_pair = find_ins_pos(key,
+					 traits_base::m_store_extra_indicator);
+
+	if (m_entries[pos_hash_pair.first].m_stat != valid_entry_status)
+	  return insert_new_imp(value_type(key, mapped_type()),
+				 pos_hash_pair)->second;
+
+	PB_DS_CHECK_KEY_EXISTS(key)
+	return (m_entries + pos_hash_pair.first)->m_value.second;
+      }
+#endif
+
+      inline pointer
+      find_key_pointer(key_const_reference key, false_type)
+      {
+	const size_type hash = ranged_probe_fn_base::operator()(key);
+	resize_base::notify_find_search_start();
+
+	// Loop until entry is found or until all possible entries accessed.
+	for (size_type i = 0; i < m_num_e; ++i)
+	  {
+	    const size_type pos = ranged_probe_fn_base::operator()(key,
+								   hash, i);
+
+	    entry* const p_e = m_entries + pos;
+	    switch (p_e->m_stat)
+	      {
+	      case empty_entry_status:
+		{
+		  resize_base::notify_find_search_end();
+		  PB_DS_CHECK_KEY_DOES_NOT_EXIST(key)
+		  return 0;
+		}
+		break;
+	      case valid_entry_status:
+		if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), key))
+		  {
+		    resize_base::notify_find_search_end();
+		    PB_DS_CHECK_KEY_EXISTS(key)
+		    return pointer(&p_e->m_value);
+		  }
+		break;
+	      case erased_entry_status:
+		break;
+	      default:
+		_GLIBCXX_DEBUG_ASSERT(0);
+	      };
+
+	    resize_base::notify_find_search_collision();
+	  }
+
+	PB_DS_CHECK_KEY_DOES_NOT_EXIST(key)
+	resize_base::notify_find_search_end();
+	return 0;
+      }
+
+      inline pointer
+      find_key_pointer(key_const_reference key, true_type)
+      {
+	comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(key);
+	resize_base::notify_find_search_start();
+
+	// Loop until entry is found or until all possible entries accessed.
+	for (size_type i = 0; i < m_num_e; ++i)
+	  {
+	    const size_type pos =
+	      ranged_probe_fn_base::operator()(key, pos_hash_pair.second, i);
+
+	    entry* const p_e = m_entries + pos;
+
+	    switch(p_e->m_stat)
+	      {
+	      case empty_entry_status:
+		{
+		  resize_base::notify_find_search_end();
+		  PB_DS_CHECK_KEY_DOES_NOT_EXIST(key)
+		  return 0;
+		}
+		break;
+	      case valid_entry_status:
+		if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
+						p_e->m_hash,
+						key, pos_hash_pair.second))
+		  {
+		    resize_base::notify_find_search_end();
+		    PB_DS_CHECK_KEY_EXISTS(key)
+		    return pointer(&p_e->m_value);
+		  }
+		break;
+	      case erased_entry_status:
+		break;
+	      default:
+		_GLIBCXX_DEBUG_ASSERT(0);
+	      };
+
+	    resize_base::notify_find_search_collision();
+	  }
+
+	PB_DS_CHECK_KEY_DOES_NOT_EXIST(key)
+	resize_base::notify_find_search_end();
+	return 0;
+      }
+
+      inline bool
+      erase_imp(key_const_reference, true_type);
+
+      inline bool
+      erase_imp(key_const_reference, false_type);
+
+      inline void
+      erase_entry(entry_pointer);
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      void
+      inc_it_state(pointer& r_p_value, size_type& r_pos) const
+      { inc_it_state((mapped_const_pointer& )r_p_value, r_pos); }
+#endif
+
+      void
+      inc_it_state(const_pointer& r_p_value, size_type& r_pos) const
+      {
+	_GLIBCXX_DEBUG_ASSERT(r_p_value != 0);
+	for (++r_pos; r_pos < m_num_e; ++r_pos)
+	  {
+	    const_entry_pointer p_e =& m_entries[r_pos];
+	    if (p_e->m_stat == valid_entry_status)
+	      {
+		r_p_value =& p_e->m_value;
+		return;
+	      }
+	  }
+	r_p_value = 0;
+      }
+
+      void
+      get_start_it_state(const_pointer& r_p_value, size_type& r_pos) const
+      {
+	for (r_pos = 0; r_pos < m_num_e; ++r_pos)
+	  {
+	    const_entry_pointer p_e = &m_entries[r_pos];
+	    if (p_e->m_stat == valid_entry_status)
+	      {
+		r_p_value = &p_e->m_value;
+		return;
+	      }
+	  }
+	r_p_value = 0;
+      }
+
+      void
+      get_start_it_state(pointer& r_p_value, size_type& r_pos)
+      {
+	for (r_pos = 0; r_pos < m_num_e; ++r_pos)
+	  {
+	    entry_pointer p_e = &m_entries[r_pos];
+	    if (p_e->m_stat == valid_entry_status)
+	      {
+		r_p_value = &p_e->m_value;
+		return;
+	      }
+	  }
+	r_p_value = 0;
+      }
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_entry_array_valid(const entry_array, false_type,
+			       const char*, int) const;
+
+      void
+      assert_entry_array_valid(const entry_array, true_type,
+			       const char*, int) const;
+#endif
+
+      static entry_allocator 	s_entry_allocator;
+      static iterator 		s_end_it;
+      static const_iterator 	s_const_end_it;
+
+      size_type 		m_num_e;
+      size_type 		m_num_used_e;
+      entry_pointer 		m_entries;
+
+      enum
+	{
+	  store_hash_ok = !Store_Hash
+			  || !is_same<Hash_Fn, __gnu_pbds::null_type>::value
+	};
+
+      PB_DS_STATIC_ASSERT(sth, store_hash_ok);
+    };
+
+#include <ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_HASH_EQ_FN_C_DEC
+#undef PB_DS_RANGED_PROBE_FN_C_DEC
+#undef PB_DS_GP_HASH_TRAITS_BASE
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
+#undef PB_DS_GP_HASH_NAME
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp
new file mode 100644
index 0000000..09d05bf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp
@@ -0,0 +1,58 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/info_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s entire container info related
+ * functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{ return m_num_used_e; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{ return s_entry_allocator.max_size(); }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{ return (size() == 0); }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp
new file mode 100644
index 0000000..c8ed2ec
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp
@@ -0,0 +1,43 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/insert_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s insert related functions.
+ */
+
+#include <ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp>
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..57126d5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s insert related functions,
+ * when the hash value is not stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+find_ins_pos(key_const_reference r_key, false_type)
+{
+  size_type hash = ranged_probe_fn_base::operator()(r_key);
+  size_type i;
+
+  /* The insertion position is initted to a non-legal value to indicate
+   *     that it has not been initted yet.
+   */
+  size_type ins_pos = m_num_e;
+  resize_base::notify_insert_search_start();
+  for (i = 0; i < m_num_e; ++i)
+    {
+      const size_type pos = ranged_probe_fn_base::operator()(r_key, hash, i);
+      _GLIBCXX_DEBUG_ASSERT(pos < m_num_e);
+      entry* const p_e = m_entries + pos;
+      switch(p_e->m_stat)
+        {
+        case empty_entry_status:
+	  {
+            resize_base::notify_insert_search_end();
+	    PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	    return (ins_pos == m_num_e) ? pos : ins_pos;
+	  }
+	  break;
+        case erased_entry_status:
+	  if (ins_pos == m_num_e)
+	    ins_pos = pos;
+	  break;
+        case valid_entry_status:
+	  if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
+            {
+	      resize_base::notify_insert_search_end();
+	      PB_DS_CHECK_KEY_EXISTS(r_key)
+                return pos;
+            }
+	  break;
+        default:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+        };
+
+      resize_base::notify_insert_search_collision();
+    }
+  resize_base::notify_insert_search_end();
+  if (ins_pos == m_num_e)
+    __throw_insert_error();
+  return ins_pos;
+}
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert_imp(const_reference r_val, false_type)
+{
+  key_const_reference r_key = PB_DS_V2F(r_val);
+  const size_type pos = find_ins_pos(r_key, 
+				     traits_base::m_store_extra_indicator);
+
+  if (m_entries[pos].m_stat == valid_entry_status)
+    {
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      return std::make_pair(&(m_entries + pos)->m_value, false);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+  return std::make_pair(insert_new_imp(r_val, pos), true);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..1c3122f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
@@ -0,0 +1,118 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/insert_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s find related functions,
+ * when the hash value is stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::comp_hash
+PB_DS_CLASS_C_DEC::
+find_ins_pos(key_const_reference r_key, true_type)
+{
+  PB_DS_ASSERT_VALID((*this))
+  comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key);
+
+  size_type i;
+
+  /* The insertion position is initted to a non-legal value to indicate
+   *     that it has not been initted yet.
+   */
+  size_type ins_pos = m_num_e;
+  resize_base::notify_insert_search_start();
+  for (i = 0; i < m_num_e; ++i)
+    {
+      const size_type pos = ranged_probe_fn_base::operator()(r_key, pos_hash_pair.second, i);
+
+      entry* const p_e = m_entries + pos;
+      switch(p_e->m_stat)
+        {
+        case empty_entry_status:
+	  {
+            resize_base::notify_insert_search_end();
+	    PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+
+	    return ((ins_pos == m_num_e) ?
+		     std::make_pair(pos, pos_hash_pair.second) :
+		     std::make_pair(ins_pos, pos_hash_pair.second));
+	  }
+	  break;
+        case erased_entry_status:
+	  if (ins_pos == m_num_e)
+	    ins_pos = pos;
+	  break;
+        case valid_entry_status:
+	  if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash,
+					  r_key, pos_hash_pair.second))
+            {
+	      resize_base::notify_insert_search_end();
+	      PB_DS_CHECK_KEY_EXISTS(r_key)
+              return std::make_pair(pos, pos_hash_pair.second);
+            }
+	  break;
+        default:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+        };
+      resize_base::notify_insert_search_collision();
+    }
+  resize_base::notify_insert_search_end();
+  if (ins_pos == m_num_e)
+    __throw_insert_error();
+  return std::make_pair(ins_pos, pos_hash_pair.second);
+}
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert_imp(const_reference r_val, true_type)
+{
+  key_const_reference r_key = PB_DS_V2F(r_val);
+  comp_hash pos_hash_pair = find_ins_pos(r_key, 
+					 traits_base::m_store_extra_indicator);
+
+  _GLIBCXX_DEBUG_ASSERT(pos_hash_pair.first < m_num_e);
+  entry_pointer p_e =& m_entries[pos_hash_pair.first];
+  if (p_e->m_stat == valid_entry_status)
+    {
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      return std::make_pair(&p_e->m_value, false);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+  return std::make_pair(insert_new_imp(r_val, pos_hash_pair), true);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp
new file mode 100644
index 0000000..06089cf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp
@@ -0,0 +1,83 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/iterator_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s iterators related functions, e.g.,
+ * begin().
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::s_end_it;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::s_const_end_it;
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+begin()
+{
+  pointer_ p_value;
+  size_type pos;
+  get_start_it_state(p_value, pos);
+  return iterator(p_value, pos, this);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+end()
+{ return s_end_it; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin() const
+{
+  const_pointer_ p_value;
+  size_type pos;
+  get_start_it_state(p_value, pos);
+  return const_iterator(p_value, pos, this);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end() const
+{ return s_const_end_it; }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp
new file mode 100644
index 0000000..dfc3769
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/policy_access_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s policy agpess
+ * functions.
+ */
+
+PB_DS_CLASS_T_DEC
+Hash_Fn& 
+PB_DS_CLASS_C_DEC::
+get_hash_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Hash_Fn& 
+PB_DS_CLASS_C_DEC::
+get_hash_fn() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Eq_Fn& 
+PB_DS_CLASS_C_DEC::
+get_eq_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Eq_Fn& 
+PB_DS_CLASS_C_DEC::
+get_eq_fn() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Probe_Fn& 
+PB_DS_CLASS_C_DEC::
+get_probe_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Probe_Fn& 
+PB_DS_CLASS_C_DEC::
+get_probe_fn() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Comb_Probe_Fn& 
+PB_DS_CLASS_C_DEC::
+get_comb_probe_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Comb_Probe_Fn& 
+PB_DS_CLASS_C_DEC::
+get_comb_probe_fn() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Resize_Policy& 
+PB_DS_CLASS_C_DEC::
+get_resize_policy()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Resize_Policy& 
+PB_DS_CLASS_C_DEC::
+get_resize_policy() const
+{ return *this; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp
new file mode 100644
index 0000000..fc8e8ad
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp
@@ -0,0 +1,139 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/resize_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s resize related functions.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+do_resize_if_needed()
+{
+  if (!resize_base::is_resize_needed())
+    return false;
+  resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e));
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+do_resize(size_type n)
+{ resize_imp(resize_base::get_nearest_larger_size(n)); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+do_resize_if_needed_no_throw()
+{
+  if (!resize_base::is_resize_needed())
+    return;
+
+  __try
+    {
+      resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e));
+    }
+  __catch(...)
+    { }
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+resize_imp(size_type new_size)
+{
+#ifdef PB_DS_REGRESSION
+  typename _Alloc::group_adjustor adjust(m_num_e);
+#endif 
+
+  if (new_size == m_num_e)
+    return;
+
+  PB_DS_ASSERT_VALID((*this))
+  const size_type old_size = m_num_e;
+  entry_array a_entries_resized = 0;
+
+  // Following line might throw an exception.
+  a_entries_resized = s_entry_allocator.allocate(new_size);
+
+  ranged_probe_fn_base::notify_resized(new_size);
+  m_num_e = new_size;
+
+  for (size_type i = 0; i < m_num_e; ++i)
+    a_entries_resized[i].m_stat = empty_entry_status;
+
+  __try
+    {
+      resize_imp(a_entries_resized, old_size);
+    }
+  __catch(...)
+    {
+      erase_all_valid_entries(a_entries_resized, new_size);
+      m_num_e = old_size;
+      s_entry_allocator.deallocate(a_entries_resized, new_size);
+      ranged_probe_fn_base::notify_resized(old_size);
+      __throw_exception_again;
+    }
+
+  // At this point no exceptions can be thrown.
+  _GLIBCXX_DEBUG_ONLY(assert_entry_array_valid(a_entries_resized,
+					       traits_base::m_store_extra_indicator,
+					       __FILE__, __LINE__);)
+
+  Resize_Policy::notify_resized(new_size);
+  erase_all_valid_entries(m_entries, old_size);
+  s_entry_allocator.deallocate(m_entries, old_size);
+  m_entries = a_entries_resized;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+resize_imp(entry_array a_entries_resized, size_type old_size)
+{
+  for (size_type pos = 0; pos < old_size; ++pos)
+    if (m_entries[pos].m_stat == valid_entry_status)
+      resize_imp_reassign(m_entries + pos, a_entries_resized, 
+			  traits_base::m_store_extra_indicator);
+}
+
+#include <ext/pb_ds/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp>
+#include <ext/pb_ds/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp>
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..46d4f92
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp
@@ -0,0 +1,72 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s resize related functions, when the
+ * hash value is not stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, 
+		    false_type)
+{
+  key_const_reference r_key = PB_DS_V2F(p_e->m_value);
+  size_type hash = ranged_probe_fn_base::operator()(r_key);
+  size_type i;
+  for (i = 0; i < m_num_e; ++i)
+    {
+      const size_type pos = ranged_probe_fn_base::operator()(r_key, hash, i);
+      entry_pointer p_new_e = a_entries_resized + pos;
+      switch(p_new_e->m_stat)
+        {
+        case empty_entry_status:
+	  new (&p_new_e->m_value) value_type(p_e->m_value);
+	  p_new_e->m_stat = valid_entry_status;
+	  return;
+        case erased_entry_status:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+	  break;
+        case valid_entry_status:
+	  break;
+        default:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+        };
+    }
+  __throw_insert_error();
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp
new file mode 100644
index 0000000..40b5e73
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp
@@ -0,0 +1,74 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/resize_store_hash_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s resize related functions, when the
+ * hash value is stored.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, 
+		    true_type)
+{
+  key_const_reference r_key = PB_DS_V2F(p_e->m_value);
+  size_type hash = ranged_probe_fn_base::operator()(r_key, p_e->m_hash);
+
+  size_type i;
+  for (i = 0; i < m_num_e; ++i)
+    {
+      const size_type pos = ranged_probe_fn_base::operator()(r_key, hash, i);
+      entry_pointer p_new_e = a_entries_resized + pos;
+      switch(p_new_e->m_stat)
+        {
+        case empty_entry_status:
+	  new (&p_new_e->m_value) value_type(p_e->m_value);
+	  p_new_e->m_hash = hash;
+	  p_new_e->m_stat = valid_entry_status;
+	  return;
+        case erased_entry_status:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+	  break;
+        case valid_entry_status:
+	  break;
+        default:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+        };
+    }
+  __throw_insert_error();
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp
new file mode 100644
index 0000000..4d804ba
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp
@@ -0,0 +1,74 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file gp_hash_table_map_/trace_fn_imps.hpp
+ * Contains implementations of gp_ht_map_'s trace-mode functions.
+ */
+
+#ifdef PB_DS_HT_MAP_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  std::cerr << static_cast<unsigned long>(m_num_e) << " " <<
+    static_cast<unsigned long>(m_num_used_e) << std::endl;
+
+  for (size_type i = 0; i < m_num_e; ++i)
+    {
+      std::cerr << static_cast<unsigned long>(i) << " ";
+
+      switch(m_entries[i].m_stat)
+        {
+	case empty_entry_status:
+	  std::cerr << "<empty>";
+	  break;
+	case erased_entry_status:
+	  std::cerr << "<erased>";
+	  break;
+	case valid_entry_status:
+	  std::cerr << PB_DS_V2F(m_entries[i].m_value);
+	  break;
+	default:
+	  _GLIBCXX_DEBUG_ASSERT(0);
+	};
+
+      std::cerr << std::endl;
+    }
+}
+
+#endif // #ifdef PB_DS_HT_MAP_TRACE_
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp
new file mode 100644
index 0000000..9e3f313
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp
@@ -0,0 +1,58 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file direct_mask_range_hashing_imp.hpp
+ * Contains a range-hashing policy implementation
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{ mask_based_base::swap(other); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_resized(size_type size)
+{ mask_based_base::notify_resized(size); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+operator()(size_type hash) const
+{ return mask_based_base::range_hash(hash); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp
new file mode 100644
index 0000000..c38ecec
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp
@@ -0,0 +1,58 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file direct_mod_range_hashing_imp.hpp
+ * Contains a range-hashing policy implementation
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{ mod_based_base::swap(other); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_resized(size_type n)
+{ mod_based_base::notify_resized(n); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+operator()(size_type hash) const
+{ return mod_based_base::range_hash(hash); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/linear_probe_fn_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/linear_probe_fn_imp.hpp
new file mode 100644
index 0000000..5055d6a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/linear_probe_fn_imp.hpp
@@ -0,0 +1,53 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file linear_probe_fn_imp.hpp
+ * Contains a probe policy implementation
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{ }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+operator()(size_type i) const
+{
+  return (i);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp
new file mode 100644
index 0000000..b92a3eb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp
@@ -0,0 +1,101 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file mask_based_range_hashing.hpp
+ * Contains a range hashing policy base.
+ */
+
+#ifndef PB_DS_MASK_BASED_RANGE_HASHING_HPP
+#define PB_DS_MASK_BASED_RANGE_HASHING_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Range hashing policy.
+    template<typename Size_Type>
+    class mask_based_range_hashing
+    {
+    protected:
+      typedef Size_Type 	size_type;
+
+      void
+      swap(mask_based_range_hashing& other)
+      { std::swap(m_mask, other.m_mask); }
+
+      void
+      notify_resized(size_type size);
+
+      inline size_type
+      range_hash(size_type hash) const
+      { return size_type(hash & m_mask); }
+
+    private:
+      size_type 		m_mask;
+      const static size_type 	s_num_bits_in_size_type;
+      const static size_type 	s_highest_bit_1;
+    };
+
+    template<typename Size_Type>
+    const typename mask_based_range_hashing<Size_Type>::size_type
+    mask_based_range_hashing<Size_Type>::s_num_bits_in_size_type =
+      sizeof(typename mask_based_range_hashing<Size_Type>::size_type) << 3;
+
+    template<typename Size_Type>
+    const typename mask_based_range_hashing<Size_Type>::size_type mask_based_range_hashing<Size_Type>::s_highest_bit_1 = static_cast<typename mask_based_range_hashing<Size_Type>::size_type>(1) << (s_num_bits_in_size_type - 1);
+
+ 
+    template<typename Size_Type>
+    void
+    mask_based_range_hashing<Size_Type>::
+    notify_resized(size_type size)
+    {
+      size_type i = 0;
+      while (size ^ s_highest_bit_1)
+	{
+	  size <<= 1;
+	  ++i;
+	}
+
+      m_mask = 1;
+      i += 2;
+      while (i++ < s_num_bits_in_size_type)
+        m_mask = (m_mask << 1) ^ 1;
+    }
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mod_based_range_hashing.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mod_based_range_hashing.hpp
new file mode 100644
index 0000000..d1b3dda
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mod_based_range_hashing.hpp
@@ -0,0 +1,74 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file mod_based_range_hashing.hpp
+ * Contains a range hashing policy base.
+ */
+
+#ifndef PB_DS_MOD_BASED_RANGE_HASHING_HPP
+#define PB_DS_MOD_BASED_RANGE_HASHING_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Mod based range hashing.
+    template<typename Size_Type>
+    class mod_based_range_hashing
+    {
+    protected:
+      typedef Size_Type 	size_type;
+
+      void
+      swap(mod_based_range_hashing& other)
+      { std::swap(m_size, other.m_size); }
+
+      void
+      notify_resized(size_type s)
+      { m_size = s; }
+
+      inline size_type
+      range_hash(size_type s) const
+      { return s % m_size; }
+
+    private:
+      size_type m_size;
+    };
+  } // namespace detail
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_MOD_BASED_RANGE_HASHING_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/probe_fn_base.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/probe_fn_base.hpp
new file mode 100644
index 0000000..3cd06e1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/probe_fn_base.hpp
@@ -0,0 +1,60 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file probe_fn_base.hpp
+ * Contains a probe policy base.
+ */
+
+#ifndef PB_DS_PROBE_FN_BASE_HPP
+#define PB_DS_PROBE_FN_BASE_HPP
+
+#include <functional>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Probe functor base.
+    template<typename _Alloc>
+    class probe_fn_base
+    {
+    protected:
+      ~probe_fn_base() { }
+    };
+} // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/quadratic_probe_fn_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/quadratic_probe_fn_imp.hpp
new file mode 100644
index 0000000..4b31646
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/quadratic_probe_fn_imp.hpp
@@ -0,0 +1,53 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file quadratic_probe_fn_imp.hpp
+ * Contains a probe policy implementation
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{ }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+operator()(size_type i) const
+{
+  return (i*  i);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_hash_fn.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_hash_fn.hpp
new file mode 100644
index 0000000..0a3cabe
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_hash_fn.hpp
@@ -0,0 +1,359 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ranged_hash_fn.hpp
+ * Contains a unified ranged hash functor, allowing the hash tables
+ * to deal with a single class for ranged hashing.
+ */
+
+#ifndef PB_DS_RANGED_HASH_FN_HPP
+#define PB_DS_RANGED_HASH_FN_HPP
+
+#include <utility>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Primary template.
+    template<typename Key, typename Hash_Fn, typename _Alloc, 
+	     typename Comb_Hash_Fn, bool Store_Hash>
+    class ranged_hash_fn;
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Hash_Fn, typename _Alloc, \
+	     typename Comb_Hash_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_hash_fn<Key,	Hash_Fn, _Alloc, Comb_Hash_Fn, false>
+
+    /**
+     * Specialization 1
+     * The client supplies a hash function and a ranged hash function,
+     * and requests that hash values not be stored.
+     **/
+    template<typename Key, typename Hash_Fn, typename _Alloc, 
+	     typename Comb_Hash_Fn>
+    class ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false> 
+    : public Hash_Fn, public Comb_Hash_Fn
+    {
+    protected:
+      typedef typename _Alloc::size_type size_type;
+      typedef Hash_Fn hash_fn_base;
+      typedef Comb_Hash_Fn comb_hash_fn_base;
+      typedef typename _Alloc::template rebind< Key>::other key_allocator;
+      typedef typename key_allocator::const_reference key_const_reference;
+
+      ranged_hash_fn(size_type);
+
+      ranged_hash_fn(size_type, const Hash_Fn&);
+
+      ranged_hash_fn(size_type, const Hash_Fn&, const Comb_Hash_Fn&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      void
+      notify_resized(size_type);
+
+      inline size_type
+      operator()(key_const_reference) const;
+    };
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size)
+    { Comb_Hash_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const Hash_Fn& r_hash_fn) 
+    : Hash_Fn(r_hash_fn)
+    { Comb_Hash_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const Hash_Fn& r_hash_fn, 
+		   const Comb_Hash_Fn& r_comb_hash_fn) 
+    : Hash_Fn(r_hash_fn), Comb_Hash_Fn(r_comb_hash_fn)
+    { comb_hash_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    {
+      comb_hash_fn_base::swap(other);
+      std::swap((Hash_Fn& )(*this), (Hash_Fn& )other);
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    notify_resized(size_type size)
+    { comb_hash_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    operator()(key_const_reference r_key) const
+    { return (comb_hash_fn_base::operator()(hash_fn_base::operator()(r_key)));}
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Hash_Fn, typename _Alloc, \
+	     typename Comb_Hash_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_hash_fn<Key,Hash_Fn,	_Alloc, Comb_Hash_Fn, true>
+
+    /**
+     * Specialization 2
+     * The client supplies a hash function and a ranged hash function,
+     * and requests that hash values be stored.
+     **/
+    template<typename Key, typename Hash_Fn, typename _Alloc,
+	     typename Comb_Hash_Fn>
+    class ranged_hash_fn<Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true> 
+    : public Hash_Fn, public Comb_Hash_Fn
+    {
+    protected:
+      typedef typename _Alloc::size_type size_type;
+      typedef std::pair<size_type, size_type> comp_hash;
+      typedef Hash_Fn hash_fn_base;
+      typedef Comb_Hash_Fn comb_hash_fn_base;
+      typedef typename _Alloc::template rebind<Key>::other key_allocator;
+      typedef typename key_allocator::const_reference key_const_reference;
+
+      ranged_hash_fn(size_type);
+
+      ranged_hash_fn(size_type, const Hash_Fn&);
+
+      ranged_hash_fn(size_type, const Hash_Fn&, const Comb_Hash_Fn&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      void
+      notify_resized(size_type);
+
+      inline comp_hash
+      operator()(key_const_reference) const;
+
+      inline comp_hash
+      operator()(key_const_reference, size_type) const;
+    };
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size)
+    { Comb_Hash_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const Hash_Fn& r_hash_fn) :
+      Hash_Fn(r_hash_fn)
+    { Comb_Hash_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const Hash_Fn& r_hash_fn, 
+		   const Comb_Hash_Fn& r_comb_hash_fn) 
+    : Hash_Fn(r_hash_fn), Comb_Hash_Fn(r_comb_hash_fn)
+    { comb_hash_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    {
+      comb_hash_fn_base::swap(other);
+      std::swap((Hash_Fn& )(*this), (Hash_Fn& )other);
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    notify_resized(size_type size)
+    { comb_hash_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::comp_hash
+    PB_DS_CLASS_C_DEC::
+    operator()(key_const_reference r_key) const
+    {
+      const size_type hash = hash_fn_base::operator()(r_key);
+      return std::make_pair(comb_hash_fn_base::operator()(hash), hash);
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::comp_hash
+    PB_DS_CLASS_C_DEC::
+    operator()
+#ifdef _GLIBCXX_DEBUG
+      (key_const_reference r_key, size_type hash) const
+#else 
+      (key_const_reference /*r_key*/, size_type hash) const
+#endif
+    {
+      _GLIBCXX_DEBUG_ASSERT(hash == hash_fn_base::operator()(r_key));
+      return std::make_pair(comb_hash_fn_base::operator()(hash), hash);
+    }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename _Alloc, typename Comb_Hash_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_hash_fn<Key,	null_type, _Alloc, Comb_Hash_Fn, false>
+
+    /**
+     * Specialization 3
+     * The client does not supply a hash function (by specifying
+     * null_type as the Hash_Fn parameter), and requests that hash
+     * values not be stored.
+     **/
+    template<typename Key, typename _Alloc, typename Comb_Hash_Fn>
+    class ranged_hash_fn<Key, null_type, _Alloc, Comb_Hash_Fn, false> 
+    : public Comb_Hash_Fn
+    {
+    protected:
+      typedef typename _Alloc::size_type size_type;
+      typedef Comb_Hash_Fn comb_hash_fn_base;
+
+      ranged_hash_fn(size_type);
+
+      ranged_hash_fn(size_type, const Comb_Hash_Fn&);
+
+      ranged_hash_fn(size_type, const null_type&, const Comb_Hash_Fn&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+    };
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size)
+    { Comb_Hash_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const Comb_Hash_Fn& r_comb_hash_fn) :
+      Comb_Hash_Fn(r_comb_hash_fn)
+    { }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const null_type& r_null_type, 
+		   const Comb_Hash_Fn& r_comb_hash_fn) 
+    : Comb_Hash_Fn(r_comb_hash_fn)
+    { }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    { comb_hash_fn_base::swap(other); }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename _Alloc, typename Comb_Hash_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_hash_fn<Key,	null_type, _Alloc, Comb_Hash_Fn, true>
+
+    /**
+     * Specialization 4
+     * The client does not supply a hash function (by specifying
+     * null_type as the Hash_Fn parameter), and requests that hash
+     * values be stored.
+     **/
+    template<typename Key, typename _Alloc, typename Comb_Hash_Fn>
+    class ranged_hash_fn<Key, null_type, _Alloc, Comb_Hash_Fn, true> 
+    : public Comb_Hash_Fn
+    {
+    protected:
+      typedef typename _Alloc::size_type size_type;
+      typedef Comb_Hash_Fn comb_hash_fn_base;
+
+      ranged_hash_fn(size_type);
+
+      ranged_hash_fn(size_type, const Comb_Hash_Fn&);
+
+      ranged_hash_fn(size_type, const null_type&, const Comb_Hash_Fn&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+    };
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size)
+    { Comb_Hash_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const Comb_Hash_Fn& r_comb_hash_fn) 
+    : Comb_Hash_Fn(r_comb_hash_fn)
+    { }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_hash_fn(size_type size, const null_type& r_null_type, 
+		   const Comb_Hash_Fn& r_comb_hash_fn) 
+    : Comb_Hash_Fn(r_comb_hash_fn)
+    { }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    { comb_hash_fn_base::swap(other); }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp
new file mode 100644
index 0000000..d950d92
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp
@@ -0,0 +1,327 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ranged_probe_fn.hpp
+ * Contains a unified ranged probe functor, allowing the probe tables to deal with
+ *    a single class for ranged probeing.
+ */
+
+#ifndef PB_DS_RANGED_PROBE_FN_HPP
+#define PB_DS_RANGED_PROBE_FN_HPP
+
+#include <utility>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Primary template.
+    template<typename Key, typename Hash_Fn, typename _Alloc,
+	     typename Comb_Probe_Fn, typename Probe_Fn, bool Store_Hash>
+    class ranged_probe_fn;
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Hash_Fn, typename _Alloc, \
+	     typename Comb_Probe_Fn, typename Probe_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_probe_fn<Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false>
+
+    /**
+     * Specialization 1     
+     * The client supplies a probe function and a ranged probe
+     * function, and requests that hash values not be stored.
+     **/
+    template<typename Key, typename Hash_Fn, typename _Alloc,
+	     typename Comb_Probe_Fn, typename Probe_Fn>
+    class ranged_probe_fn<Key, Hash_Fn, _Alloc, Comb_Probe_Fn,
+			  Probe_Fn, false> 
+    : public Hash_Fn, public Comb_Probe_Fn, public Probe_Fn
+    {
+    protected:
+      typedef typename _Alloc::size_type size_type;
+      typedef Comb_Probe_Fn comb_probe_fn_base;
+      typedef Hash_Fn hash_fn_base;
+      typedef Probe_Fn probe_fn_base;
+      typedef typename _Alloc::template rebind<Key>::other key_allocator;
+      typedef typename key_allocator::const_reference key_const_reference;
+
+      ranged_probe_fn(size_type);
+
+      ranged_probe_fn(size_type, const Hash_Fn&);
+
+      ranged_probe_fn(size_type, const Hash_Fn&, const Comb_Probe_Fn&);
+
+      ranged_probe_fn(size_type, const Hash_Fn&, const Comb_Probe_Fn&, 
+		      const Probe_Fn&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      void
+      notify_resized(size_type);
+
+      inline size_type
+      operator()(key_const_reference) const;
+
+      inline size_type
+      operator()(key_const_reference, size_type, size_type) const;
+    };
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size)
+    { Comb_Probe_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn) 
+    : Hash_Fn(r_hash_fn)
+    { Comb_Probe_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, 
+		    const Comb_Probe_Fn& r_comb_probe_fn) 
+    : Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn)
+    { comb_probe_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, 
+		    const Comb_Probe_Fn& r_comb_probe_fn, 
+		    const Probe_Fn& r_probe_fn) 
+    : Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn), Probe_Fn(r_probe_fn)
+    { comb_probe_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    {
+      comb_probe_fn_base::swap(other);
+      std::swap((Hash_Fn& )(*this), (Hash_Fn&)other);
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    notify_resized(size_type size)
+    { comb_probe_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    operator()(key_const_reference r_key) const
+    { return comb_probe_fn_base::operator()(hash_fn_base::operator()(r_key)); }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    operator()(key_const_reference, size_type hash, size_type i) const
+    {
+      return comb_probe_fn_base::operator()(hash + probe_fn_base::operator()(i));
+    }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Hash_Fn, typename _Alloc, \
+	     typename Comb_Probe_Fn, typename Probe_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_probe_fn<Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true>
+
+    /**
+     * Specialization 2- The client supplies a probe function and a ranged
+     *    probe function, and requests that hash values not be stored.
+     **/
+    template<typename Key, typename Hash_Fn, typename _Alloc,
+	     typename Comb_Probe_Fn, typename Probe_Fn>
+    class ranged_probe_fn<Key, Hash_Fn, _Alloc, Comb_Probe_Fn, 
+			  Probe_Fn, true> 
+    : public Hash_Fn, public Comb_Probe_Fn, public Probe_Fn
+    {
+    protected:
+      typedef typename _Alloc::size_type size_type;
+      typedef std::pair<size_type, size_type> comp_hash;
+      typedef Comb_Probe_Fn comb_probe_fn_base;
+      typedef Hash_Fn hash_fn_base;
+      typedef Probe_Fn probe_fn_base;
+      typedef typename _Alloc::template rebind<Key>::other key_allocator;
+      typedef typename key_allocator::const_reference key_const_reference;
+
+      ranged_probe_fn(size_type);
+
+      ranged_probe_fn(size_type, const Hash_Fn&);
+
+      ranged_probe_fn(size_type, const Hash_Fn&, 
+		      const Comb_Probe_Fn&);
+
+      ranged_probe_fn(size_type, const Hash_Fn&, const Comb_Probe_Fn&, 
+		      const Probe_Fn&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      void
+      notify_resized(size_type);
+
+      inline comp_hash
+      operator()(key_const_reference) const;
+
+      inline size_type
+      operator()(key_const_reference, size_type, size_type) const;
+
+      inline size_type
+      operator()(key_const_reference, size_type) const;
+    };
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size)
+    { Comb_Probe_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn) 
+    : Hash_Fn(r_hash_fn)
+    { Comb_Probe_Fn::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, 
+		    const Comb_Probe_Fn& r_comb_probe_fn) 
+    : Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn)
+    { comb_probe_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, 
+		    const Comb_Probe_Fn& r_comb_probe_fn, 
+		    const Probe_Fn& r_probe_fn) 
+    : Hash_Fn(r_hash_fn), Comb_Probe_Fn(r_comb_probe_fn), Probe_Fn(r_probe_fn)
+    { comb_probe_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    {
+      comb_probe_fn_base::swap(other);
+      std::swap((Hash_Fn& )(*this), (Hash_Fn& )other);
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    notify_resized(size_type size)
+    { comb_probe_fn_base::notify_resized(size); }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::comp_hash
+    PB_DS_CLASS_C_DEC::
+    operator()(key_const_reference r_key) const
+    {
+      const size_type hash = hash_fn_base::operator()(r_key);
+      return std::make_pair(comb_probe_fn_base::operator()(hash), hash);
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    operator()(key_const_reference, size_type hash, size_type i) const
+    {
+      return comb_probe_fn_base::operator()(hash + probe_fn_base::operator()(i));
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    operator()
+#ifdef _GLIBCXX_DEBUG
+      (key_const_reference r_key, size_type hash) const
+#else 
+      (key_const_reference /*r_key*/, size_type hash) const
+#endif 
+    {
+      _GLIBCXX_DEBUG_ASSERT(hash == hash_fn_base::operator()(r_key));
+      return hash;
+    }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+    /**
+     * Specialization 3 and 4
+     * The client does not supply a hash function or probe function,
+     * and requests that hash values not be stored.
+     **/
+    template<typename Key, typename _Alloc, typename Comb_Probe_Fn>
+    class ranged_probe_fn<Key, null_type, _Alloc, Comb_Probe_Fn, 
+			  null_type, false> 
+    : public Comb_Probe_Fn
+    {
+    protected:
+      typedef typename _Alloc::size_type size_type;
+      typedef Comb_Probe_Fn comb_probe_fn_base;
+      typedef typename _Alloc::template rebind<Key>::other key_allocator;
+      typedef typename key_allocator::const_reference key_const_reference;
+
+      ranged_probe_fn(size_type size)
+      { Comb_Probe_Fn::notify_resized(size); }
+
+      ranged_probe_fn(size_type, const Comb_Probe_Fn& r_comb_probe_fn)
+      : Comb_Probe_Fn(r_comb_probe_fn)
+      { }
+
+      ranged_probe_fn(size_type, const null_type&, 
+		      const Comb_Probe_Fn& r_comb_probe_fn, 
+		      const null_type&)
+      : Comb_Probe_Fn(r_comb_probe_fn)
+      { }
+
+      void
+      swap(ranged_probe_fn& other)
+      { comb_probe_fn_base::swap(other); }
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp
new file mode 100644
index 0000000..4b62bb0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp
@@ -0,0 +1,68 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_probe_fn.hpp
+ * Contains a sample probe policy.
+ */
+
+#ifndef PB_DS_SAMPLE_PROBE_FN_HPP
+#define PB_DS_SAMPLE_PROBE_FN_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample probe policy.
+  class sample_probe_fn
+  {
+  public:
+    typedef std::size_t size_type;
+
+    /// Default constructor.
+    sample_probe_fn();
+
+    /// Copy constructor.
+    sample_probe_fn(const sample_probe_fn&);
+
+    /// Swaps content.
+    inline void
+    swap(sample_probe_fn&);
+
+  protected:
+    /// Returns the i-th offset from the hash value of some key r_key.
+    inline size_type
+    operator()(key_const_reference r_key, size_type i) const;
+  };
+}
+#endif // #ifndef PB_DS_SAMPLE_PROBE_FN_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp
new file mode 100644
index 0000000..b38baf0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp
@@ -0,0 +1,74 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_range_hashing.hpp
+ * Contains a range hashing policy.
+ */
+
+#ifndef PB_DS_SAMPLE_RANGE_HASHING_HPP
+#define PB_DS_SAMPLE_RANGE_HASHING_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample range-hashing functor.
+  class sample_range_hashing
+  {
+  public:
+    /// Size type.
+    typedef std::size_t size_type;
+
+    /// Default constructor.
+    sample_range_hashing();
+
+    /// Copy constructor.
+    sample_range_hashing(const sample_range_hashing& other);
+
+    /// Swaps content.
+    inline void
+    swap(sample_range_hashing& other);
+
+  protected:
+    /// Notifies the policy object that the container's size has
+    /// changed to argument's size.
+    void
+    notify_resized(size_type);
+
+    /// Transforms the __hash value hash into a ranged-hash value.
+    inline size_type
+    operator()(size_type ) const;
+  };
+}
+#endif // #ifndef PB_DS_SAMPLE_RANGE_HASHING_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp
new file mode 100644
index 0000000..4a51984
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp
@@ -0,0 +1,75 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_ranged_hash_fn.hpp
+ * Contains a ranged hash policy.
+ */
+
+#ifndef PB_DS_SAMPLE_RANGED_HASH_FN_HPP
+#define PB_DS_SAMPLE_RANGED_HASH_FN_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample ranged-hash functor.
+  class sample_ranged_hash_fn
+  {
+  public:
+    typedef std::size_t size_type;
+
+    /// Default constructor.
+    sample_ranged_hash_fn();
+
+    /// Copy constructor.
+    sample_ranged_hash_fn(const sample_ranged_hash_fn&);
+
+    /// Swaps content.
+    inline void
+    swap(sample_ranged_hash_fn&);
+
+  protected:
+
+    /// Notifies the policy object that the container's __size has
+    /// changed to size.
+    void
+    notify_resized(size_type);
+
+    /// Transforms key_const_reference into a position within the table.
+    inline size_type
+    operator()(key_const_reference) const;
+
+  };
+}
+#endif // #ifndef PB_DS_SAMPLE_RANGED_HASH_FN_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp
new file mode 100644
index 0000000..4ec4100
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp
@@ -0,0 +1,77 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_ranged_probe_fn.hpp
+ * Contains a ranged probe policy.
+ */
+
+#ifndef PB_DS_SAMPLE_RANGED_PROBE_FN_HPP
+#define PB_DS_SAMPLE_RANGED_PROBE_FN_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample ranged-probe functor.
+  class sample_ranged_probe_fn
+  {
+  public:
+    typedef std::size_t 	size_type;
+
+    // Default constructor.
+    sample_ranged_probe_fn();
+
+    // Copy constructor.
+    sample_ranged_probe_fn(const sample_ranged_probe_fn&);
+
+    // Swaps content.
+    inline void
+    swap(sample_ranged_probe_fn&);
+
+  protected:
+
+    // Notifies the policy object that the container's __size has
+    // changed to size.
+    void
+    notify_resized(size_type);
+
+    // Transforms the const key reference r_key into the i-th position
+    // within the table. This method is called for each collision within
+    // the probe sequence.
+    inline size_type
+    operator()(key_const_reference, std::size_t, size_type) const;
+
+  };
+}
+#endif // #ifndef PB_DS_SAMPLE_RANGED_PROBE_FN_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp
new file mode 100644
index 0000000..477bcb9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp
@@ -0,0 +1,159 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/const_iterator.hpp
+ * Contains an iterator class returned by the table's const find and insert
+ * methods.
+ */
+
+#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_CONST_ITERATOR_HPP
+#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_CONST_ITERATOR_HPP
+
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/point_const_iterator.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_C_DEC  \
+    left_child_next_sibling_heap_const_iterator_<Node, _Alloc>
+
+#define PB_DS_BASIC_HEAP_CIT_BASE \
+    left_child_next_sibling_heap_node_point_const_iterator_<Node, _Alloc>
+
+    /// Const point-type iterator.
+    template<typename Node, typename _Alloc>
+    class left_child_next_sibling_heap_const_iterator_
+    : public PB_DS_BASIC_HEAP_CIT_BASE
+    {
+    private:
+      typedef PB_DS_BASIC_HEAP_CIT_BASE 	      	base_type;
+      typedef typename base_type::node_pointer		node_pointer;
+
+    public:
+      /// Category.
+      typedef std::forward_iterator_tag 		iterator_category;
+
+      /// Difference type.
+      typedef typename _Alloc::difference_type 		difference_type;
+
+      /// Iterator's value type.
+      typedef typename base_type::value_type 		value_type;
+
+      /// Iterator's pointer type.
+      typedef typename base_type::pointer 		pointer;
+
+      /// Iterator's const pointer type.
+      typedef typename base_type::const_pointer 	const_pointer;
+
+      /// Iterator's reference type.
+      typedef typename base_type::reference 		reference;
+
+      /// Iterator's const reference type.
+      typedef typename base_type::const_reference 	const_reference;
+
+      inline
+      left_child_next_sibling_heap_const_iterator_(node_pointer p_nd)
+      : base_type(p_nd)
+      { }
+
+      /// Default constructor.
+      inline
+      left_child_next_sibling_heap_const_iterator_()
+      { }
+
+      /// Copy constructor.
+      inline
+      left_child_next_sibling_heap_const_iterator_(const PB_DS_CLASS_C_DEC& other) : base_type(other)
+      { }
+
+      /// Compares content to a different iterator object.
+      bool
+      operator==(const PB_DS_CLASS_C_DEC& other) const
+      { return (base_type::m_p_nd == other.m_p_nd); }
+
+      /// Compares content (negatively) to a different iterator object.
+      bool
+      operator!=(const PB_DS_CLASS_C_DEC& other) const
+      { return (base_type::m_p_nd != other.m_p_nd); }
+
+      PB_DS_CLASS_C_DEC&
+      operator++()
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd != 0);
+	inc();
+	return (*this);
+      }
+
+      PB_DS_CLASS_C_DEC
+      operator++(int)
+      {
+	PB_DS_CLASS_C_DEC ret_it(base_type::m_p_nd);
+	operator++();
+	return (ret_it);
+      }
+
+    private:
+      void
+      inc()
+      {
+	if (base_type::m_p_nd->m_p_next_sibling != 0)
+	  {
+	    base_type::m_p_nd = base_type::m_p_nd->m_p_next_sibling;
+	    while (base_type::m_p_nd->m_p_l_child != 0)
+	      base_type::m_p_nd = base_type::m_p_nd->m_p_l_child;
+	    return;
+	  }
+
+	while (true)
+	  {
+	    node_pointer p_next = base_type::m_p_nd;
+	    base_type::m_p_nd = base_type::m_p_nd->m_p_prev_or_parent;
+	    if (base_type::m_p_nd == 0
+		|| base_type::m_p_nd->m_p_l_child == p_next)
+	      return;
+	  }
+      }
+    };
+
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_BASIC_HEAP_CIT_BASE
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..3539f58
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,152 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_allocator
+PB_DS_CLASS_C_DEC::s_node_allocator;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::no_throw_copies_t
+PB_DS_CLASS_C_DEC::s_no_throw_copies_ind;
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+left_child_next_sibling_heap() :
+  m_p_root(0),
+  m_size(0)
+{
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+left_child_next_sibling_heap(const Cmp_Fn& r_cmp_fn) :
+  Cmp_Fn(r_cmp_fn),
+  m_p_root(0),
+  m_size(0)
+{
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+left_child_next_sibling_heap(const PB_DS_CLASS_C_DEC& other) 
+: Cmp_Fn(other), m_p_root(0), m_size(0)
+{
+  m_size = other.m_size;
+  PB_DS_ASSERT_VALID(other)
+  m_p_root = recursive_copy_node(other.m_p_root);
+  m_size = other.m_size;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  value_swap(other);
+  std::swap((Cmp_Fn& )(*this), (Cmp_Fn& )other);
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+value_swap(PB_DS_CLASS_C_DEC& other)
+{
+  std::swap(m_p_root, other.m_p_root);
+  std::swap(m_size, other.m_size);
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~left_child_next_sibling_heap()
+{
+  clear();
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+recursive_copy_node(node_const_pointer p_nd)
+{
+  if (p_nd == 0)
+    return (0);
+
+  node_pointer p_ret = s_node_allocator.allocate(1);
+
+  __try
+    {
+      new (p_ret) node(*p_nd);
+    }
+  __catch(...)
+    {
+      s_node_allocator.deallocate(p_ret, 1);
+      __throw_exception_again;
+    }
+
+  p_ret->m_p_l_child = p_ret->m_p_next_sibling =
+    p_ret->m_p_prev_or_parent = 0;
+
+  __try
+    {
+      p_ret->m_p_l_child = recursive_copy_node(p_nd->m_p_l_child);
+      p_ret->m_p_next_sibling = recursive_copy_node(p_nd->m_p_next_sibling);
+    }
+  __catch(...)
+    {
+      clear_imp(p_ret);
+      __throw_exception_again;
+    }
+
+  if (p_ret->m_p_l_child != 0)
+    p_ret->m_p_l_child->m_p_prev_or_parent = p_ret;
+
+  if (p_ret->m_p_next_sibling != 0)
+    p_ret->m_p_next_sibling->m_p_prev_or_parent =
+      p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd ? p_ret : 0;
+
+  return p_ret;
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp
new file mode 100644
index 0000000..fda9f27
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp
@@ -0,0 +1,137 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/debug_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  PB_DS_DEBUG_VERIFY(m_p_root == 0 || m_p_root->m_p_prev_or_parent == 0);
+
+  if (m_p_root != 0)
+    assert_node_consistent(m_p_root, Single_Link_Roots, __file, __line);
+  assert_size(__file, __line);
+  assert_iterators(__file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_node_consistent(node_const_pointer p_nd, bool single_link,
+		       const char* __file, int __line) const
+{
+  if (p_nd == 0)
+    return;
+
+  assert_node_consistent(p_nd->m_p_l_child, false, __file, __line);
+  assert_node_consistent(p_nd->m_p_next_sibling, single_link, __file, __line);
+
+  if (single_link)
+    PB_DS_DEBUG_VERIFY(p_nd->m_p_prev_or_parent == 0);
+  else if (p_nd->m_p_next_sibling != 0)
+    PB_DS_DEBUG_VERIFY(p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd);
+
+  if (p_nd->m_p_l_child == 0)
+    return;
+
+  node_const_pointer p_child = p_nd->m_p_l_child;
+  while (p_child != 0)
+    {
+      node_const_pointer p_next_child = p_child->m_p_next_sibling;
+      PB_DS_DEBUG_VERIFY(!Cmp_Fn::operator()(p_nd->m_value, p_child->m_value));
+      p_child = p_next_child;
+    }
+  PB_DS_DEBUG_VERIFY(p_nd->m_p_l_child->m_p_prev_or_parent == p_nd);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_iterators(const char* __file, int __line) const
+{
+  PB_DS_DEBUG_VERIFY(std::distance(begin(), end()) == size());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_size(const char* __file, int __line) const
+{
+  PB_DS_DEBUG_VERIFY(size_from_node(m_p_root) == m_size);
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size_under_node(node_const_pointer p_nd)
+{ return 1 + size_from_node(p_nd->m_p_l_child); }
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size_from_node(node_const_pointer p_nd)
+{
+  size_type ret = 0;
+  while (p_nd != 0)
+    {
+      ret += 1 + size_from_node(p_nd->m_p_l_child);
+      p_nd = p_nd->m_p_next_sibling;
+    }
+  return ret;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+degree(node_const_pointer p_nd)
+{
+  size_type ret = 0;
+  node_const_pointer p_child = p_nd->m_p_l_child;
+  while (p_child != 0)
+    {
+      ++ret;
+      p_child = p_child->m_p_next_sibling;
+    }
+  return ret;
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp
new file mode 100644
index 0000000..3106505
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp
@@ -0,0 +1,150 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/erase_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  clear_imp(m_p_root);
+  _GLIBCXX_DEBUG_ASSERT(m_size == 0);
+  m_p_root = 0;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+actual_erase_node(node_pointer p_nd)
+{
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  --m_size;
+  p_nd->~node();
+  s_node_allocator.deallocate(p_nd, 1);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear_imp(node_pointer p_nd)
+{
+  while (p_nd != 0)
+    {
+      clear_imp(p_nd->m_p_l_child);
+      node_pointer p_next = p_nd->m_p_next_sibling;
+      actual_erase_node(p_nd);
+      p_nd = p_next;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+to_linked_list()
+{
+  PB_DS_ASSERT_VALID((*this))
+  node_pointer p_cur = m_p_root;
+  while (p_cur != 0)
+    if (p_cur->m_p_l_child != 0)
+      {
+	node_pointer p_child_next = p_cur->m_p_l_child->m_p_next_sibling;
+	p_cur->m_p_l_child->m_p_next_sibling = p_cur->m_p_next_sibling;
+	p_cur->m_p_next_sibling = p_cur->m_p_l_child;
+	p_cur->m_p_l_child = p_child_next;
+      }
+    else
+      p_cur = p_cur->m_p_next_sibling;
+
+#ifdef _GLIBCXX_DEBUG
+  node_const_pointer p_counter = m_p_root;
+  size_type count = 0;
+  while (p_counter != 0)
+    {
+      ++count;
+      _GLIBCXX_DEBUG_ASSERT(p_counter->m_p_l_child == 0);
+      p_counter = p_counter->m_p_next_sibling;
+    }
+  _GLIBCXX_DEBUG_ASSERT(count == m_size);
+#endif 
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+prune(Pred pred)
+{
+  node_pointer p_cur = m_p_root;
+  m_p_root = 0;
+  node_pointer p_out = 0;
+  while (p_cur != 0)
+    {
+      node_pointer p_next = p_cur->m_p_next_sibling;
+      if (pred(p_cur->m_value))
+        {
+	  p_cur->m_p_next_sibling = p_out;
+	  if (p_out != 0)
+	    p_out->m_p_prev_or_parent = p_cur;
+	  p_out = p_cur;
+        }
+      else
+        {
+	  p_cur->m_p_next_sibling = m_p_root;
+	  if (m_p_root != 0)
+	    m_p_root->m_p_prev_or_parent = p_cur;
+	  m_p_root = p_cur;
+        }
+      p_cur = p_next;
+    }
+  return p_out;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+bubble_to_top(node_pointer p_nd)
+{
+  node_pointer p_parent = parent(p_nd);
+  while (p_parent != 0)
+    {
+      swap_with_parent(p_nd, p_parent);
+      p_parent = parent(p_nd);
+    }
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/info_fn_imps.hpp
new file mode 100644
index 0000000..2a122f8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/info_fn_imps.hpp
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/info_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{
+  return (m_size == 0);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{
+  return (m_size);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{
+  return (s_node_allocator.max_size());
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp
new file mode 100644
index 0000000..8f275c0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp
@@ -0,0 +1,175 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/insert_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+get_new_node_for_insert(const_reference r_val)
+{
+  return get_new_node_for_insert(r_val, s_no_throw_copies_ind);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+get_new_node_for_insert(const_reference r_val, false_type)
+{
+  node_pointer p_new_nd = s_node_allocator.allocate(1);
+
+  cond_dealtor_t cond(p_new_nd);
+
+  new (const_cast<void* >(
+			  static_cast<const void* >(&p_new_nd->m_value)))
+    typename node::value_type(r_val);
+
+  cond.set_no_action();
+
+  ++m_size;
+
+  return (p_new_nd);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+get_new_node_for_insert(const_reference r_val, true_type)
+{
+  node_pointer p_new_nd = s_node_allocator.allocate(1);
+
+  new (const_cast<void* >(
+			  static_cast<const void* >(&p_new_nd->m_value)))
+    typename node::value_type(r_val);
+
+  ++m_size;
+
+  return (p_new_nd);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+make_child_of(node_pointer p_nd, node_pointer p_new_parent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_new_parent != 0);
+
+  p_nd->m_p_next_sibling = p_new_parent->m_p_l_child;
+
+  if (p_new_parent->m_p_l_child != 0)
+    p_new_parent->m_p_l_child->m_p_prev_or_parent = p_nd;
+
+  p_nd->m_p_prev_or_parent = p_new_parent;
+
+  p_new_parent->m_p_l_child = p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+parent(node_pointer p_nd)
+{
+  while (true)
+    {
+      node_pointer p_pot = p_nd->m_p_prev_or_parent;
+
+      if (p_pot == 0 || p_pot->m_p_l_child == p_nd)
+	return p_pot;
+
+      p_nd = p_pot;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+swap_with_parent(node_pointer p_nd, node_pointer p_parent)
+{
+  if (p_parent == m_p_root)
+    m_p_root = p_nd;
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_parent != 0);
+  _GLIBCXX_DEBUG_ASSERT(parent(p_nd) == p_parent);
+
+  const bool nd_direct_child = p_parent->m_p_l_child == p_nd;
+  const bool parent_root = p_parent->m_p_prev_or_parent == 0;
+  const bool parent_direct_child =
+    !parent_root&&  p_parent->m_p_prev_or_parent->m_p_l_child == p_parent;
+
+  std::swap(p_parent->m_p_prev_or_parent, p_nd->m_p_prev_or_parent);
+  std::swap(p_parent->m_p_next_sibling, p_nd->m_p_next_sibling);
+  std::swap(p_parent->m_p_l_child, p_nd->m_p_l_child);
+  std::swap(p_parent->m_metadata, p_nd->m_metadata);
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent != 0);
+
+  if (p_nd->m_p_next_sibling != 0)
+    p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd;
+
+  if (p_parent->m_p_next_sibling != 0)
+    p_parent->m_p_next_sibling->m_p_prev_or_parent = p_parent;
+
+  if (p_parent->m_p_l_child != 0)
+    p_parent->m_p_l_child->m_p_prev_or_parent = p_parent;
+
+  if (parent_direct_child)
+    p_nd->m_p_prev_or_parent->m_p_l_child = p_nd;
+  else if (!parent_root)
+    p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd;
+
+  if (!nd_direct_child)
+    {
+      p_nd->m_p_l_child->m_p_prev_or_parent = p_nd;
+
+      p_parent->m_p_prev_or_parent->m_p_next_sibling = p_parent;
+    }
+  else
+    {
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child == p_nd);
+      _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent == p_parent);
+
+      p_nd->m_p_l_child = p_parent;
+      p_parent->m_p_prev_or_parent = p_nd;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(parent(p_parent) == p_nd);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp
new file mode 100644
index 0000000..55d3eba
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp
@@ -0,0 +1,88 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/iterators_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+begin()
+{
+  node_pointer p_nd = m_p_root;
+
+  if (p_nd == 0)
+    return (iterator(0));
+
+  while (p_nd->m_p_l_child != 0)
+    p_nd = p_nd->m_p_l_child;
+
+  return (iterator(p_nd));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin() const
+{
+  node_pointer p_nd = m_p_root;
+
+  if (p_nd == 0)
+    return (const_iterator(0));
+
+  while (p_nd->m_p_l_child != 0)
+    p_nd = p_nd->m_p_l_child;
+
+  return (const_iterator(p_nd));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+end()
+{
+  return (iterator(0));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end() const
+{
+  return (const_iterator(0));
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp
new file mode 100644
index 0000000..7ced08f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp
@@ -0,0 +1,286 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp
+ * Contains an implementation class for a basic heap.
+ */
+
+#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_HPP
+#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_HPP
+
+/*
+ * Based on CLRS.
+ */
+
+#include <iterator>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/node.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/point_const_iterator.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp>
+#ifdef PB_DS_LC_NS_HEAP_TRACE_
+#include <iostream>
+#endif
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_CLASS_T_DEC \
+    template<typename Value_Type, typename Cmp_Fn, typename Node_Metadata, \
+	     typename _Alloc, bool Single_Link_Roots>
+
+#define PB_DS_CLASS_C_DEC \
+    left_child_next_sibling_heap<Value_Type, Cmp_Fn, Node_Metadata,	\
+				  _Alloc, Single_Link_Roots>
+#else
+#define PB_DS_CLASS_T_DEC \
+    template<typename Value_Type, typename Cmp_Fn, typename Node_Metadata, \
+	     typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    left_child_next_sibling_heap<Value_Type, Cmp_Fn, Node_Metadata, _Alloc>
+#endif
+
+    /// Base class for a basic heap.
+    template<typename Value_Type,
+	     typename Cmp_Fn,
+	     typename Node_Metadata,
+	     typename _Alloc
+#ifdef _GLIBCXX_DEBUG
+	     ,bool Single_Link_Roots>
+#else
+	     >
+#endif
+    class left_child_next_sibling_heap : public Cmp_Fn
+    {
+    protected:
+      typedef
+      typename _Alloc::template rebind<
+      left_child_next_sibling_heap_node_<Value_Type, Node_Metadata,
+					 _Alloc> >::other
+      node_allocator;
+
+      typedef typename node_allocator::value_type     	node;
+      typedef typename node_allocator::pointer 		node_pointer;
+      typedef typename node_allocator::const_pointer	node_const_pointer;
+      typedef Node_Metadata node_metadata;
+      typedef std::pair< node_pointer, node_pointer> 	node_pointer_pair;
+
+    private:
+      typedef cond_dealtor< node, _Alloc> 		cond_dealtor_t;
+
+      enum
+	{
+	  simple_value = is_simple<Value_Type>::value
+	};
+
+      typedef integral_constant<int, simple_value> 	no_throw_copies_t;
+      typedef typename _Alloc::template rebind<Value_Type>	__rebind_v;
+
+    public:
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 	difference_type;
+      typedef Value_Type 				value_type;
+
+      typedef typename __rebind_v::other::pointer 	pointer;
+      typedef typename __rebind_v::other::const_pointer const_pointer;
+      typedef typename __rebind_v::other::reference	reference;
+      typedef typename __rebind_v::other::const_reference const_reference;
+
+      typedef left_child_next_sibling_heap_node_point_const_iterator_<node, _Alloc>
+      point_const_iterator;
+
+      typedef point_const_iterator 			point_iterator;
+
+      typedef left_child_next_sibling_heap_const_iterator_<node, _Alloc>
+      const_iterator;
+
+      typedef const_iterator 				iterator;
+      typedef Cmp_Fn 					cmp_fn;
+      typedef _Alloc 					allocator_type;
+
+      left_child_next_sibling_heap();
+      left_child_next_sibling_heap(const Cmp_Fn&);
+      left_child_next_sibling_heap(const left_child_next_sibling_heap&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      ~left_child_next_sibling_heap();
+
+      inline bool
+      empty() const;
+
+      inline size_type
+      size() const;
+
+      inline size_type
+      max_size() const;
+
+      Cmp_Fn&
+      get_cmp_fn();
+
+      const Cmp_Fn&
+      get_cmp_fn() const;
+
+      inline iterator
+      begin();
+
+      inline const_iterator
+      begin() const;
+
+      inline iterator
+      end();
+
+      inline const_iterator
+      end() const;
+
+      void
+      clear();
+
+#ifdef PB_DS_LC_NS_HEAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    protected:
+      inline node_pointer
+      get_new_node_for_insert(const_reference);
+
+      inline static void
+      make_child_of(node_pointer, node_pointer);
+
+      void
+      value_swap(left_child_next_sibling_heap&);
+
+      inline static node_pointer
+      parent(node_pointer);
+
+      inline void
+      swap_with_parent(node_pointer, node_pointer);
+
+      void
+      bubble_to_top(node_pointer);
+
+      inline void
+      actual_erase_node(node_pointer);
+
+      void
+      clear_imp(node_pointer);
+
+      void
+      to_linked_list();
+
+      template<typename Pred>
+      node_pointer
+      prune(Pred);
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+
+      void
+      assert_node_consistent(node_const_pointer, bool, const char*, int) const;
+
+      static size_type
+      size_under_node(node_const_pointer);
+
+      static size_type
+      degree(node_const_pointer);
+#endif
+
+#ifdef PB_DS_LC_NS_HEAP_TRACE_
+      static void
+      trace_node(node_const_pointer, size_type);
+#endif
+
+    private:
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_iterators(const char*, int) const;
+
+      void
+      assert_size(const char*, int) const;
+
+      static size_type
+      size_from_node(node_const_pointer);
+#endif
+
+      node_pointer
+      recursive_copy_node(node_const_pointer);
+
+      inline node_pointer
+      get_new_node_for_insert(const_reference, false_type);
+
+      inline node_pointer
+      get_new_node_for_insert(const_reference, true_type);
+
+#ifdef PB_DS_LC_NS_HEAP_TRACE_
+      template<typename Metadata_>
+      static void
+      trace_node_metadata(node_const_pointer, type_to_type<Metadata_>);
+
+      static void
+      trace_node_metadata(node_const_pointer, type_to_type<null_type>);
+#endif
+
+      static node_allocator 	s_node_allocator;
+      static no_throw_copies_t 	s_no_throw_copies_ind;
+
+    protected:
+      node_pointer 		m_p_root;
+      size_type 		m_size;
+    };
+
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/info_fn_imps.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/policy_access_fn_imps.hpp>
+
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/node.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/node.hpp
new file mode 100644
index 0000000..27c70a8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/node.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/node.hpp
+ * Contains an implementation struct for this type of heap's node.
+ */
+
+#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NODE_HPP
+#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NODE_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Node.
+    template<typename _Value, typename _Metadata, typename _Alloc>
+    struct left_child_next_sibling_heap_node_
+    {
+    private:
+      typedef left_child_next_sibling_heap_node_<_Value, _Metadata, _Alloc> this_type;
+
+    public:
+      typedef _Value 				value_type;
+      typedef typename _Alloc::size_type 	size_type;
+      typedef _Metadata 			metadata_type;
+
+      typedef typename _Alloc::template rebind<this_type>::other::pointer node_pointer;
+
+      value_type 	m_value;
+      metadata_type 	m_metadata;
+      node_pointer 	m_p_l_child;
+      node_pointer 	m_p_next_sibling;
+      node_pointer 	m_p_prev_or_parent;
+    };
+
+    template<typename _Value, typename _Alloc>
+    struct left_child_next_sibling_heap_node_<_Value, null_type, _Alloc>
+    {
+    private:
+      typedef left_child_next_sibling_heap_node_<_Value, null_type, _Alloc> this_type;
+
+    public:
+      typedef _Value 				value_type;
+      typedef typename _Alloc::size_type 	size_type;
+
+      typedef typename _Alloc::template rebind<this_type>::other::pointer node_pointer;
+
+      value_type 	m_value;
+      node_pointer 	m_p_l_child;
+      node_pointer 	m_p_next_sibling;
+      node_pointer 	m_p_prev_or_parent;
+    };
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NODE_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/point_const_iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/point_const_iterator.hpp
new file mode 100644
index 0000000..8aa9ef9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/point_const_iterator.hpp
@@ -0,0 +1,149 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/point_const_iterator.hpp
+ * Contains an iterator class returned by the table's const find and insert
+ * methods.
+ */
+
+#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_CONST_FIND_ITERATOR_HPP
+#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_CONST_FIND_ITERATOR_HPP
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+
+#define PB_DS_CLASS_T_DEC			\
+    template<typename Node, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    left_child_next_sibling_heap_node_point_const_iterator_<Node, _Alloc>
+
+    /// Const point-type iterator.
+    template<typename Node, typename _Alloc>
+    class left_child_next_sibling_heap_node_point_const_iterator_
+    {
+    protected:
+      typedef typename _Alloc::template rebind<Node>::other::pointer node_pointer;
+
+    public:
+      /// Category.
+      typedef trivial_iterator_tag iterator_category;
+
+      /// Difference type.
+      typedef trivial_iterator_difference_type difference_type;
+
+      /// Iterator's value type.
+      typedef typename Node::value_type value_type;
+
+      /// Iterator's pointer type.
+      typedef
+      typename _Alloc::template rebind<
+	value_type>::other::pointer
+      pointer;
+
+      /// Iterator's const pointer type.
+      typedef
+      typename _Alloc::template rebind<
+	value_type>::other::const_pointer
+      const_pointer;
+
+      /// Iterator's reference type.
+      typedef
+      typename _Alloc::template rebind<
+	value_type>::other::reference
+      reference;
+
+      /// Iterator's const reference type.
+      typedef
+      typename _Alloc::template rebind<
+	value_type>::other::const_reference
+      const_reference;
+
+      inline
+      left_child_next_sibling_heap_node_point_const_iterator_(node_pointer p_nd) : m_p_nd(p_nd)
+      { }
+
+      /// Default constructor.
+      inline
+      left_child_next_sibling_heap_node_point_const_iterator_() : m_p_nd(0)
+      { }
+
+      /// Copy constructor.
+      inline
+      left_child_next_sibling_heap_node_point_const_iterator_(const PB_DS_CLASS_C_DEC& other) : m_p_nd(other.m_p_nd)
+      { }
+
+      /// Access.
+      const_pointer
+      operator->() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
+	return &m_p_nd->m_value;
+      }
+
+      /// Access.
+      const_reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd != 0);
+	return m_p_nd->m_value;
+      }
+
+      /// Compares content to a different iterator object.
+      bool
+      operator==(const PB_DS_CLASS_C_DEC& other) const
+      { return m_p_nd == other.m_p_nd; }
+
+      /// Compares content (negatively) to a different iterator object.
+      bool
+      operator!=(const PB_DS_CLASS_C_DEC& other) const
+      { return m_p_nd != other.m_p_nd; }
+
+      node_pointer m_p_nd;
+    };
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/policy_access_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/policy_access_fn_imps.hpp
new file mode 100644
index 0000000..3b296e7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/policy_access_fn_imps.hpp
@@ -0,0 +1,52 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/policy_access_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn() const
+{ return *this; }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp
new file mode 100644
index 0000000..bb47b56
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file left_child_next_sibling_heap_/trace_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+#ifdef PB_DS_LC_NS_HEAP_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  std::cerr << std::endl;
+  trace_node(m_p_root, 0);
+  std::cerr << std::endl;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace_node(node_const_pointer p_nd, size_type level)
+{
+  while (p_nd != 0)
+    {
+      for (size_type i = 0; i < level; ++i)
+	std::cerr << ' ';
+
+      std::cerr << p_nd <<
+	" prev = " << p_nd->m_p_prev_or_parent <<
+	" next " << p_nd->m_p_next_sibling <<
+	" left = " << p_nd->m_p_l_child << " ";
+
+      trace_node_metadata(p_nd, type_to_type<node_metadata>());
+      std::cerr << p_nd->m_value << std::endl;
+      trace_node(p_nd->m_p_l_child, level + 1);
+      p_nd = p_nd->m_p_next_sibling;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Metadata_>
+void
+PB_DS_CLASS_C_DEC::
+trace_node_metadata(node_const_pointer p_nd, type_to_type<Metadata_>)
+{
+  std::cerr << "(" << p_nd->m_metadata << ") ";
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace_node_metadata(node_const_pointer, type_to_type<null_type>)
+{ }
+
+#endif // #ifdef PB_DS_LC_NS_HEAP_TRACE_
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp
new file mode 100644
index 0000000..c734d4f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp
@@ -0,0 +1,136 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/constructor_destructor_fn_imps.hpp
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::entry_allocator
+PB_DS_CLASS_C_DEC::s_entry_allocator;
+
+PB_DS_CLASS_T_DEC
+Eq_Fn PB_DS_CLASS_C_DEC::s_eq_fn;
+
+PB_DS_CLASS_T_DEC
+null_type PB_DS_CLASS_C_DEC::s_null_type;
+
+PB_DS_CLASS_T_DEC
+Update_Policy PB_DS_CLASS_C_DEC::s_update_policy;
+
+PB_DS_CLASS_T_DEC
+type_to_type<
+  typename PB_DS_CLASS_C_DEC::update_metadata> PB_DS_CLASS_C_DEC::s_metadata_type_indicator;
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    insert(*(first_it++));
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_LU_NAME() : m_p_l(0)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+PB_DS_CLASS_C_DEC::
+PB_DS_LU_NAME(It first_it, It last_it) : m_p_l(0)
+{
+  copy_from_range(first_it, last_it);
+  PB_DS_ASSERT_VALID((*this));
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_LU_NAME(const PB_DS_CLASS_C_DEC& other) :
+m_p_l(0)
+{
+  __try
+    {
+      for (const_iterator it = other.begin(); it != other.end(); ++it)
+	{
+	  entry_pointer p_l = allocate_new_entry(*it,
+				      traits_base::m_no_throw_copies_indicator);
+
+	  p_l->m_p_next = m_p_l;
+	  m_p_l = p_l;
+	}
+    }
+  __catch(...)
+    {
+      deallocate_all();
+      __throw_exception_again;
+    }
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
+  std::swap(m_p_l, other.m_p_l);
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+deallocate_all()
+{
+  entry_pointer p_l = m_p_l;
+  while (p_l != 0)
+    {
+      entry_pointer p_next_l = p_l->m_p_next;
+      actual_erase_entry(p_l);
+      p_l = p_next_l;
+    }
+  m_p_l = 0;
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~PB_DS_LU_NAME()
+{ deallocate_all(); }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp
new file mode 100644
index 0000000..5c99c08
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/debug_fn_imps.hpp
+ * Contains implementations of cc_ht_map_'s debug-mode functions.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  size_type calc_size = 0;
+  for (const_iterator it = begin(); it != end(); ++it)
+    {
+      debug_base::check_key_exists(PB_DS_V2F(*it), __file, __line);
+      ++calc_size;
+    }
+  debug_base::check_size(calc_size, __file, __line);
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/entry_metadata_base.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/entry_metadata_base.hpp
new file mode 100644
index 0000000..29e404b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/entry_metadata_base.hpp
@@ -0,0 +1,60 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/entry_metadata_base.hpp
+ * Contains an implementation for a list update map.
+ */
+
+#ifndef PB_DS_LU_MAP_ENTRY_METADATA_BASE_HPP
+#define PB_DS_LU_MAP_ENTRY_METADATA_BASE_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    template<typename Metadata>
+    struct lu_map_entry_metadata_base
+    {
+      Metadata m_update_metadata;
+    };
+    
+    template<>
+    struct lu_map_entry_metadata_base<null_type>
+    { };  
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp
new file mode 100644
index 0000000..bfe6004
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp
@@ -0,0 +1,134 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/erase_fn_imps.hpp
+ * Contains implementations of lu_map_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase(key_const_reference r_key)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (m_p_l == 0)
+    return false;
+
+  if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value)))
+    {
+      entry_pointer p_next = m_p_l->m_p_next;
+      actual_erase_entry(m_p_l);
+      m_p_l = p_next;
+      return true;
+    }
+
+  entry_pointer p_l = m_p_l;
+  while (p_l->m_p_next != 0)
+    if (s_eq_fn(r_key, PB_DS_V2F(p_l->m_p_next->m_value)))
+      {
+	erase_next(p_l);
+	return true;
+      }
+    else
+      p_l = p_l->m_p_next;
+  return false;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  deallocate_all();
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+  size_type num_ersd = 0;
+  while (m_p_l != 0 && pred(m_p_l->m_value))
+    {
+      entry_pointer p_next = m_p_l->m_p_next;
+      ++num_ersd;
+      actual_erase_entry(m_p_l);
+      m_p_l = p_next;
+    }
+
+  if (m_p_l == 0)
+    return num_ersd;
+
+  entry_pointer p_l = m_p_l;
+  while (p_l->m_p_next != 0)
+    {
+      if (pred(p_l->m_p_next->m_value))
+        {
+	  ++num_ersd;
+	  erase_next(p_l);
+        }
+      else
+	p_l = p_l->m_p_next;
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+  return num_ersd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_next(entry_pointer p_l)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_l != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_l->m_p_next != 0);
+  entry_pointer p_next_l = p_l->m_p_next->m_p_next;
+  actual_erase_entry(p_l->m_p_next);
+  p_l->m_p_next = p_next_l;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+actual_erase_entry(entry_pointer p_l)
+{
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_l->m_value));)
+  p_l->~entry();
+  s_entry_allocator.deallocate(p_l, 1);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp
new file mode 100644
index 0000000..36b84c8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/find_fn_imps.hpp
+ * Contains implementations of lu_map_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::entry_pointer
+PB_DS_CLASS_C_DEC::
+find_imp(key_const_reference r_key) const
+{
+  if (m_p_l == 0)
+    return 0;
+  if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value)))
+    {
+      apply_update(m_p_l, s_metadata_type_indicator);
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      return m_p_l;
+    }
+
+  entry_pointer p_l = m_p_l;
+  while (p_l->m_p_next != 0)
+    {
+      entry_pointer p_next = p_l->m_p_next;
+      if (s_eq_fn(r_key, PB_DS_V2F(p_next->m_value)))
+        {
+	  if (apply_update(p_next, s_metadata_type_indicator))
+            {
+	      p_l->m_p_next = p_next->m_p_next;
+	      p_next->m_p_next = m_p_l;
+	      m_p_l = p_next;
+	      return m_p_l;
+            }
+	  return p_next;
+        }
+      else
+	p_l = p_next;
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+  return 0;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Metadata>
+inline bool
+PB_DS_CLASS_C_DEC::
+apply_update(entry_pointer p_l, type_to_type<Metadata>)
+{ return s_update_policy(p_l->m_update_metadata); }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+apply_update(entry_pointer, type_to_type<null_type>)
+{ return s_update_policy(s_null_type); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp
new file mode 100644
index 0000000..c832214
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/info_fn_imps.hpp
+ * Contains implementations of lu_map_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{ return std::distance(begin(), end()); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{ return s_entry_allocator.max_size(); }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{ return (m_p_l == 0); }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp
new file mode 100644
index 0000000..a24e2c5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp
@@ -0,0 +1,106 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/insert_fn_imps.hpp
+ * Contains implementations of lu_map_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline std::pair<
+  typename PB_DS_CLASS_C_DEC::point_iterator,
+  bool>
+PB_DS_CLASS_C_DEC::
+insert(const_reference r_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+  entry_pointer p_l = find_imp(PB_DS_V2F(r_val));
+
+  if (p_l != 0)
+    {
+      PB_DS_CHECK_KEY_EXISTS(PB_DS_V2F(r_val))
+      return std::make_pair(point_iterator(&p_l->m_value), false);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(PB_DS_V2F(r_val))
+
+  p_l = allocate_new_entry(r_val, traits_base::m_no_throw_copies_indicator);
+  p_l->m_p_next = m_p_l;
+  m_p_l = p_l;
+  PB_DS_ASSERT_VALID((*this))
+  return std::make_pair(point_iterator(&p_l->m_value), true);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::entry_pointer
+PB_DS_CLASS_C_DEC::
+allocate_new_entry(const_reference r_val, false_type)
+{
+  entry_pointer p_l = s_entry_allocator.allocate(1);
+  cond_dealtor_t cond(p_l);
+  new (const_cast<void* >(static_cast<const void* >(&p_l->m_value)))
+    value_type(r_val);
+
+  cond.set_no_action();
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
+  init_entry_metadata(p_l, s_metadata_type_indicator);
+  return p_l;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::entry_pointer
+PB_DS_CLASS_C_DEC::
+allocate_new_entry(const_reference    r_val, true_type)
+{
+  entry_pointer p_l = s_entry_allocator.allocate(1);
+  new (&p_l->m_value) value_type(r_val);
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
+  init_entry_metadata(p_l, s_metadata_type_indicator);
+  return p_l;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Metadata>
+inline void
+PB_DS_CLASS_C_DEC::
+init_entry_metadata(entry_pointer p_l, type_to_type<Metadata>)
+{ new (&p_l->m_update_metadata) Metadata(s_update_policy()); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+init_entry_metadata(entry_pointer, type_to_type<null_type>)
+{ }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp
new file mode 100644
index 0000000..325cce6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp
@@ -0,0 +1,80 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/iterators_fn_imps.hpp
+ * Contains implementations of lu_map_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+begin()
+{
+  if (m_p_l == 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(empty());
+      return end();
+    }
+  return iterator(&m_p_l->m_value, m_p_l, this);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin() const
+{
+  if (m_p_l == 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(empty());
+      return end();
+    }
+  return iterator(&m_p_l->m_value, m_p_l, const_cast<PB_DS_CLASS_C_DEC* >(this));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+end()
+{ return iterator(0, 0, this); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end() const
+{
+  return const_iterator(0, 0, const_cast<PB_DS_CLASS_C_DEC* const>(this));
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp
new file mode 100644
index 0000000..6a200d4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp
@@ -0,0 +1,343 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/lu_map_.hpp
+ * Contains a list update map.
+ */
+
+#include <utility>
+#include <iterator>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+#include <ext/pb_ds/detail/list_update_map_/entry_metadata_base.hpp>
+#include <ext/pb_ds/exception.hpp>
+#ifdef _GLIBCXX_DEBUG
+#include <ext/pb_ds/detail/debug_map_base.hpp>
+#endif
+#ifdef PB_DS_LU_MAP_TRACE_
+#include <iostream>
+#endif
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+#define PB_DS_LU_NAME lu_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+#define PB_DS_LU_NAME lu_set
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Eq_Fn, \
+	     typename _Alloc, typename Update_Policy>
+
+#define PB_DS_CLASS_C_DEC \
+    PB_DS_LU_NAME<Key, Mapped, Eq_Fn, _Alloc, Update_Policy>
+
+#define PB_DS_LU_TRAITS_BASE \
+    types_traits<Key, Mapped, _Alloc, false>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key, Eq_Fn, \
+	      typename _Alloc::template rebind<Key>::other::const_reference>
+#endif
+
+    /// list-based (with updates) associative container.
+    /// Skip to the lu, my darling.
+    template<typename Key,
+	     typename Mapped,
+	     typename Eq_Fn,
+	     typename _Alloc,
+	     typename Update_Policy>
+    class PB_DS_LU_NAME :
+#ifdef _GLIBCXX_DEBUG
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
+#endif
+      public PB_DS_LU_TRAITS_BASE
+    {
+    private:
+      typedef PB_DS_LU_TRAITS_BASE 	       	traits_base;
+
+      struct entry
+     : public lu_map_entry_metadata_base<typename Update_Policy::metadata_type>
+      {
+	typename traits_base::value_type m_value;
+	typename _Alloc::template rebind<entry>::other::pointer m_p_next;
+      };
+
+      typedef typename _Alloc::template rebind<entry>::other entry_allocator;
+      typedef typename entry_allocator::pointer entry_pointer;
+      typedef typename entry_allocator::const_pointer const_entry_pointer;
+      typedef typename entry_allocator::reference entry_reference;
+      typedef typename entry_allocator::const_reference const_entry_reference;
+
+      typedef typename _Alloc::template rebind<entry_pointer>::other entry_pointer_allocator;
+      typedef typename entry_pointer_allocator::pointer entry_pointer_array;
+
+      typedef typename traits_base::value_type value_type_;
+      typedef typename traits_base::pointer pointer_;
+      typedef typename traits_base::const_pointer const_pointer_;
+      typedef typename traits_base::reference reference_;
+      typedef typename traits_base::const_reference const_reference_;
+
+#define PB_DS_GEN_POS entry_pointer
+
+#include <ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/point_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/const_iterator.hpp>
+#include <ext/pb_ds/detail/unordered_iterator/iterator.hpp>
+
+#undef PB_DS_GEN_POS
+
+
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base;
+#endif
+
+      typedef cond_dealtor<entry, _Alloc> cond_dealtor_t;
+
+    public:
+      typedef _Alloc allocator_type;
+      typedef typename _Alloc::size_type size_type;
+      typedef typename _Alloc::difference_type difference_type;
+      typedef Eq_Fn eq_fn;
+      typedef Update_Policy update_policy;
+      typedef typename Update_Policy::metadata_type update_metadata;
+      typedef typename traits_base::key_type key_type;
+      typedef typename traits_base::key_pointer key_pointer;
+      typedef typename traits_base::key_const_pointer key_const_pointer;
+      typedef typename traits_base::key_reference key_reference;
+      typedef typename traits_base::key_const_reference key_const_reference;
+      typedef typename traits_base::mapped_type mapped_type;
+      typedef typename traits_base::mapped_pointer mapped_pointer;
+      typedef typename traits_base::mapped_const_pointer mapped_const_pointer;
+      typedef typename traits_base::mapped_reference mapped_reference;
+      typedef typename traits_base::mapped_const_reference mapped_const_reference;
+      typedef typename traits_base::value_type value_type;
+      typedef typename traits_base::pointer pointer;
+      typedef typename traits_base::const_pointer const_pointer;
+      typedef typename traits_base::reference reference;
+      typedef typename traits_base::const_reference const_reference;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef point_iterator_ 			point_iterator;
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+      typedef point_const_iterator_ 		point_iterator;
+#endif
+
+      typedef point_const_iterator_ 		point_const_iterator;
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef iterator_ 			iterator;
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+      typedef const_iterator_ 			iterator;
+#endif
+
+      typedef const_iterator_ 			const_iterator;
+
+    public:
+      PB_DS_LU_NAME();
+
+      PB_DS_LU_NAME(const PB_DS_CLASS_C_DEC&);
+
+      virtual
+      ~PB_DS_LU_NAME();
+
+      template<typename It>
+      PB_DS_LU_NAME(It, It);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      inline size_type
+      size() const;
+
+      inline size_type
+      max_size() const;
+
+      inline bool
+      empty() const;
+
+      inline mapped_reference
+      operator[](key_const_reference r_key)
+      {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	return insert(std::make_pair(r_key, mapped_type())).first->second;
+#else
+	insert(r_key);
+	return traits_base::s_null_type;
+#endif
+      }
+
+      inline std::pair<point_iterator, bool>
+      insert(const_reference);
+
+      inline point_iterator
+      find(key_const_reference r_key)
+      {
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	entry_pointer p_e = find_imp(r_key);
+	return point_iterator(p_e == 0 ? 0: &p_e->m_value);
+      }
+
+      inline point_const_iterator
+      find(key_const_reference r_key) const
+      {
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	entry_pointer p_e = find_imp(r_key);
+	return point_const_iterator(p_e == 0 ? 0: &p_e->m_value);
+      }
+
+      inline bool
+      erase(key_const_reference);
+
+      template<typename Pred>
+      inline size_type
+      erase_if(Pred);
+
+      void
+      clear();
+
+      inline iterator
+      begin();
+
+      inline const_iterator
+      begin() const;
+
+      inline iterator
+      end();
+
+      inline const_iterator
+      end() const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char* file, int line) const;
+#endif
+
+#ifdef PB_DS_LU_MAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    protected:
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+    private:
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      friend class iterator_;
+#endif
+
+      friend class const_iterator_;
+
+      inline entry_pointer
+      allocate_new_entry(const_reference, false_type);
+
+      inline entry_pointer
+      allocate_new_entry(const_reference, true_type);
+
+      template<typename Metadata>
+      inline static void
+      init_entry_metadata(entry_pointer, type_to_type<Metadata>);
+
+      inline static void
+      init_entry_metadata(entry_pointer, type_to_type<null_type>);
+
+      void
+      deallocate_all();
+
+      void
+      erase_next(entry_pointer);
+
+      void
+      actual_erase_entry(entry_pointer);
+
+      void
+      inc_it_state(const_pointer& r_p_value, entry_pointer& r_pos) const
+      {
+	r_pos = r_pos->m_p_next;
+	r_p_value = (r_pos == 0) ? 0 : &r_pos->m_value;
+      }
+
+      template<typename Metadata>
+      inline static bool
+      apply_update(entry_pointer, type_to_type<Metadata>);
+
+      inline static bool
+      apply_update(entry_pointer, type_to_type<null_type>);
+
+      inline entry_pointer
+      find_imp(key_const_reference) const;
+
+      static entry_allocator 			s_entry_allocator;
+      static Eq_Fn 				s_eq_fn;
+      static Update_Policy 			s_update_policy;
+      static type_to_type<update_metadata> 	s_metadata_type_indicator;
+      static null_type 				s_null_type;
+
+      mutable entry_pointer 			m_p_l;
+    };
+
+#include <ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp>
+#include <ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp>
+#include <ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_LU_TRAITS_BASE
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
+#undef PB_DS_LU_NAME
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp
new file mode 100644
index 0000000..208dafb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp
@@ -0,0 +1,59 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_map_/trace_fn_imps.hpp
+ * Contains implementations of lu_map_.
+ */
+
+#ifdef PB_DS_LU_MAP_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  std::cerr << m_p_l << std::endl << std::endl;
+  const_entry_pointer p_l = m_p_l;
+  while (p_l != 0)
+    {
+      std::cerr << PB_DS_V2F(p_l->m_value) << std::endl;
+      p_l = p_l->m_p_next;
+    }
+  std::cerr << std::endl;
+}
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/lu_counter_metadata.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/lu_counter_metadata.hpp
new file mode 100644
index 0000000..47f386c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/lu_counter_metadata.hpp
@@ -0,0 +1,87 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file lu_counter_metadata.hpp
+ * Contains implementation of a lu counter policy's metadata.
+ */
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    template<typename Size_Type>
+      class lu_counter_policy_base;
+
+    /// A list-update metadata type that moves elements to the front of
+    /// the list based on the counter algorithm.
+    template<typename Size_Type = std::size_t>
+      class lu_counter_metadata
+      {
+      public:
+	typedef Size_Type 	size_type;
+
+      private:
+	lu_counter_metadata(size_type init_count) : m_count(init_count)
+	{ }
+
+	friend class lu_counter_policy_base<size_type>;
+
+	mutable size_type 	m_count;
+    };
+
+    /// Base class for list-update counter policy.
+    template<typename Size_Type>
+      class lu_counter_policy_base
+      {
+      protected:
+	typedef Size_Type 	size_type;
+
+	lu_counter_metadata<size_type>
+	operator()(size_type max_size) const
+	{ return lu_counter_metadata<Size_Type>(std::rand() % max_size); }
+
+	template<typename Metadata_Reference>
+	bool
+	operator()(Metadata_Reference r_data, size_type m_max_count) const
+	{
+	  if (++r_data.m_count != m_max_count)
+	    return false;
+	  r_data.m_count = 0;
+	  return true;
+	}
+      };
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/sample_update_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/sample_update_policy.hpp
new file mode 100644
index 0000000..170e29b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/sample_update_policy.hpp
@@ -0,0 +1,76 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_update_policy.hpp
+ * Contains a sample policy for list update containers.
+ */
+
+#ifndef PB_DS_SAMPLE_UPDATE_POLICY_HPP
+#define PB_DS_SAMPLE_UPDATE_POLICY_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample list-update policy.
+  struct sample_update_policy
+  {
+    /// Default constructor.
+    sample_update_policy();
+
+    /// Copy constructor.
+    sample_update_policy(const sample_update_policy&);
+
+    /// Swaps content.
+    inline void
+    swap(sample_update_policy& other);
+
+  protected:
+    /// Metadata on which this functor operates.
+    typedef some_metadata_type metadata_type;
+
+    /// Creates a metadata object.
+    metadata_type
+    operator()() const;
+
+    /// Decides whether a metadata object should be moved to the front
+    /// of the list. A list-update based containers object will call
+    /// this method to decide whether to move a node to the front of
+    /// the list. The method shoule return true if the node should be
+    /// moved to the front of the list.
+    bool
+    operator()(metadata_reference) const;
+  };
+}
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..cb9c998
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,257 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::value_allocator
+PB_DS_CLASS_C_DEC::s_value_alloc;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::metadata_allocator
+PB_DS_CLASS_C_DEC::s_metadata_alloc;
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_OV_TREE_NAME() :
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
+  m_size(0)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_OV_TREE_NAME(const Cmp_Fn& r_cmp_fn) :
+  cmp_fn(r_cmp_fn),
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
+  m_size(0)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_OV_TREE_NAME(const Cmp_Fn& r_cmp_fn, const node_update& r_nodeu) :
+  cmp_fn(r_cmp_fn),
+  node_update(r_nodeu),
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
+  m_size(0)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_OV_TREE_NAME(const PB_DS_CLASS_C_DEC& other) :
+#ifdef PB_DS_TREE_TRACE
+  trace_base(other),
+#endif
+  cmp_fn(other),
+  node_update(other),
+  m_a_values(0),
+  m_a_metadata(0),
+  m_end_it(0),
+  m_size(0)
+{
+  copy_from_ordered_range(other.begin(), other.end());
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+inline void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+  typedef std::map<key_type, mapped_type, Cmp_Fn,
+		   typename _Alloc::template rebind<value_type>::other>
+    map_type;
+#else
+  typedef std::set<key_type, Cmp_Fn,
+		   typename _Alloc::template rebind<Key>::other>
+    map_type;
+#endif
+
+  map_type m(first_it, last_it);
+  copy_from_ordered_range(m.begin(), m.end());
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_ordered_range(It first_it, It last_it)
+{
+  const size_type len = std::distance(first_it, last_it);
+  if (len == 0)
+    return;
+
+  value_vector a_values = s_value_alloc.allocate(len);
+  iterator target_it = a_values;
+  It source_it = first_it;
+  It source_end_it = last_it;
+
+  cond_dtor<size_type> cd(a_values, target_it, len);
+  while (source_it != source_end_it)
+    {
+      void* __v = const_cast<void*>(static_cast<const void*>(target_it));
+      new (__v) value_type(*source_it++);
+      ++target_it;
+    }
+
+  reallocate_metadata((node_update*)this, len);
+  cd.set_no_action();
+  m_a_values = a_values;
+  m_size = len;
+  m_end_it = m_a_values + m_size;
+  update(PB_DS_node_begin_imp(), (node_update*)this);
+
+#ifdef _GLIBCXX_DEBUG
+  for (const_iterator dbg_it = m_a_values; dbg_it != m_end_it; ++dbg_it)
+    debug_base::insert_new(PB_DS_V2F(*dbg_it));
+#endif
+}
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_ordered_range(It first_it, It last_it, It other_first_it,
+			It other_last_it)
+{
+  clear();
+  const size_type len = std::distance(first_it, last_it)
+    			 + std::distance(other_first_it, other_last_it);
+
+  value_vector a_values = s_value_alloc.allocate(len);
+
+  iterator target_it = a_values;
+  It source_it = first_it;
+  It source_end_it = last_it;
+
+  cond_dtor<size_type> cd(a_values, target_it, len);
+  while (source_it != source_end_it)
+    {
+      new (const_cast<void* >(static_cast<const void* >(target_it)))
+	value_type(*source_it++);
+      ++target_it;
+    }
+
+  source_it = other_first_it;
+  source_end_it = other_last_it;
+
+  while (source_it != source_end_it)
+    {
+      new (const_cast<void* >(static_cast<const void* >(target_it)))
+	value_type(*source_it++);
+      ++target_it;
+    }
+
+  reallocate_metadata((node_update* )this, len);
+  cd.set_no_action();
+  m_a_values = a_values;
+  m_size = len;
+  m_end_it = m_a_values + m_size;
+  update(PB_DS_node_begin_imp(), (node_update* )this);
+
+#ifdef _GLIBCXX_DEBUG
+  for (const_iterator dbg_it = m_a_values; dbg_it != m_end_it; ++dbg_it)
+    debug_base::insert_new(PB_DS_V2F(*dbg_it));
+#endif
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  value_swap(other);
+  std::swap(static_cast<cmp_fn&>(*this),
+	    static_cast<cmp_fn&>(other));
+  std::swap(static_cast<traits_base&>(*this),
+	    static_cast<traits_base&>(other));
+  PB_DS_ASSERT_VALID(other)
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+value_swap(PB_DS_CLASS_C_DEC& other)
+{
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
+  std::swap(m_a_values, other.m_a_values);
+  std::swap(m_a_metadata, other.m_a_metadata);
+  std::swap(m_size, other.m_size);
+  std::swap(m_end_it, other.m_end_it);
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~PB_DS_OV_TREE_NAME()
+{
+  PB_DS_ASSERT_VALID((*this))
+  cond_dtor<size_type> cd(m_a_values, m_end_it, m_size);
+  reallocate_metadata((node_update*)this, 0);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+update(node_iterator, null_node_update_pointer)
+{ }
+
+PB_DS_CLASS_T_DEC
+template<typename Node_Update>
+void
+PB_DS_CLASS_C_DEC::
+update(node_iterator nd_it, Node_Update* p_update)
+{
+  node_const_iterator end_it = PB_DS_node_end_imp();
+  if (nd_it != end_it)
+    {
+      update(nd_it.get_l_child(), p_update);
+      update(nd_it.get_r_child(), p_update);
+      node_update::operator()(nd_it, end_it);
+    }
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp
new file mode 100644
index 0000000..8056876
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp
@@ -0,0 +1,79 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/debug_fn_imps.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  if (m_a_values == 0 || m_end_it == 0 || m_size == 0)
+    PB_DS_DEBUG_VERIFY(m_a_values == 0 &&  m_end_it == 0 && m_size == 0);
+
+  assert_iterators(__file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_iterators(const char* __file, int __line) const
+{
+  debug_base::check_size(m_size, __file, __line);
+  size_type iterated_num = 0;
+  const_iterator prev_it = end();
+  PB_DS_DEBUG_VERIFY(m_end_it == m_a_values + m_size);
+  for (const_iterator it = begin(); it != end(); ++it)
+    {
+      ++iterated_num;
+      debug_base::check_key_exists(PB_DS_V2F(*it), __file, __line);
+      PB_DS_DEBUG_VERIFY(lower_bound(PB_DS_V2F(*it)) == it);
+      const_iterator upper_bound_it = upper_bound(PB_DS_V2F(*it));
+      --upper_bound_it;
+      PB_DS_DEBUG_VERIFY(upper_bound_it == it);
+      if (prev_it != end())
+	PB_DS_DEBUG_VERIFY(Cmp_Fn::operator()(PB_DS_V2F(*prev_it),
+					      PB_DS_V2F(*it)));
+      prev_it = it;
+    }
+  PB_DS_DEBUG_VERIFY(iterated_num == m_size);
+}
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp
new file mode 100644
index 0000000..42d978b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp
@@ -0,0 +1,191 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/erase_fn_imps.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (m_size == 0)
+    {
+      return;
+    }
+  else
+    {
+      reallocate_metadata((node_update* )this, 0);
+      cond_dtor<size_type> cd(m_a_values, m_end_it, m_size);
+    }
+
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
+  m_a_values = 0;
+  m_size = 0;
+  m_end_it = m_a_values;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+#ifdef PB_DS_REGRESSION
+    typename _Alloc::group_adjustor adjust(m_size);
+#endif
+
+  size_type new_size = 0;
+  size_type num_val_ersd = 0;
+
+  for (iterator source_it = begin(); source_it != m_end_it; ++source_it)
+    if (!pred(*source_it))
+      ++new_size;
+    else
+      ++num_val_ersd;
+
+  if (new_size == 0)
+    {
+      clear();
+      return num_val_ersd;
+    }
+
+  value_vector a_new_values = s_value_alloc.allocate(new_size);
+  iterator target_it = a_new_values;
+  cond_dtor<size_type> cd(a_new_values, target_it, new_size);
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear());
+  for (iterator source_it = begin(); source_it != m_end_it; ++source_it)
+    {
+      if (!pred(*source_it))
+	{
+	  new (const_cast<void*>(static_cast<const void*>(target_it)))
+	    value_type(*source_it);
+
+	  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(*source_it)));
+	  ++target_it;
+	}
+    }
+
+  reallocate_metadata((node_update*)this, new_size);
+  cd.set_no_action();
+
+  {
+    cond_dtor<size_type> cd1(m_a_values, m_end_it, m_size);
+  }
+
+  m_a_values = a_new_values;
+  m_size = new_size;
+  m_end_it = target_it;
+  update(node_begin(), (node_update*)this);
+  PB_DS_ASSERT_VALID((*this))
+  return num_val_ersd;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+It
+PB_DS_CLASS_C_DEC::
+erase_imp(It it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (it == end())
+    return end();
+
+  PB_DS_CHECK_KEY_EXISTS(PB_DS_V2F(*it))
+
+#ifdef PB_DS_REGRESSION
+    typename _Alloc::group_adjustor adjust(m_size);
+#endif
+
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  value_vector a_values = s_value_alloc.allocate(m_size - 1);
+  iterator source_it = begin();
+  iterator source_end_it = end();
+  iterator target_it = a_values;
+  iterator ret_it = end();
+
+  cond_dtor<size_type> cd(a_values, target_it, m_size - 1);
+
+  _GLIBCXX_DEBUG_ONLY(size_type cnt = 0;)
+
+  while (source_it != source_end_it)
+    {
+      if (source_it != it)
+	{
+	  _GLIBCXX_DEBUG_ONLY(++cnt;)
+	  _GLIBCXX_DEBUG_ASSERT(cnt != m_size);
+	  new (const_cast<void*>(static_cast<const void*>(target_it)))
+	      value_type(*source_it);
+
+	  ++target_it;
+	}
+      else
+	ret_it = target_it;
+    ++source_it;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  reallocate_metadata((node_update*)this, m_size - 1);
+  cd.set_no_action();
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(*it));)
+  {
+    cond_dtor<size_type> cd1(m_a_values, m_end_it, m_size);
+  }
+
+  m_a_values = a_values;
+  --m_size;
+  m_end_it = m_a_values + m_size;
+  update(node_begin(), (node_update*)this);
+  PB_DS_ASSERT_VALID((*this))
+  return It(ret_it);
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase(key_const_reference r_key)
+{
+  point_iterator it = find(r_key);
+  if (it == end())
+    return false;
+  erase(it);
+  return true;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/info_fn_imps.hpp
new file mode 100644
index 0000000..fbade74
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/info_fn_imps.hpp
@@ -0,0 +1,60 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/info_fn_imps.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{
+  PB_DS_ASSERT_VALID((*this))
+  return m_size;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{ return s_value_alloc.max_size(); }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{ return size() == 0; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp
new file mode 100644
index 0000000..2754898
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/insert_fn_imps.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+reallocate_metadata(null_node_update_pointer, size_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+template<typename Node_Update_>
+void
+PB_DS_CLASS_C_DEC::
+reallocate_metadata(Node_Update_* , size_type new_size)
+{
+  metadata_pointer a_new_metadata_vec =(new_size == 0) ? 0 : s_metadata_alloc.allocate(new_size);
+
+  if (m_a_metadata != 0)
+    {
+      for (size_type i = 0; i < m_size; ++i)
+	m_a_metadata[i].~metadata_type();
+      s_metadata_alloc.deallocate(m_a_metadata, m_size);
+    }
+  std::swap(m_a_metadata, a_new_metadata_vec);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp
new file mode 100644
index 0000000..87ba113
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/iterators_fn_imps.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+node_begin() const
+{ return PB_DS_node_begin_imp(); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+node_end() const
+{ return PB_DS_node_end_imp(); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+node_begin()
+{ return PB_DS_node_begin_imp(); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+node_end()
+{ return PB_DS_node_end_imp(); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+PB_DS_node_begin_imp() const
+{
+  return node_const_iterator(const_cast<pointer>(mid_pointer(begin(), end())),
+			      const_cast<pointer>(begin()),
+			      const_cast<pointer>(end()),(m_a_metadata == 0)?
+			      0 :
+			      mid_pointer(m_a_metadata, m_a_metadata + m_size));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+PB_DS_node_end_imp() const
+{
+  return node_const_iterator(end(), end(), end(),
+		     (m_a_metadata == 0) ? 0 : m_a_metadata + m_size);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+PB_DS_node_begin_imp()
+{
+  return node_iterator(mid_pointer(begin(), end()), begin(), end(),
+		       (m_a_metadata == 0) ? 0 : mid_pointer(m_a_metadata, m_a_metadata + m_size));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+PB_DS_node_end_imp()
+{
+  return node_iterator(end(), end(),
+		  end(),(m_a_metadata == 0) ? 0 : m_a_metadata + m_size);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp
new file mode 100644
index 0000000..adbb345
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp
@@ -0,0 +1,291 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/node_iterators.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+#ifndef PB_DS_OV_TREE_NODE_ITERATORS_HPP
+#define PB_DS_OV_TREE_NODE_ITERATORS_HPP
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_OV_TREE_CONST_NODE_ITERATOR_C_DEC	\
+    ov_tree_node_const_it_<Value_Type, Metadata_Type, _Alloc>
+
+    /// Const node reference.
+    template<typename Value_Type, typename Metadata_Type, typename _Alloc>
+    class ov_tree_node_const_it_
+    {
+
+    protected:
+      typedef
+      typename _Alloc::template rebind<
+      Value_Type>::other::pointer
+      pointer;
+
+      typedef
+      typename _Alloc::template rebind<
+	Value_Type>::other::const_pointer
+      const_pointer;
+
+      typedef
+      typename _Alloc::template rebind<
+	Metadata_Type>::other::const_pointer
+      const_metadata_pointer;
+
+      typedef PB_DS_OV_TREE_CONST_NODE_ITERATOR_C_DEC this_type;
+
+    protected:
+
+      template<typename Ptr>
+      inline static Ptr
+      mid_pointer(Ptr p_begin, Ptr p_end)
+      {
+	_GLIBCXX_DEBUG_ASSERT(p_end >= p_begin);
+	return (p_begin + (p_end - p_begin) / 2);
+      }
+
+    public:
+
+      typedef trivial_iterator_tag iterator_category;
+
+      typedef trivial_iterator_difference_type difference_type;
+
+      typedef
+      typename _Alloc::template rebind<
+	Value_Type>::other::const_pointer
+      value_type;
+
+      typedef
+      typename _Alloc::template rebind<
+	typename remove_const<
+	Value_Type>::type>::other::const_pointer
+      reference;
+
+      typedef
+      typename _Alloc::template rebind<
+	typename remove_const<
+	Value_Type>::type>::other::const_pointer
+      const_reference;
+
+      typedef Metadata_Type metadata_type;
+
+      typedef
+      typename _Alloc::template rebind<
+	metadata_type>::other::const_reference
+      metadata_const_reference;
+
+    public:
+      inline
+      ov_tree_node_const_it_(const_pointer p_nd = 0,  const_pointer p_begin_nd = 0,  const_pointer p_end_nd = 0,  const_metadata_pointer p_metadata = 0) : m_p_value(const_cast<pointer>(p_nd)), m_p_begin_value(const_cast<pointer>(p_begin_nd)), m_p_end_value(const_cast<pointer>(p_end_nd)), m_p_metadata(p_metadata)
+      { }
+
+      inline const_reference
+      operator*() const
+      { return m_p_value; }
+
+      inline metadata_const_reference
+      get_metadata() const
+      {
+	enum
+	  {
+	    has_metadata = !is_same<Metadata_Type, null_type>::value
+	  };
+
+	PB_DS_STATIC_ASSERT(should_have_metadata, has_metadata);
+	_GLIBCXX_DEBUG_ASSERT(m_p_metadata != 0);
+	return *m_p_metadata;
+      }
+
+      /// Returns the node iterator associated with the left node.
+      inline this_type
+      get_l_child() const
+      {
+	if (m_p_begin_value == m_p_value)
+	  return (this_type(m_p_begin_value, m_p_begin_value, m_p_begin_value));
+
+	const_metadata_pointer p_begin_metadata =
+	  m_p_metadata - (m_p_value - m_p_begin_value);
+
+	return (this_type(mid_pointer(m_p_begin_value, m_p_value),
+			  m_p_begin_value,
+			  m_p_value,
+			  mid_pointer(p_begin_metadata, m_p_metadata)));
+      }
+
+      /// Returns the node iterator associated with the right node.
+      inline this_type
+      get_r_child() const
+      {
+	if (m_p_value == m_p_end_value)
+	  return (this_type(m_p_end_value, m_p_end_value, m_p_end_value));
+
+	const_metadata_pointer p_end_metadata =
+	  m_p_metadata + (m_p_end_value - m_p_value);
+
+	return (this_type(mid_pointer(m_p_value + 1, m_p_end_value),
+			  m_p_value + 1,
+			  m_p_end_value,(m_p_metadata == 0) ?
+			  0 : mid_pointer(m_p_metadata + 1, p_end_metadata)));
+      }
+
+      inline bool
+      operator==(const this_type& other) const
+      {
+	const bool is_end = m_p_begin_value == m_p_end_value;
+	const bool is_other_end = other.m_p_begin_value == other.m_p_end_value;
+
+	if (is_end)
+	  return (is_other_end);
+
+	if (is_other_end)
+	  return (is_end);
+
+	return m_p_value == other.m_p_value;
+      }
+
+      inline bool
+      operator!=(const this_type& other) const
+      { return !operator==(other); }
+
+    public:
+      pointer m_p_value;
+      pointer m_p_begin_value;
+      pointer m_p_end_value;
+
+      const_metadata_pointer m_p_metadata;
+    };
+
+#define PB_DS_OV_TREE_NODE_ITERATOR_C_DEC \
+    ov_tree_node_it_<Value_Type, Metadata_Type, _Alloc>
+
+    /// Node reference.
+    template<typename Value_Type, typename Metadata_Type, typename _Alloc>
+    class ov_tree_node_it_ : public PB_DS_OV_TREE_CONST_NODE_ITERATOR_C_DEC
+    {
+    private:
+      typedef PB_DS_OV_TREE_NODE_ITERATOR_C_DEC this_type;
+
+      typedef PB_DS_OV_TREE_CONST_NODE_ITERATOR_C_DEC base_type;
+
+      typedef typename base_type::pointer pointer;
+
+      typedef typename base_type::const_pointer const_pointer;
+
+      typedef
+      typename base_type::const_metadata_pointer
+      const_metadata_pointer;
+
+    public:
+      typedef trivial_iterator_tag iterator_category;
+
+      typedef trivial_iterator_difference_type difference_type;
+
+      typedef
+      typename _Alloc::template rebind<
+	Value_Type>::other::pointer
+      value_type;
+
+      typedef
+      typename _Alloc::template rebind<
+	typename remove_const<
+	Value_Type>::type>::other::pointer
+      reference;
+
+      typedef
+      typename _Alloc::template rebind<
+	typename remove_const<
+	Value_Type>::type>::other::pointer
+      const_reference;
+
+      inline
+      ov_tree_node_it_(const_pointer p_nd = 0,  const_pointer p_begin_nd = 0,  const_pointer p_end_nd = 0,  const_metadata_pointer p_metadata = 0) : base_type(p_nd,  p_begin_nd,  p_end_nd,  p_metadata)
+      { }
+
+      /// Access.
+      inline reference
+      operator*() const
+      { return reference(base_type::m_p_value); }
+
+      /// Returns the node reference associated with the left node.
+      inline ov_tree_node_it_
+      get_l_child() const
+      {
+	if (base_type::m_p_begin_value == base_type::m_p_value)
+	  return (this_type(base_type::m_p_begin_value,  base_type::m_p_begin_value,  base_type::m_p_begin_value));
+
+	const_metadata_pointer p_begin_metadata =
+	  base_type::m_p_metadata - (base_type::m_p_value - base_type::m_p_begin_value);
+
+	return (this_type(base_type::mid_pointer(base_type::m_p_begin_value, base_type::m_p_value),
+			  base_type::m_p_begin_value,
+			  base_type::m_p_value,
+			  base_type::mid_pointer(p_begin_metadata, base_type::m_p_metadata)));
+      }
+
+      /// Returns the node reference associated with the right node.
+      inline ov_tree_node_it_
+      get_r_child() const
+      {
+	if (base_type::m_p_value == base_type::m_p_end_value)
+	  return this_type(base_type::m_p_end_value, base_type::m_p_end_value,  
+			   base_type::m_p_end_value);
+
+	const_metadata_pointer p_end_metadata =
+	  base_type::m_p_metadata + (base_type::m_p_end_value - base_type::m_p_value);
+
+	return (this_type(base_type::mid_pointer(base_type::m_p_value + 1, base_type::m_p_end_value),
+			  base_type::m_p_value + 1,
+			  base_type::m_p_end_value,(base_type::m_p_metadata == 0)?
+			  0 : base_type::mid_pointer(base_type::m_p_metadata + 1, p_end_metadata)));
+      }
+
+    };
+
+#undef PB_DS_OV_TREE_NODE_ITERATOR_C_DEC
+#undef PB_DS_OV_TREE_CONST_NODE_ITERATOR_C_DEC
+
+} // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
new file mode 100644
index 0000000..349f268
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
@@ -0,0 +1,542 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/ov_tree_map_.hpp
+ * Contains an implementation class for ov_tree.
+ */
+
+#include <map>
+#include <set>
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+#include <ext/pb_ds/detail/eq_fn/eq_by_less.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/tree_trace_base.hpp>
+#ifdef _GLIBCXX_DEBUG
+#include <ext/pb_ds/detail/debug_map_base.hpp>
+#endif
+#include <utility>
+#include <functional>
+#include <algorithm>
+#include <vector>
+#include <assert.h>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+#define PB_DS_OV_TREE_NAME ov_tree_map
+#define PB_DS_CONST_NODE_ITERATOR_NAME ov_tree_node_const_iterator_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+#define PB_DS_OV_TREE_NAME ov_tree_set
+#define PB_DS_CONST_NODE_ITERATOR_NAME ov_tree_node_const_iterator_set
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Cmp_Fn, \
+	     typename Node_And_It_Traits, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+   PB_DS_OV_TREE_NAME<Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc>
+
+#define PB_DS_OV_TREE_TRAITS_BASE \
+    types_traits<Key, Mapped, _Alloc, false>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key, eq_by_less<Key, Cmp_Fn>, \
+       	typename _Alloc::template rebind<Key>::other::const_reference>
+#endif
+
+#ifdef PB_DS_TREE_TRACE
+#define PB_DS_TREE_TRACE_BASE_C_DEC \
+    tree_trace_base<typename Node_And_It_Traits::node_const_iterator,	\
+		    typename Node_And_It_Traits::node_iterator,		\
+		    Cmp_Fn, false, _Alloc>
+#endif
+
+#ifndef PB_DS_CHECK_KEY_EXISTS
+#  error Missing definition
+#endif
+
+    /**
+     *  @brief Ordered-vector tree associative-container.
+     *  @ingroup branch-detail
+     */
+    template<typename Key, typename Mapped, typename Cmp_Fn,
+	     typename Node_And_It_Traits, typename _Alloc>
+    class PB_DS_OV_TREE_NAME :
+#ifdef _GLIBCXX_DEBUG
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
+#endif
+#ifdef PB_DS_TREE_TRACE
+      public PB_DS_TREE_TRACE_BASE_C_DEC,
+#endif
+      public Cmp_Fn,
+      public Node_And_It_Traits::node_update,
+      public PB_DS_OV_TREE_TRAITS_BASE
+    {
+    private:
+      typedef PB_DS_OV_TREE_TRAITS_BASE	       		traits_base;
+      typedef Node_And_It_Traits			traits_type;
+
+      typedef typename remove_const<typename traits_base::value_type>::type non_const_value_type;
+
+      typedef typename _Alloc::template rebind<non_const_value_type>::other value_allocator;
+      typedef typename value_allocator::pointer 	value_vector;
+
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC 		debug_base;
+#endif
+
+#ifdef PB_DS_TREE_TRACE
+      typedef PB_DS_TREE_TRACE_BASE_C_DEC 		trace_base;
+#endif
+
+      typedef typename traits_base::pointer 		mapped_pointer_;
+      typedef typename traits_base::const_pointer 	mapped_const_pointer_;
+
+      typedef typename traits_type::metadata_type 	metadata_type;
+
+      typedef typename _Alloc::template rebind<metadata_type>::other metadata_allocator;
+      typedef typename metadata_allocator::pointer 	metadata_pointer;
+      typedef typename metadata_allocator::const_reference metadata_const_reference;
+      typedef typename metadata_allocator::reference 	metadata_reference;
+
+      typedef typename traits_type::null_node_update_pointer
+      null_node_update_pointer;
+
+    public:
+      typedef ov_tree_tag 				 container_category;
+      typedef _Alloc 					allocator_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+      typedef Cmp_Fn 					cmp_fn;
+
+      typedef typename traits_base::key_type 		key_type;
+      typedef typename traits_base::key_pointer 	key_pointer;
+      typedef typename traits_base::key_const_pointer 	key_const_pointer;
+      typedef typename traits_base::key_reference 	key_reference;
+      typedef typename traits_base::key_const_reference key_const_reference;
+      typedef typename traits_base::mapped_type 	mapped_type;
+      typedef typename traits_base::mapped_pointer 	mapped_pointer;
+      typedef typename traits_base::mapped_const_pointer mapped_const_pointer;
+      typedef typename traits_base::mapped_reference 	mapped_reference;
+      typedef typename traits_base::mapped_const_reference mapped_const_reference;
+      typedef typename traits_base::value_type 		value_type;
+      typedef typename traits_base::pointer 		pointer;
+      typedef typename traits_base::const_pointer 	const_pointer;
+      typedef typename traits_base::reference 		reference;
+      typedef typename traits_base::const_reference 	const_reference;
+
+      typedef const_pointer 				point_const_iterator;
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      typedef pointer 					point_iterator;
+#else
+      typedef point_const_iterator 			point_iterator;
+#endif
+
+      typedef point_iterator 				iterator;
+      typedef point_const_iterator 			const_iterator;
+
+      /// Conditional destructor.
+      template<typename Size_Type>
+        class cond_dtor
+        {
+	public:
+	  cond_dtor(value_vector a_vec, iterator& r_last_it, 
+		    Size_Type total_size) 
+	  : m_a_vec(a_vec), m_r_last_it(r_last_it), m_max_size(total_size),
+	    m_no_action(false)
+	  { }
+
+	  ~cond_dtor()
+	  {
+	    if (m_no_action)
+	      return;
+	    iterator it = m_a_vec;
+	    while (it != m_r_last_it)
+	      {
+		it->~value_type();
+		++it;
+	      }
+	    
+	    if (m_max_size > 0)
+	      value_allocator().deallocate(m_a_vec, m_max_size);
+	  }
+
+	  inline void
+	  set_no_action()
+	  { m_no_action = true; }
+	  
+	protected:
+	  value_vector 		m_a_vec;
+	  iterator& 		m_r_last_it;
+	  const Size_Type 	m_max_size;
+	  bool 			m_no_action;
+       };
+      
+      typedef typename traits_type::node_update 	node_update;
+      typedef typename traits_type::node_iterator 	node_iterator;
+      typedef typename traits_type::node_const_iterator	node_const_iterator;
+
+
+      PB_DS_OV_TREE_NAME();
+
+      PB_DS_OV_TREE_NAME(const Cmp_Fn&);
+
+      PB_DS_OV_TREE_NAME(const Cmp_Fn&, const node_update&);
+
+      PB_DS_OV_TREE_NAME(const PB_DS_CLASS_C_DEC&);
+
+      ~PB_DS_OV_TREE_NAME();
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+      inline size_type
+      max_size() const;
+
+      inline bool
+      empty() const;
+
+      inline size_type
+      size() const;
+
+      Cmp_Fn&
+      get_cmp_fn();
+
+      const Cmp_Fn&
+      get_cmp_fn() const;
+
+      inline mapped_reference
+      operator[](key_const_reference r_key)
+      {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+	PB_DS_ASSERT_VALID((*this))
+	point_iterator it = lower_bound(r_key);
+	if (it != end() && !Cmp_Fn::operator()(r_key, PB_DS_V2F(*it)))
+	  {
+	    PB_DS_CHECK_KEY_EXISTS(r_key)
+	    PB_DS_ASSERT_VALID((*this))
+	     return it->second;
+	  }
+	return insert_new_val(it, std::make_pair(r_key, mapped_type()))->second;
+#else
+	insert(r_key);
+	return traits_base::s_null_type;
+#endif
+      }
+
+      inline std::pair<point_iterator, bool>
+      insert(const_reference r_value)
+      {
+	PB_DS_ASSERT_VALID((*this))
+	key_const_reference r_key = PB_DS_V2F(r_value);
+	point_iterator it = lower_bound(r_key);
+
+	if (it != end()&&  !Cmp_Fn::operator()(r_key, PB_DS_V2F(*it)))
+	  {
+	    PB_DS_ASSERT_VALID((*this))
+	    PB_DS_CHECK_KEY_EXISTS(r_key)
+	    return std::make_pair(it, false);
+	  }
+
+	return std::make_pair(insert_new_val(it, r_value), true);
+      }
+
+      inline point_iterator
+      lower_bound(key_const_reference r_key)
+      {
+	pointer it = m_a_values;
+	pointer e_it = m_a_values + m_size;
+	while (it != e_it)
+	  {
+	    pointer mid_it = it + ((e_it - it) >> 1);
+	    if (cmp_fn::operator()(PB_DS_V2F(*mid_it), r_key))
+	      it = ++mid_it;
+	    else
+	      e_it = mid_it;
+	  }
+	return it;
+      }
+
+      inline point_const_iterator
+      lower_bound(key_const_reference r_key) const
+      { return const_cast<PB_DS_CLASS_C_DEC& >(*this).lower_bound(r_key); }
+
+      inline point_iterator
+      upper_bound(key_const_reference r_key)
+      {
+	iterator pot_it = lower_bound(r_key);
+	if (pot_it != end() && !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it)))
+	  {
+	    PB_DS_CHECK_KEY_EXISTS(r_key)
+	    return ++pot_it;
+	  }
+
+	PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	return pot_it;
+      }
+
+      inline point_const_iterator
+      upper_bound(key_const_reference r_key) const
+      { return const_cast<PB_DS_CLASS_C_DEC&>(*this).upper_bound(r_key); }
+
+      inline point_iterator
+      find(key_const_reference r_key)
+      {
+	PB_DS_ASSERT_VALID((*this))
+	iterator pot_it = lower_bound(r_key);
+	if (pot_it != end() && !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it)))
+	  {
+	    PB_DS_CHECK_KEY_EXISTS(r_key)
+	    return pot_it;
+	  }
+
+	PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+	return end();
+      }
+
+      inline point_const_iterator
+      find(key_const_reference r_key) const
+      { return (const_cast<PB_DS_CLASS_C_DEC&>(*this).find(r_key)); }
+
+      bool
+      erase(key_const_reference);
+
+      template<typename Pred>
+      inline size_type
+      erase_if(Pred);
+
+      inline iterator
+      erase(iterator it)
+      { return erase_imp<iterator>(it); }
+
+      void
+      clear();
+
+      void
+      join(PB_DS_CLASS_C_DEC&);
+
+      void
+      split(key_const_reference, PB_DS_CLASS_C_DEC&);
+
+      inline iterator
+      begin()
+      { return m_a_values; }
+
+      inline const_iterator
+      begin() const
+      { return m_a_values; }
+
+      inline iterator
+      end()
+      { return m_end_it; }
+
+      inline const_iterator
+      end() const
+      { return m_end_it; }
+
+      /// Returns a const node_iterator corresponding to the node at the
+      /// root of the tree.
+      inline node_const_iterator
+      node_begin() const;
+
+      /// Returns a node_iterator corresponding to the node at the
+      /// root of the tree.
+      inline node_iterator
+      node_begin();
+
+      /// Returns a const node_iterator corresponding to a node just
+      /// after a leaf of the tree.
+      inline node_const_iterator
+      node_end() const;
+
+      /// Returns a node_iterator corresponding to a node just
+      /// after a leaf of the tree.
+      inline node_iterator
+      node_end();
+
+    private:
+
+      inline void
+      update(node_iterator, null_node_update_pointer);
+
+      template<typename Node_Update>
+      void
+      update(node_iterator, Node_Update*);
+
+      void
+      reallocate_metadata(null_node_update_pointer, size_type);
+
+      template<typename Node_Update_>
+      void
+      reallocate_metadata(Node_Update_*, size_type);
+
+      template<typename It>
+      void
+      copy_from_ordered_range(It, It);
+
+      void
+      value_swap(PB_DS_CLASS_C_DEC&);
+
+      template<typename It>
+      void
+      copy_from_ordered_range(It, It, It, It);
+
+      template<typename Ptr>
+      inline static Ptr
+      mid_pointer(Ptr p_begin, Ptr p_end)
+      {
+	_GLIBCXX_DEBUG_ASSERT(p_end >= p_begin);
+	return (p_begin + (p_end - p_begin) / 2);
+      }
+
+      inline iterator
+      insert_new_val(iterator it, const_reference r_value)
+      {
+#ifdef PB_DS_REGRESSION
+	typename _Alloc::group_adjustor adjust(m_size);
+#endif
+
+	PB_DS_CHECK_KEY_DOES_NOT_EXIST(PB_DS_V2F(r_value))
+
+	value_vector a_values = s_value_alloc.allocate(m_size + 1);
+
+	iterator source_it = begin();
+	iterator source_end_it = end();
+	iterator target_it = a_values;
+	iterator ret_it;
+
+	cond_dtor<size_type> cd(a_values, target_it, m_size + 1);
+	while (source_it != it)
+	  {
+	    new (const_cast<void*>(static_cast<const void*>(target_it)))
+	      value_type(*source_it++);
+	    ++target_it;
+	  }
+
+	new (const_cast<void*>(static_cast<const void*>(ret_it = target_it)))
+	  value_type(r_value);
+	++target_it;
+
+	while (source_it != source_end_it)
+	  {
+	    new (const_cast<void*>(static_cast<const void*>(target_it)))
+	      value_type(*source_it++);
+	    ++target_it;
+	  }
+
+	reallocate_metadata((node_update*)this, m_size + 1);
+	cd.set_no_action();
+	if (m_size != 0)
+	  {
+	    cond_dtor<size_type> cd1(m_a_values, m_end_it, m_size);
+	  }
+
+	++m_size;
+	m_a_values = a_values;
+	m_end_it = m_a_values + m_size;
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_value)));
+	update(node_begin(), (node_update* )this);
+	PB_DS_ASSERT_VALID((*this))
+	return ret_it;
+      }
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+
+      void
+      assert_iterators(const char*, int) const;
+#endif
+
+      template<typename It>
+      It
+      erase_imp(It);
+
+      inline node_const_iterator
+      PB_DS_node_begin_imp() const;
+
+      inline node_const_iterator
+      PB_DS_node_end_imp() const;
+
+      inline node_iterator
+      PB_DS_node_begin_imp();
+
+      inline node_iterator
+      PB_DS_node_end_imp();
+
+    private:
+      static value_allocator 	s_value_alloc;
+      static metadata_allocator s_metadata_alloc;
+
+      value_vector 		m_a_values;
+      metadata_pointer 		m_a_metadata;
+      iterator 			m_end_it;
+      size_type 		m_size;
+    };
+
+#include <ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/info_fn_imps.hpp>
+#include <ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp>
+#include <ext/pb_ds/detail/bin_search_tree_/policy_access_fn_imps.hpp>
+
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_OV_TREE_NAME
+#undef PB_DS_OV_TREE_TRAITS_BASE
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
+#ifdef PB_DS_TREE_TRACE
+#undef PB_DS_TREE_TRACE_BASE_C_DEC
+#endif
+#undef PB_DS_CONST_NODE_ITERATOR_NAME
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/policy_access_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/policy_access_fn_imps.hpp
new file mode 100644
index 0000000..f09949b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/policy_access_fn_imps.hpp
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/policy_access_fn_imps.hpp
+ * Contains an implementation class for ov_tree.
+ */
+
+PB_DS_CLASS_T_DEC
+Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn() const
+{ return *this; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..520dfd7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp
@@ -0,0 +1,132 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/split_join_fn_imps.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+split(key_const_reference r_key, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  if (m_size == 0)
+    {
+      other.clear();
+      return;
+    }
+
+  if (Cmp_Fn::operator()(r_key, PB_DS_V2F(*begin())))
+    {
+      value_swap(other);
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(*(end() - 1))))
+    {
+      return;
+    }
+
+  if (m_size == 1)
+    {
+      value_swap(other);
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  iterator it = upper_bound(r_key);
+  PB_DS_CLASS_C_DEC new_other(other, other);
+  new_other.copy_from_ordered_range(it, end());
+  PB_DS_CLASS_C_DEC new_this(*this, *this);
+  new_this.copy_from_ordered_range(begin(), it);
+
+  // No exceptions from this point.
+  other.update(other.node_begin(), (node_update*)(&other));
+  update(node_begin(), (node_update*)this);
+  other.value_swap(new_other);
+  value_swap(new_this);
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  if (other.m_size == 0)
+    return;
+
+  if (m_size == 0)
+    {
+      value_swap(other);
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  const bool greater = Cmp_Fn::operator()(PB_DS_V2F(*(end() - 1)),
+					  PB_DS_V2F(*other.begin()));
+
+  const bool lesser = Cmp_Fn::operator()(PB_DS_V2F(*(other.end() - 1)),
+					 PB_DS_V2F(*begin()));
+
+  if (!greater && !lesser)
+    __throw_join_error();
+
+  PB_DS_CLASS_C_DEC new_this(*this, *this);
+
+  if (greater)
+    new_this.copy_from_ordered_range(begin(), end(),
+				     other.begin(), other.end());
+  else
+    new_this.copy_from_ordered_range(other.begin(), other.end(),
+				     begin(), end());
+
+  // No exceptions from this point.
+  value_swap(new_this);
+  other.clear();
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/traits.hpp
new file mode 100644
index 0000000..a39f0ff
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/traits.hpp
@@ -0,0 +1,190 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file ov_tree_map_/traits.hpp
+ * Contains an implementation class for ov_tree_.
+ */
+
+#ifndef PB_DS_OV_TREE_NODE_AND_IT_TRAITS_HPP
+#define PB_DS_OV_TREE_NODE_AND_IT_TRAITS_HPP
+
+#include <ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Tree traits.
+    /// @ingroup traits
+    template<typename Key,
+	     typename Mapped,
+	     class Cmp_Fn,
+	     template<typename Node_CItr,
+		      class Node_Itr,
+		      class Cmp_Fn_,
+		      typename _Alloc_>
+    class Node_Update,
+	     typename _Alloc>
+    struct tree_traits<
+      Key,
+      Mapped,
+      Cmp_Fn,
+      Node_Update,
+      ov_tree_tag,
+      _Alloc>
+    {
+    private:
+      typedef
+      typename types_traits<
+      Key,
+      Mapped,
+      _Alloc,
+      false>::value_type
+      value_type;
+
+    public:
+      typedef
+      typename tree_node_metadata_dispatch<
+      Key,
+      Mapped,
+      Cmp_Fn,
+      Node_Update,
+      _Alloc>::type
+      metadata_type;
+
+      /// This is an iterator to an iterator: it iterates over nodes,
+      /// and de-referencing it returns one of the tree's iterators.
+      typedef
+      ov_tree_node_const_it_<
+	value_type,
+	metadata_type,
+	_Alloc>
+      node_const_iterator;
+
+      typedef
+      ov_tree_node_it_<
+	value_type,
+	metadata_type,
+	_Alloc>
+      node_iterator;
+
+      typedef
+      Node_Update<
+	node_const_iterator,
+	node_iterator,
+	Cmp_Fn,
+	_Alloc>
+      node_update;
+
+      typedef
+      __gnu_pbds::null_node_update<
+	node_const_iterator,
+	node_iterator,
+	Cmp_Fn,
+	_Alloc>* 
+      null_node_update_pointer;
+    };
+
+
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     class Cmp_Fn,
+	     template<typename Node_CItr,
+		      class Node_Itr,
+		      class Cmp_Fn_,
+		      typename _Alloc_>
+    class Node_Update,
+	     typename _Alloc>
+    struct tree_traits<
+      Key,
+      null_type,
+      Cmp_Fn,
+      Node_Update,
+      ov_tree_tag,
+      _Alloc>
+    {
+    private:
+      typedef
+      typename types_traits<
+      Key,
+      null_type,
+      _Alloc,
+      false>::value_type
+      value_type;
+
+    public:
+      typedef
+      typename tree_node_metadata_dispatch<
+      Key,
+      null_type,
+      Cmp_Fn,
+      Node_Update,
+      _Alloc>::type
+      metadata_type;
+
+      /// This is an iterator to an iterator: it iterates over nodes,
+      /// and de-referencing it returns one of the tree's iterators.
+      typedef
+      ov_tree_node_const_it_<
+	value_type,
+	metadata_type,
+	_Alloc>
+      node_const_iterator;
+
+      typedef node_const_iterator node_iterator;
+
+      typedef
+      Node_Update<
+	node_const_iterator,
+	node_const_iterator,
+	Cmp_Fn,
+	_Alloc>
+      node_update;
+
+      typedef
+      __gnu_pbds::null_node_update<
+	node_const_iterator,
+	node_iterator,
+	Cmp_Fn,
+	_Alloc>* 
+      null_node_update_pointer;
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_OV_TREE_NODE_AND_IT_TRAITS_HPP
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..6208432
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,82 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pairing_heap_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for a pairing heap.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    push(*(first_it++));
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+pairing_heap()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+pairing_heap(const Cmp_Fn& r_cmp_fn)
+: base_type(r_cmp_fn)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+pairing_heap(const PB_DS_CLASS_C_DEC& other)
+: base_type(other)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  base_type::swap(other);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~pairing_heap()
+{ }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp
new file mode 100644
index 0000000..a662c18
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp
@@ -0,0 +1,53 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pairing_heap_/debug_fn_imps.hpp
+ * Contains an implementation class for a pairing heap.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  PB_DS_DEBUG_VERIFY(base_type::m_p_root == 0 
+		        || base_type::m_p_root->m_p_next_sibling == 0);
+  base_type::assert_valid(__file, __line);
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp
new file mode 100644
index 0000000..4282032
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp
@@ -0,0 +1,233 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pairing_heap_/erase_fn_imps.hpp
+ * Contains an implementation class for a pairing heap.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+pop()
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+
+  node_pointer p_new_root = join_node_children(base_type::m_p_root);
+  PB_DS_ASSERT_NODE_CONSISTENT(p_new_root, false)
+  if (p_new_root != 0)
+    p_new_root->m_p_prev_or_parent = 0;
+
+  base_type::actual_erase_node(base_type::m_p_root);
+  base_type::m_p_root = p_new_root;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase(point_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+  remove_node(it.m_p_nd);
+  base_type::actual_erase_node(it.m_p_nd);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+remove_node(node_pointer p_nd)
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+  node_pointer p_new_child = join_node_children(p_nd);
+
+  PB_DS_ASSERT_NODE_CONSISTENT(p_new_child, false)
+
+  if (p_nd == base_type::m_p_root)
+    {
+      if (p_new_child != 0)
+	p_new_child->m_p_prev_or_parent = 0;
+      base_type::m_p_root = p_new_child;
+      PB_DS_ASSERT_NODE_CONSISTENT(base_type::m_p_root, false)
+      return;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent != 0);
+  if (p_nd->m_p_prev_or_parent->m_p_l_child == p_nd)
+    {
+      if (p_new_child != 0)
+        {
+	  p_new_child->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+	  p_new_child->m_p_next_sibling = p_nd->m_p_next_sibling;
+	  if (p_new_child->m_p_next_sibling != 0)
+	    p_new_child->m_p_next_sibling->m_p_prev_or_parent = p_new_child;
+	  p_nd->m_p_prev_or_parent->m_p_l_child = p_new_child;
+	  PB_DS_ASSERT_NODE_CONSISTENT(p_nd->m_p_prev_or_parent, false)
+          return;
+        }
+
+      p_nd->m_p_prev_or_parent->m_p_l_child = p_nd->m_p_next_sibling;
+      if (p_nd->m_p_next_sibling != 0)
+	p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+      PB_DS_ASSERT_NODE_CONSISTENT(p_nd->m_p_prev_or_parent, false)
+      return;
+    }
+
+  if (p_new_child != 0)
+    {
+      p_new_child->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+      p_new_child->m_p_next_sibling = p_nd->m_p_next_sibling;
+      if (p_new_child->m_p_next_sibling != 0)
+	p_new_child->m_p_next_sibling->m_p_prev_or_parent = p_new_child;
+      p_new_child->m_p_prev_or_parent->m_p_next_sibling = p_new_child;
+      PB_DS_ASSERT_NODE_CONSISTENT(p_nd->m_p_prev_or_parent, false)
+      return;
+    }
+
+  p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd->m_p_next_sibling;
+  if (p_nd->m_p_next_sibling != 0)
+    p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+  PB_DS_ASSERT_NODE_CONSISTENT(p_nd->m_p_prev_or_parent, false)
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+join_node_children(node_pointer p_nd)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  node_pointer p_ret = p_nd->m_p_l_child;
+  if (p_ret == 0)
+    return 0;
+  while (p_ret->m_p_next_sibling != 0)
+    p_ret = forward_join(p_ret, p_ret->m_p_next_sibling);
+  while (p_ret->m_p_prev_or_parent != p_nd)
+    p_ret = back_join(p_ret->m_p_prev_or_parent, p_ret);
+  PB_DS_ASSERT_NODE_CONSISTENT(p_ret, false)
+  return p_ret;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+forward_join(node_pointer p_nd, node_pointer p_next)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling == p_next);
+  if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value))
+    {
+      p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+      base_type::make_child_of(p_nd, p_next);
+      return p_next->m_p_next_sibling == 0 
+	? p_next : p_next->m_p_next_sibling;
+    }
+
+  if (p_next->m_p_next_sibling != 0)
+    {
+      p_next->m_p_next_sibling->m_p_prev_or_parent = p_nd;
+      p_nd->m_p_next_sibling = p_next->m_p_next_sibling;
+      base_type::make_child_of(p_next, p_nd);
+      return p_nd->m_p_next_sibling;
+    }
+
+  p_nd->m_p_next_sibling = 0;
+  base_type::make_child_of(p_next, p_nd);
+  PB_DS_ASSERT_NODE_CONSISTENT(p_nd, false)
+  return p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+back_join(node_pointer p_nd, node_pointer p_next)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == 0);
+
+  if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value))
+    {
+      p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+      base_type::make_child_of(p_nd, p_next);
+      PB_DS_ASSERT_NODE_CONSISTENT(p_next, false)
+      return p_next;
+    }
+
+  p_nd->m_p_next_sibling = 0;
+  base_type::make_child_of(p_next, p_nd);
+  PB_DS_ASSERT_NODE_CONSISTENT(p_nd, false)
+  return p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+    if (base_type::empty())
+      {
+        PB_DS_ASSERT_VALID((*this))
+	return 0;
+      }
+  base_type::to_linked_list();
+  node_pointer p_out = base_type::prune(pred);
+  size_type ersd = 0;
+  while (p_out != 0)
+    {
+      ++ersd;
+      node_pointer p_next = p_out->m_p_next_sibling;
+      base_type::actual_erase_node(p_out);
+      p_out = p_next;
+    }
+
+  node_pointer p_cur = base_type::m_p_root;
+  base_type::m_p_root = 0;
+  while (p_cur != 0)
+    {
+      node_pointer p_next = p_cur->m_p_next_sibling;
+      p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = 0;
+
+      push_imp(p_cur);
+      p_cur = p_next;
+    }
+  PB_DS_ASSERT_VALID((*this))
+  return ersd;
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/find_fn_imps.hpp
new file mode 100644
index 0000000..b346c9a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/find_fn_imps.hpp
@@ -0,0 +1,49 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pairing_heap_/find_fn_imps.hpp
+ * Contains an implementation class for a pairing heap.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reference
+PB_DS_CLASS_C_DEC::
+top() const
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+  return base_type::m_p_root->m_value;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp
new file mode 100644
index 0000000..9903767
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp
@@ -0,0 +1,88 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pairing_heap_/insert_fn_imps.hpp
+ * Contains an implementation class for a pairing heap.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+push(const_reference r_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+  node_pointer p_new_nd = base_type::get_new_node_for_insert(r_val);
+  push_imp(p_new_nd);
+  PB_DS_ASSERT_VALID((*this))
+  return point_iterator(p_new_nd);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+push_imp(node_pointer p_nd)
+{
+  p_nd->m_p_l_child = 0;
+  if (base_type::m_p_root == 0)
+    {
+      p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = 0;
+      base_type::m_p_root = p_nd;
+    }
+  else if (Cmp_Fn::operator()(base_type::m_p_root->m_value, p_nd->m_value))
+    {
+      p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = 0;
+      base_type::make_child_of(base_type::m_p_root, p_nd);
+      PB_DS_ASSERT_NODE_CONSISTENT(p_nd, false)
+      base_type::m_p_root = p_nd;
+    }
+  else
+    {
+      base_type::make_child_of(p_nd, base_type::m_p_root);
+      PB_DS_ASSERT_NODE_CONSISTENT(base_type::m_p_root, false)
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+modify(point_iterator it, const_reference r_new_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+  remove_node(it.m_p_nd);
+  it.m_p_nd->m_value = r_new_val;
+  push_imp(it.m_p_nd);
+  PB_DS_ASSERT_VALID((*this))
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/pairing_heap_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/pairing_heap_.hpp
new file mode 100644
index 0000000..dc32a88
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/pairing_heap_.hpp
@@ -0,0 +1,185 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pairing_heap_/pairing_heap_.hpp
+ * Contains an implementation class for a pairing heap.
+ */
+
+/*
+ * Pairing heap:
+ * Michael L. Fredman, Robert Sedgewick, Daniel Dominic Sleator,
+ *    and Robert Endre Tarjan, The Pairing Heap:
+ *    A New Form of Self-Adjusting Heap, Algorithmica, 1(1):111-129, 1986.
+ */
+
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_T_DEC \
+  template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+  pairing_heap<Value_Type, Cmp_Fn, _Alloc>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_P_HEAP_BASE \
+  left_child_next_sibling_heap<Value_Type, Cmp_Fn, null_type, _Alloc, false>
+#else
+#define PB_DS_P_HEAP_BASE \
+  left_child_next_sibling_heap<Value_Type, Cmp_Fn, null_type, _Alloc>
+#endif
+
+    /**
+     *  Pairing heap.
+     *
+     *  @ingroup heap-detail
+     */
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+    class pairing_heap : public PB_DS_P_HEAP_BASE
+    {
+    private:
+      typedef PB_DS_P_HEAP_BASE				base_type;
+      typedef typename base_type::node_pointer 		node_pointer;
+
+      typedef typename _Alloc::template rebind<Value_Type>::other __rebind_a;
+
+    public:
+      typedef Value_Type 				value_type;
+      typedef Cmp_Fn 					cmp_fn;
+      typedef _Alloc 					allocator_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+
+      typedef typename __rebind_a::pointer 		pointer;
+      typedef typename __rebind_a::const_pointer 	const_pointer;
+      typedef typename __rebind_a::reference		reference;
+      typedef typename __rebind_a::const_reference 	const_reference;
+
+      typedef typename base_type::point_const_iterator	point_const_iterator;
+      typedef typename base_type::point_iterator 	point_iterator;
+      typedef typename base_type::const_iterator 	const_iterator;
+      typedef typename base_type::iterator 		iterator;
+
+      pairing_heap();
+
+      pairing_heap(const Cmp_Fn&);
+
+      pairing_heap(const pairing_heap&);
+
+      void
+      swap(pairing_heap&);
+
+      ~pairing_heap();
+
+      inline point_iterator
+      push(const_reference);
+
+      void
+      modify(point_iterator, const_reference);
+
+      inline const_reference
+      top() const;
+
+      void
+      pop();
+
+      void
+      erase(point_iterator);
+
+      template<typename Pred>
+      size_type
+      erase_if(Pred);
+
+      template<typename Pred>
+      void
+      split(Pred, pairing_heap&);
+
+      void
+      join(pairing_heap&);
+
+    protected:
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+
+    private:
+
+      inline void
+      push_imp(node_pointer);
+
+      node_pointer
+      join_node_children(node_pointer);
+
+      node_pointer
+      forward_join(node_pointer, node_pointer);
+
+      node_pointer
+      back_join(node_pointer, node_pointer);
+
+      void
+      remove_node(node_pointer);
+    };
+
+#define PB_DS_ASSERT_NODE_CONSISTENT(_Node, _Bool) \
+ _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(_Node, _Bool,	\
+						       __FILE__, __LINE__);)
+
+#include <ext/pb_ds/detail/pairing_heap_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/pairing_heap_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp>
+
+#undef PB_DS_ASSERT_NODE_CONSISTENT
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_P_HEAP_BASE
+
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..a2a4312
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp
@@ -0,0 +1,123 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pairing_heap_/split_join_fn_imps.hpp
+ * Contains an implementation class for a pairing heap.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+void
+PB_DS_CLASS_C_DEC::
+split(Pred pred, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  other.clear();
+
+  if (base_type::empty())
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  base_type::to_linked_list();
+  node_pointer p_out = base_type::prune(pred);
+  while (p_out != 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0);
+      --base_type::m_size;
+      ++other.m_size;
+      node_pointer p_next = p_out->m_p_next_sibling;
+      p_out->m_p_l_child = p_out->m_p_next_sibling = p_out->m_p_prev_or_parent = 0;
+
+      other.push_imp(p_out);
+      p_out = p_next;
+    }
+
+  PB_DS_ASSERT_VALID(other)
+  node_pointer p_cur = base_type::m_p_root;
+  base_type::m_p_root = 0;
+  while (p_cur != 0)
+    {
+      node_pointer p_next = p_cur->m_p_next_sibling;
+      p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = 0;
+
+      push_imp(p_cur);
+      p_cur = p_next;
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  if (other.m_p_root == 0)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  if (base_type::m_p_root == 0)
+    base_type::m_p_root = other.m_p_root;
+  else if (Cmp_Fn::operator()(base_type::m_p_root->m_value, other.m_p_root->m_value))
+    {
+      base_type::make_child_of(base_type::m_p_root, other.m_p_root);
+      PB_DS_ASSERT_NODE_CONSISTENT(other.m_p_root, false)
+      base_type::m_p_root = other.m_p_root;
+    }
+  else
+    {
+      base_type::make_child_of(other.m_p_root, base_type::m_p_root);
+      PB_DS_ASSERT_NODE_CONSISTENT(base_type::m_p_root, false)
+    }
+
+  base_type::m_size += other.m_size;
+  other.m_p_root = 0;
+  other.m_size = 0;
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..c67674c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,214 @@
+ // -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::head_allocator
+PB_DS_CLASS_C_DEC::s_head_allocator;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::inode_allocator
+PB_DS_CLASS_C_DEC::s_inode_allocator;
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::leaf_allocator
+PB_DS_CLASS_C_DEC::s_leaf_allocator;
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_PAT_TRIE_NAME() :
+  m_p_head(s_head_allocator.allocate(1)),
+  m_size(0)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_PAT_TRIE_NAME(const access_traits& r_access_traits) :
+  synth_access_traits(r_access_traits),
+  m_p_head(s_head_allocator.allocate(1)),
+  m_size(0)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_PAT_TRIE_NAME(const PB_DS_CLASS_C_DEC& other) :
+#ifdef _GLIBCXX_DEBUG
+  debug_base(other),
+#endif
+  synth_access_traits(other),
+  node_update(other),
+  m_p_head(s_head_allocator.allocate(1)),
+  m_size(0)
+{
+  initialize();
+  m_size = other.m_size;
+  PB_DS_ASSERT_VALID(other)
+    if (other.m_p_head->m_p_parent == 0)
+      {
+	PB_DS_ASSERT_VALID((*this))
+	return;
+      }
+  __try
+    {
+      m_p_head->m_p_parent = recursive_copy_node(other.m_p_head->m_p_parent);
+    }
+  __catch(...)
+    {
+      s_head_allocator.deallocate(m_p_head, 1);
+      __throw_exception_again;
+    }
+
+  m_p_head->m_p_min = leftmost_descendant(m_p_head->m_p_parent);
+  m_p_head->m_p_max = rightmost_descendant(m_p_head->m_p_parent);
+  m_p_head->m_p_parent->m_p_parent = m_p_head;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  value_swap(other);
+  std::swap((access_traits& )(*this), (access_traits& )other);
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+value_swap(PB_DS_CLASS_C_DEC& other)
+{
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
+  std::swap(m_p_head, other.m_p_head);
+  std::swap(m_size, other.m_size);
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~PB_DS_PAT_TRIE_NAME()
+{
+  clear();
+  s_head_allocator.deallocate(m_p_head, 1);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize()
+{
+  new (m_p_head) head();
+  m_p_head->m_p_parent = 0;
+  m_p_head->m_p_min = m_p_head;
+  m_p_head->m_p_max = m_p_head;
+  m_size = 0;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    insert(*(first_it++));
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+recursive_copy_node(node_const_pointer p_ncp)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_ncp != 0);
+  if (p_ncp->m_type == leaf_node)
+    {
+      leaf_const_pointer p_other_lf = static_cast<leaf_const_pointer>(p_ncp);
+      leaf_pointer p_new_lf = s_leaf_allocator.allocate(1);
+      cond_dealtor cond(p_new_lf);
+      new (p_new_lf) leaf(p_other_lf->value());
+      apply_update(p_new_lf, (node_update*)this);
+      cond.set_no_action_dtor();
+      return (p_new_lf);
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_ncp->m_type == i_node);
+  node_pointer a_p_children[inode::arr_size];
+  size_type child_i = 0;
+  inode_const_pointer p_icp = static_cast<inode_const_pointer>(p_ncp);
+
+  typename inode::const_iterator child_it = p_icp->begin();
+
+  inode_pointer p_ret;
+  __try
+    {
+      while (child_it != p_icp->end())
+	{
+	  a_p_children[child_i] = recursive_copy_node(*(child_it));
+	  child_i++;
+	  child_it++;
+	}
+      p_ret = s_inode_allocator.allocate(1);
+    }
+  __catch(...)
+    {
+      while (child_i-- > 0)
+	clear_imp(a_p_children[child_i]);
+      __throw_exception_again;
+    }
+
+  new (p_ret) inode(p_icp->get_e_ind(), pref_begin(a_p_children[0]));
+
+  --child_i;
+  _GLIBCXX_DEBUG_ASSERT(child_i >= 1);
+  do
+    p_ret->add_child(a_p_children[child_i], pref_begin(a_p_children[child_i]),
+		     pref_end(a_p_children[child_i]), this);
+  while (child_i-- > 0);
+  apply_update(p_ret, (node_update*)this);
+  return p_ret;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp
new file mode 100644
index 0000000..f632531
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp
@@ -0,0 +1,115 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/debug_fn_imps.hpp
+ * Contains an implementation class for pat_trie_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  if (m_p_head->m_p_parent != 0)
+    m_p_head->m_p_parent->assert_valid(this, __file, __line);
+  assert_iterators(__file, __line);
+  assert_reverse_iterators(__file, __line);
+  if (m_p_head->m_p_parent == 0)
+    {
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_min == m_p_head);
+      PB_DS_DEBUG_VERIFY(m_p_head->m_p_max == m_p_head);
+      PB_DS_DEBUG_VERIFY(empty());
+      return;
+    }
+
+  PB_DS_DEBUG_VERIFY(m_p_head->m_p_min->m_type == leaf_node);
+  PB_DS_DEBUG_VERIFY(m_p_head->m_p_max->m_type == leaf_node);
+  PB_DS_DEBUG_VERIFY(!empty());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_iterators(const char* __file, int __line) const
+{
+  size_type calc_size = 0;
+  for (const_iterator it = begin(); it != end(); ++it)
+    {
+      ++calc_size;
+      debug_base::check_key_exists(PB_DS_V2F(*it), __file, __line);
+      PB_DS_DEBUG_VERIFY(lower_bound(PB_DS_V2F(*it)) == it);
+      PB_DS_DEBUG_VERIFY(--upper_bound(PB_DS_V2F(*it)) == it);
+    }
+  PB_DS_DEBUG_VERIFY(calc_size == m_size);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_reverse_iterators(const char* __file, int __line) const
+{
+  size_type calc_size = 0;
+  for (const_reverse_iterator it = rbegin(); it != rend(); ++it)
+    {
+      ++calc_size;
+      node_const_pointer p_nd =
+	const_cast<PB_DS_CLASS_C_DEC*>(this)->find_imp(PB_DS_V2F(*it));
+      PB_DS_DEBUG_VERIFY(p_nd == it.m_p_nd);
+    }
+  PB_DS_DEBUG_VERIFY(calc_size == m_size);
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+recursive_count_leafs(node_const_pointer p_nd, const char* __file, int __line)
+{
+  if (p_nd == 0)
+    return (0);
+  if (p_nd->m_type == leaf_node)
+    return (1);
+  PB_DS_DEBUG_VERIFY(p_nd->m_type == i_node);
+  size_type ret = 0;
+  for (typename inode::const_iterator it = static_cast<inode_const_pointer>(p_nd)->begin();
+       it != static_cast<inode_const_pointer>(p_nd)->end();
+       ++it)
+    ret += recursive_count_leafs(*it, __file, __line);
+  return ret;
+}
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp
new file mode 100644
index 0000000..48907ea
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp
@@ -0,0 +1,315 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/erase_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase(key_const_reference r_key)
+{
+  node_pointer p_nd = find_imp(r_key);
+  if (p_nd == 0 || p_nd->m_type == i_node)
+    {
+      PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+      return false;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == leaf_node);
+  if (!synth_access_traits::equal_keys(PB_DS_V2F(reinterpret_cast<leaf_pointer>(p_nd)->value()), r_key))
+    {
+      PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+      return false;
+    }
+
+  PB_DS_CHECK_KEY_EXISTS(r_key)
+  erase_leaf(static_cast<leaf_pointer>(p_nd));
+  PB_DS_ASSERT_VALID((*this))
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_fixup(inode_pointer p_nd)
+{
+  _GLIBCXX_DEBUG_ASSERT(std::distance(p_nd->begin(), p_nd->end()) >= 1);
+  if (std::distance(p_nd->begin(), p_nd->end()) == 1)
+    {
+      node_pointer p_parent = p_nd->m_p_parent;
+      if (p_parent == m_p_head)
+	m_p_head->m_p_parent = *p_nd->begin();
+      else
+	{
+	  _GLIBCXX_DEBUG_ASSERT(p_parent->m_type == i_node);
+	  node_pointer p_new_child = *p_nd->begin();
+
+	  typedef inode_pointer inode_ptr;
+	  inode_ptr p_internal = static_cast<inode_ptr>(p_parent);
+	  p_internal->replace_child(p_new_child, pref_begin(p_new_child),
+				    pref_end(p_new_child), this);
+	}
+      (*p_nd->begin())->m_p_parent = p_nd->m_p_parent;
+      p_nd->~inode();
+      s_inode_allocator.deallocate(p_nd, 1);
+
+      if (p_parent == m_p_head)
+	return;
+
+      _GLIBCXX_DEBUG_ASSERT(p_parent->m_type == i_node);
+      p_nd = static_cast<inode_pointer>(p_parent);
+    }
+
+  while (true)
+    {
+      _GLIBCXX_DEBUG_ASSERT(std::distance(p_nd->begin(), p_nd->end()) > 1);
+      p_nd->update_prefixes(this);
+      apply_update(p_nd, (node_update*)this);
+      PB_DS_ASSERT_NODE_VALID(p_nd)
+      if (p_nd->m_p_parent->m_type == head_node)
+	return;
+
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_parent->m_type == i_node);
+
+      p_nd = static_cast<inode_pointer>(p_nd->m_p_parent);
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+actual_erase_leaf(leaf_pointer p_l)
+{
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  --m_size;
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_l->value())));
+  p_l->~leaf();
+  s_leaf_allocator.deallocate(p_l, 1);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  if (!empty())
+    {
+      clear_imp(m_p_head->m_p_parent);
+      m_size = 0;
+      initialize();
+      _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
+      PB_DS_ASSERT_VALID((*this))
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear_imp(node_pointer p_nd)
+{
+  if (p_nd->m_type == i_node)
+    {
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == i_node);
+      for (typename inode::iterator it =
+	     static_cast<inode_pointer>(p_nd)->begin();
+	   it != static_cast<inode_pointer>(p_nd)->end();
+	   ++it)
+	{
+	  node_pointer p_child =* it;
+	  clear_imp(p_child);
+	}
+      s_inode_allocator.deallocate(static_cast<inode_pointer>(p_nd), 1);
+      return;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == leaf_node);
+  static_cast<leaf_pointer>(p_nd)->~leaf();
+  s_leaf_allocator.deallocate(static_cast<leaf_pointer>(p_nd), 1);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+erase(const_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  if (it == end())
+    return it;
+
+  const_iterator ret_it = it;
+  ++ret_it;
+  _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
+  erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+erase(iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  if (it == end())
+    return it;
+  iterator ret_it = it;
+  ++ret_it;
+  _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
+  erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reverse_iterator
+PB_DS_CLASS_C_DEC::
+erase(const_reverse_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  if (it.m_p_nd == m_p_head)
+    return it;
+  const_reverse_iterator ret_it = it;
+  ++ret_it;
+
+  _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
+  erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::reverse_iterator
+PB_DS_CLASS_C_DEC::
+erase(reverse_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  if (it.m_p_nd == m_p_head)
+    return it;
+  reverse_iterator ret_it = it;
+  ++ret_it;
+
+  _GLIBCXX_DEBUG_ASSERT(it.m_p_nd->m_type == leaf_node);
+  erase_leaf(static_cast<leaf_pointer>(it.m_p_nd));
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  size_type num_ersd = 0;
+  PB_DS_ASSERT_VALID((*this))
+
+  iterator it = begin();
+  while (it != end())
+    {
+      PB_DS_ASSERT_VALID((*this))
+      if (pred(*it))
+	{
+	  ++num_ersd;
+	  it = erase(it);
+	}
+      else
+	++it;
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+  return num_ersd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_leaf(leaf_pointer p_l)
+{
+  update_min_max_for_erased_leaf(p_l);
+  if (p_l->m_p_parent->m_type == head_node)
+    {
+      _GLIBCXX_DEBUG_ASSERT(size() == 1);
+      clear();
+      return;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(size() > 1);
+  _GLIBCXX_DEBUG_ASSERT(p_l->m_p_parent->m_type == i_node);
+
+  inode_pointer p_parent = static_cast<inode_pointer>(p_l->m_p_parent);
+
+  p_parent->remove_child(p_l);
+  erase_fixup(p_parent);
+  actual_erase_leaf(p_l);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+update_min_max_for_erased_leaf(leaf_pointer p_l)
+{
+  if (m_size == 1)
+    {
+      m_p_head->m_p_min = m_p_head;
+      m_p_head->m_p_max = m_p_head;
+      return;
+    }
+
+  if (p_l == static_cast<leaf_const_pointer>(m_p_head->m_p_min))
+    {
+      iterator it(p_l);
+      ++it;
+      m_p_head->m_p_min = it.m_p_nd;
+      return;
+    }
+
+  if (p_l == static_cast<leaf_const_pointer>(m_p_head->m_p_max))
+    {
+      iterator it(p_l);
+      --it;
+      m_p_head->m_p_max = it.m_p_nd;
+    }
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp
new file mode 100644
index 0000000..a5ca850
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp
@@ -0,0 +1,269 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/find_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key)
+{
+  PB_DS_ASSERT_VALID((*this))
+  node_pointer p_nd = find_imp(r_key);
+
+  if (p_nd == 0 || p_nd->m_type != leaf_node)
+    {
+      PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+      return end();
+    }
+
+  if (synth_access_traits::equal_keys(PB_DS_V2F(static_cast<leaf_pointer>(p_nd)->value()), r_key))
+    {
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      return iterator(p_nd);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+  return end();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key) const
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  node_const_pointer p_nd = const_cast<PB_DS_CLASS_C_DEC* >(this)->find_imp(r_key);
+
+  if (p_nd == 0 || p_nd->m_type != leaf_node)
+    {
+      PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+      return end();
+    }
+
+  if (synth_access_traits::equal_keys(PB_DS_V2F(static_cast<leaf_const_pointer>(p_nd)->value()), r_key))
+    {
+      PB_DS_CHECK_KEY_EXISTS(r_key)
+      return const_iterator(const_cast<node_pointer>(p_nd));
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(r_key)
+  return end();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+find_imp(key_const_reference r_key)
+{
+  if (empty())
+    return 0;
+
+  typename synth_access_traits::const_iterator b_it =
+    synth_access_traits::begin(r_key);
+  typename synth_access_traits::const_iterator e_it =
+    synth_access_traits::end(r_key);
+
+  node_pointer p_nd = m_p_head->m_p_parent;
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+
+  while (p_nd->m_type != leaf_node)
+    {
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == i_node);
+      node_pointer p_next_nd = static_cast<inode_pointer>(p_nd)->get_child_node(b_it,  e_it,  this);
+
+      if (p_next_nd == 0)
+	return p_nd;
+      p_nd = p_next_nd;
+    }
+  return p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+lower_bound_imp(key_const_reference r_key)
+{
+  if (empty())
+    return (m_p_head);
+
+  node_pointer p_nd = m_p_head->m_p_parent;
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+
+  typename PB_DS_CLASS_C_DEC::a_const_iterator b_it =
+    synth_access_traits::begin(r_key);
+
+  typename PB_DS_CLASS_C_DEC::a_const_iterator e_it =
+    synth_access_traits::end(r_key);
+
+  size_type checked_ind = 0;
+  while (true)
+    {
+      if (p_nd->m_type == leaf_node)
+        {
+	  if (!synth_access_traits::cmp_keys(PB_DS_V2F(static_cast<leaf_const_pointer>(p_nd)->value()), r_key))
+	    return p_nd;
+	  iterator it(p_nd);
+	  ++it;
+	  return it.m_p_nd;
+        }
+
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == i_node);
+      const size_type new_checked_ind =
+	static_cast<inode_pointer>(p_nd)->get_e_ind();
+
+      p_nd =
+	static_cast<inode_pointer>(p_nd)->get_lower_bound_child_node(                b_it, e_it, checked_ind, this);
+      checked_ind = new_checked_ind;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+lower_bound(key_const_reference r_key)
+{ return point_iterator(lower_bound_imp(r_key)); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+lower_bound(key_const_reference r_key) const
+{
+  return point_const_iterator(const_cast<PB_DS_CLASS_C_DEC* >(this)->lower_bound_imp(r_key));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+upper_bound(key_const_reference r_key)
+{
+  point_iterator l_bound_it = lower_bound(r_key);
+
+  _GLIBCXX_DEBUG_ASSERT(l_bound_it == end() ||
+		   !synth_access_traits::cmp_keys(PB_DS_V2F(*l_bound_it),
+						    r_key));
+
+  if (l_bound_it == end() ||
+      synth_access_traits::cmp_keys(r_key, PB_DS_V2F(*l_bound_it)))
+    return l_bound_it;
+
+  return ++l_bound_it;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+upper_bound(key_const_reference r_key) const
+{
+  point_const_iterator l_bound_it = lower_bound(r_key);
+
+  _GLIBCXX_DEBUG_ASSERT(l_bound_it == end() ||
+		   !synth_access_traits::cmp_keys(PB_DS_V2F(*l_bound_it),
+						    r_key));
+
+  if (l_bound_it == end() ||
+      synth_access_traits::cmp_keys(r_key, PB_DS_V2F(*l_bound_it)))
+    return l_bound_it;
+  return ++l_bound_it;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::a_const_iterator
+PB_DS_CLASS_C_DEC::
+pref_begin(node_const_pointer p_nd)
+{
+  if (p_nd->m_type == leaf_node)
+    return (synth_access_traits::begin(PB_DS_V2F(static_cast<leaf_const_pointer>(p_nd)->value())));
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == i_node);
+  return static_cast<inode_const_pointer>(p_nd)->pref_b_it();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::a_const_iterator
+PB_DS_CLASS_C_DEC::
+pref_end(node_const_pointer p_nd)
+{
+  if (p_nd->m_type == leaf_node)
+    return (synth_access_traits::end(PB_DS_V2F(static_cast<leaf_const_pointer>(p_nd)->value())));
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == i_node);
+  return static_cast<inode_const_pointer>(p_nd)->pref_e_it();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::leaf_const_pointer
+PB_DS_CLASS_C_DEC::
+leftmost_descendant(node_const_pointer p_nd)
+{
+  if (p_nd->m_type == leaf_node)
+    return static_cast<leaf_const_pointer>(p_nd);
+  return static_cast<inode_const_pointer>(p_nd)->leftmost_descendant();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::leaf_pointer
+PB_DS_CLASS_C_DEC::
+leftmost_descendant(node_pointer p_nd)
+{
+  if (p_nd->m_type == leaf_node)
+    return static_cast<leaf_pointer>(p_nd);
+  return static_cast<inode_pointer>(p_nd)->leftmost_descendant();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::leaf_const_pointer
+PB_DS_CLASS_C_DEC::
+rightmost_descendant(node_const_pointer p_nd)
+{
+  if (p_nd->m_type == leaf_node)
+    return static_cast<leaf_const_pointer>(p_nd);
+  return static_cast<inode_const_pointer>(p_nd)->rightmost_descendant();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::leaf_pointer
+PB_DS_CLASS_C_DEC::
+rightmost_descendant(node_pointer p_nd)
+{
+  if (p_nd->m_type == leaf_node)
+    return static_cast<leaf_pointer>(p_nd);
+  return static_cast<inode_pointer>(p_nd)->rightmost_descendant();
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/info_fn_imps.hpp
new file mode 100644
index 0000000..505b054
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/info_fn_imps.hpp
@@ -0,0 +1,58 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/info_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+empty() const
+{ return (m_size == 0); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+size() const
+{ return m_size; }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+max_size() const
+{ return s_inode_allocator.max_size(); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp
new file mode 100644
index 0000000..e22b81c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp
@@ -0,0 +1,472 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/insert_join_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  branch_bag bag;
+  if (!join_prep(other, bag))
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  m_p_head->m_p_parent = rec_join(m_p_head->m_p_parent,
+				  other.m_p_head->m_p_parent, 0, bag);
+
+  m_p_head->m_p_parent->m_p_parent = m_p_head;
+  m_size += other.m_size;
+  other.initialize();
+  PB_DS_ASSERT_VALID(other)
+  m_p_head->m_p_min = leftmost_descendant(m_p_head->m_p_parent);
+  m_p_head->m_p_max = rightmost_descendant(m_p_head->m_p_parent);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+join_prep(PB_DS_CLASS_C_DEC& other, branch_bag& r_bag)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  if (other.m_size == 0)
+    return false;
+
+  if (m_size == 0)
+    {
+      value_swap(other);
+      return false;
+    }
+
+  const bool greater =
+    synth_access_traits::cmp_keys(PB_DS_V2F(static_cast<leaf_const_pointer>(m_p_head->m_p_max)->value()),
+				    PB_DS_V2F(static_cast<leaf_const_pointer>(other.m_p_head->m_p_min)->value()));
+
+  const bool lesser =
+    synth_access_traits::cmp_keys(PB_DS_V2F(static_cast<leaf_const_pointer>(other.m_p_head->m_p_max)->value()),
+				    PB_DS_V2F(static_cast<leaf_const_pointer>(m_p_head->m_p_min)->value()));
+
+  if (!greater && !lesser)
+    __throw_join_error();
+
+  rec_join_prep(m_p_head->m_p_parent, other.m_p_head->m_p_parent, r_bag);
+  _GLIBCXX_DEBUG_ONLY(debug_base::join(other, false);)
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rec_join_prep(node_const_pointer p_l, node_const_pointer p_r, 
+	      branch_bag& r_bag)
+{
+  if (p_l->m_type == leaf_node)
+    {
+      if (p_r->m_type == leaf_node)
+	{
+	  rec_join_prep(static_cast<leaf_const_pointer>(p_l),
+			static_cast<leaf_const_pointer>(p_r), r_bag);
+	  return;
+	}
+
+      _GLIBCXX_DEBUG_ASSERT(p_r->m_type == i_node);
+      rec_join_prep(static_cast<leaf_const_pointer>(p_l),
+		    static_cast<inode_const_pointer>(p_r), r_bag);
+      return;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_l->m_type == i_node);
+  if (p_r->m_type == leaf_node)
+    {
+      rec_join_prep(static_cast<inode_const_pointer>(p_l),
+		    static_cast<leaf_const_pointer>(p_r), r_bag);
+      return;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_r->m_type == i_node);
+
+  rec_join_prep(static_cast<inode_const_pointer>(p_l),
+		static_cast<inode_const_pointer>(p_r), r_bag);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rec_join_prep(leaf_const_pointer /*p_l*/, leaf_const_pointer /*p_r*/,
+	      branch_bag& r_bag)
+{ r_bag.add_branch(); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rec_join_prep(leaf_const_pointer /*p_l*/, inode_const_pointer /*p_r*/,
+	      branch_bag& r_bag)
+{ r_bag.add_branch(); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rec_join_prep(inode_const_pointer /*p_l*/, leaf_const_pointer /*p_r*/,
+	      branch_bag& r_bag)
+{ r_bag.add_branch(); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rec_join_prep(inode_const_pointer p_l, inode_const_pointer p_r,
+	      branch_bag& r_bag)
+{
+  if (p_l->get_e_ind() == p_r->get_e_ind() &&
+      synth_access_traits::equal_prefixes(p_l->pref_b_it(), p_l->pref_e_it(),
+					    p_r->pref_b_it(), p_r->pref_e_it()))
+    {
+      for (typename inode::const_iterator it = p_r->begin();
+	   it != p_r->end(); ++ it)
+	{
+	  node_const_pointer p_l_join_child = p_l->get_join_child(*it, this);
+	  if (p_l_join_child != 0)
+	    rec_join_prep(p_l_join_child, * it, r_bag);
+	}
+      return;
+    }
+
+  if (p_r->get_e_ind() < p_l->get_e_ind() &&
+      p_r->should_be_mine(p_l->pref_b_it(), p_l->pref_e_it(), 0, this))
+    {
+      node_const_pointer p_r_join_child = p_r->get_join_child(p_l, this);
+      if (p_r_join_child != 0)
+	rec_join_prep(p_r_join_child, p_l, r_bag);
+      return;
+    }
+
+  if (p_r->get_e_ind() < p_l->get_e_ind() &&
+      p_r->should_be_mine(p_l->pref_b_it(), p_l->pref_e_it(), 0, this))
+    {
+      node_const_pointer p_r_join_child = p_r->get_join_child(p_l, this);
+      if (p_r_join_child != 0)
+	rec_join_prep(p_r_join_child, p_l, r_bag);
+      return;
+    }
+  r_bag.add_branch();
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+rec_join(node_pointer p_l, node_pointer p_r, size_type checked_ind, 
+	 branch_bag& r_bag)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
+  if (p_l == 0)
+    {
+      apply_update(p_r, (node_update*)this);
+      return (p_r);
+    }
+
+  if (p_l->m_type == leaf_node)
+    {
+      if (p_r->m_type == leaf_node)
+	{
+	  node_pointer p_ret = rec_join(static_cast<leaf_pointer>(p_l),
+					static_cast<leaf_pointer>(p_r), r_bag);
+	  apply_update(p_ret, (node_update*)this);
+	  return p_ret;
+	}
+
+      _GLIBCXX_DEBUG_ASSERT(p_r->m_type == i_node);
+      node_pointer p_ret = rec_join(static_cast<leaf_pointer>(p_l),
+				    static_cast<inode_pointer>(p_r),
+				    checked_ind, r_bag);
+      apply_update(p_ret, (node_update*)this);
+      return p_ret;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_l->m_type == i_node);
+  if (p_r->m_type == leaf_node)
+    {
+      node_pointer p_ret = rec_join(static_cast<inode_pointer>(p_l),
+				    static_cast<leaf_pointer>(p_r),
+				    checked_ind, r_bag);
+      apply_update(p_ret, (node_update*)this);
+      return p_ret;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_r->m_type == i_node);
+  node_pointer p_ret = rec_join(static_cast<inode_pointer>(p_l),
+				static_cast<inode_pointer>(p_r),
+				r_bag);
+
+  apply_update(p_ret, (node_update*)this);
+  return p_ret;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+rec_join(leaf_pointer p_l, leaf_pointer p_r, branch_bag& r_bag)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
+  if (p_l == 0)
+    return (p_r);
+  node_pointer p_ret = insert_branch(p_l, p_r, r_bag);
+  _GLIBCXX_DEBUG_ASSERT(PB_DS_RECURSIVE_COUNT_LEAFS(p_ret) == 2);
+  return p_ret;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+rec_join(leaf_pointer p_l, inode_pointer p_r, size_type checked_ind,
+	 branch_bag& r_bag)
+{
+#ifdef _GLIBCXX_DEBUG
+  const size_type lhs_leafs = PB_DS_RECURSIVE_COUNT_LEAFS(p_l);
+  const size_type rhs_leafs = PB_DS_RECURSIVE_COUNT_LEAFS(p_r);
+#endif
+
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
+  node_pointer p_ret = rec_join(p_r, p_l, checked_ind, r_bag);
+  _GLIBCXX_DEBUG_ASSERT(PB_DS_RECURSIVE_COUNT_LEAFS(p_ret) == lhs_leafs + rhs_leafs);
+  return p_ret;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+rec_join(inode_pointer p_l, leaf_pointer p_r, size_type checked_ind, branch_bag& r_bag)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_l != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
+
+#ifdef _GLIBCXX_DEBUG
+  const size_type lhs_leafs = PB_DS_RECURSIVE_COUNT_LEAFS(p_l);
+  const size_type rhs_leafs = PB_DS_RECURSIVE_COUNT_LEAFS(p_r);
+#endif
+
+  if (!p_l->should_be_mine(pref_begin(p_r), pref_end(p_r), checked_ind, this))
+    {
+      node_pointer p_ret = insert_branch(p_l, p_r, r_bag);
+      PB_DS_ASSERT_NODE_VALID(p_ret)
+      _GLIBCXX_DEBUG_ASSERT(PB_DS_RECURSIVE_COUNT_LEAFS(p_ret) ==
+       			    lhs_leafs + rhs_leafs);
+      return p_ret;
+    }
+
+  node_pointer p_pot_child = p_l->add_child(p_r, pref_begin(p_r),
+					    pref_end(p_r), this);
+  if (p_pot_child != p_r)
+    {
+      node_pointer p_new_child = rec_join(p_pot_child, p_r, p_l->get_e_ind(),
+					  r_bag);
+
+      p_l->replace_child(p_new_child, pref_begin(p_new_child),
+			 pref_end(p_new_child), this);
+    }
+
+  PB_DS_ASSERT_NODE_VALID(p_l)
+  _GLIBCXX_DEBUG_ASSERT(PB_DS_RECURSIVE_COUNT_LEAFS(p_l) == lhs_leafs + rhs_leafs);
+  return p_l;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+rec_join(inode_pointer p_l, inode_pointer p_r, 
+	 branch_bag& r_bag)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_l != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_r != 0);
+
+#ifdef _GLIBCXX_DEBUG
+  const size_type lhs_leafs = PB_DS_RECURSIVE_COUNT_LEAFS(p_l);
+  const size_type rhs_leafs = PB_DS_RECURSIVE_COUNT_LEAFS(p_r);
+#endif
+
+  if (p_l->get_e_ind() == p_r->get_e_ind() &&
+      synth_access_traits::equal_prefixes(p_l->pref_b_it(), p_l->pref_e_it(),
+					    p_r->pref_b_it(), p_r->pref_e_it()))
+    {
+      for (typename inode::iterator it = p_r->begin();
+	   it != p_r->end(); ++ it)
+	{
+	  node_pointer p_new_child = rec_join(p_l->get_join_child(*it, this),
+					      * it, 0, r_bag);
+	  p_l->replace_child(p_new_child, pref_begin(p_new_child),
+			     pref_end(p_new_child), this);
+	}
+
+      p_r->~inode();
+      s_inode_allocator.deallocate(p_r, 1);
+      PB_DS_ASSERT_NODE_VALID(p_l)
+      _GLIBCXX_DEBUG_ASSERT(PB_DS_RECURSIVE_COUNT_LEAFS(p_l) == lhs_leafs + rhs_leafs);
+      return p_l;
+    }
+
+  if (p_l->get_e_ind() < p_r->get_e_ind() &&
+      p_l->should_be_mine(p_r->pref_b_it(), p_r->pref_e_it(), 0, this))
+    {
+      node_pointer p_new_child = rec_join(p_l->get_join_child(p_r, this),
+					  p_r, 0, r_bag);
+      p_l->replace_child(p_new_child, pref_begin(p_new_child),
+			 pref_end(p_new_child), this);
+      PB_DS_ASSERT_NODE_VALID(p_l)
+      return p_l;
+    }
+
+  if (p_r->get_e_ind() < p_l->get_e_ind() &&
+      p_r->should_be_mine(p_l->pref_b_it(), p_l->pref_e_it(), 0, this))
+    {
+      node_pointer p_new_child = rec_join(p_r->get_join_child(p_l, this), p_l,
+					  0, r_bag);
+
+      p_r->replace_child(p_new_child, pref_begin(p_new_child),
+			 pref_end(p_new_child), this);
+
+      PB_DS_ASSERT_NODE_VALID(p_r)
+      _GLIBCXX_DEBUG_ASSERT(PB_DS_RECURSIVE_COUNT_LEAFS(p_r) == lhs_leafs + rhs_leafs);
+      return p_r;
+    }
+
+  node_pointer p_ret = insert_branch(p_l, p_r, r_bag);
+  PB_DS_ASSERT_NODE_VALID(p_ret)
+  _GLIBCXX_DEBUG_ASSERT(PB_DS_RECURSIVE_COUNT_LEAFS(p_ret) == lhs_leafs + rhs_leafs);
+  return p_ret;
+}
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert(const_reference r_val)
+{
+  node_pointer p_lf = find_imp(PB_DS_V2F(r_val));
+  if (p_lf != 0 && p_lf->m_type == leaf_node &&
+      synth_access_traits::equal_keys(PB_DS_V2F(static_cast<leaf_pointer>(p_lf)->value()), PB_DS_V2F(r_val)))
+    {
+      PB_DS_CHECK_KEY_EXISTS(PB_DS_V2F(r_val))
+      PB_DS_ASSERT_VALID((*this))
+      return std::make_pair(iterator(p_lf), false);
+    }
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(PB_DS_V2F(r_val))
+
+  leaf_pointer p_new_lf = s_leaf_allocator.allocate(1);
+  cond_dealtor cond(p_new_lf);
+
+  new (p_new_lf) leaf(r_val);
+  apply_update(p_new_lf, (node_update*)this);
+  cond.set_call_destructor();
+  branch_bag bag;
+  bag.add_branch();
+  m_p_head->m_p_parent = rec_join(m_p_head->m_p_parent, p_new_lf, 0, bag);
+  m_p_head->m_p_parent->m_p_parent = m_p_head;
+  cond.set_no_action_dtor();
+  ++m_size;
+  update_min_max_for_inserted_leaf(p_new_lf);
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
+  PB_DS_ASSERT_VALID((*this))
+  return std::make_pair(point_iterator(p_new_lf), true);
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+keys_diff_ind(typename access_traits::const_iterator b_l,
+	      typename access_traits::const_iterator e_l,
+	      typename access_traits::const_iterator b_r,
+	      typename access_traits::const_iterator e_r)
+{
+  size_type diff_pos = 0;
+  while (b_l != e_l)
+    {
+      if (b_r == e_r)
+	return (diff_pos);
+      if (access_traits::e_pos(*b_l) != access_traits::e_pos(*b_r))
+	return (diff_pos);
+      ++b_l;
+      ++b_r;
+      ++diff_pos;
+    }
+  _GLIBCXX_DEBUG_ASSERT(b_r != e_r);
+  return diff_pos;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::inode_pointer
+PB_DS_CLASS_C_DEC::
+insert_branch(node_pointer p_l, node_pointer p_r, branch_bag& r_bag)
+{
+  typename synth_access_traits::const_iterator left_b_it = pref_begin(p_l);
+  typename synth_access_traits::const_iterator left_e_it = pref_end(p_l);
+  typename synth_access_traits::const_iterator right_b_it = pref_begin(p_r);
+  typename synth_access_traits::const_iterator right_e_it = pref_end(p_r);
+
+  const size_type diff_ind = keys_diff_ind(left_b_it, left_e_it,
+					   right_b_it, right_e_it);
+
+  inode_pointer p_new_nd = r_bag.get_branch();
+  new (p_new_nd) inode(diff_ind, left_b_it);
+  p_new_nd->add_child(p_l, left_b_it, left_e_it, this);
+  p_new_nd->add_child(p_r, right_b_it, right_e_it, this);
+  p_l->m_p_parent = p_new_nd;
+  p_r->m_p_parent = p_new_nd;
+  PB_DS_ASSERT_NODE_VALID(p_new_nd)
+  return (p_new_nd);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+update_min_max_for_inserted_leaf(leaf_pointer p_new_lf)
+{
+  if (m_p_head->m_p_min == m_p_head ||
+      synth_access_traits::cmp_keys(PB_DS_V2F(p_new_lf->value()),
+				      PB_DS_V2F(static_cast<leaf_const_pointer>(m_p_head->m_p_min)->value())))
+    m_p_head->m_p_min = p_new_lf;
+
+  if (m_p_head->m_p_max == m_p_head ||
+      synth_access_traits::cmp_keys(PB_DS_V2F(static_cast<leaf_const_pointer>(m_p_head->m_p_max)->value()), PB_DS_V2F(p_new_lf->value())))
+    m_p_head->m_p_max = p_new_lf;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp
new file mode 100644
index 0000000..97de417
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp
@@ -0,0 +1,120 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/iterators_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+begin()
+{ return iterator(m_p_head->m_p_min); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin() const
+{ return const_iterator(m_p_head->m_p_min); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+end()
+{ return iterator(m_p_head); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end() const
+{ return const_iterator(m_p_head); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reverse_iterator
+PB_DS_CLASS_C_DEC::
+rbegin() const
+{
+  if (empty())
+    return rend();
+  return --end();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::reverse_iterator
+PB_DS_CLASS_C_DEC::
+rbegin()
+{
+  if (empty())
+    return rend();
+  return --end();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::reverse_iterator
+PB_DS_CLASS_C_DEC::
+rend()
+{ return reverse_iterator(m_p_head); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reverse_iterator
+PB_DS_CLASS_C_DEC::
+rend() const
+{ return const_reverse_iterator(m_p_head); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+node_begin() const
+{ return node_const_iterator(m_p_head->m_p_parent, this); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+node_begin()
+{ return node_iterator(m_p_head->m_p_parent, this); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_const_iterator
+PB_DS_CLASS_C_DEC::
+node_end() const
+{ return node_const_iterator(0, this); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+node_end()
+{ return node_iterator(0, this); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp
new file mode 100644
index 0000000..7a498bf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp
@@ -0,0 +1,596 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/pat_trie_.hpp
+ * Contains an implementation class for a patricia tree.
+ */
+
+#include <iterator>
+#include <utility>
+#include <algorithm>
+#include <functional>
+#include <assert.h>
+#include <list>
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+#include <ext/pb_ds/detail/eq_fn/eq_by_less.hpp>
+#include <ext/pb_ds/detail/pat_trie_/synth_access_traits.hpp>
+#include <ext/pb_ds/detail/pat_trie_/pat_trie_base.hpp>
+#ifdef _GLIBCXX_DEBUG
+#include <ext/pb_ds/detail/debug_map_base.hpp>
+#endif
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+#define PB_DS_PAT_TRIE_NAME pat_trie_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+#define PB_DS_PAT_TRIE_NAME pat_trie_set
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Node_And_It_Traits, \
+	     typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    PB_DS_PAT_TRIE_NAME<Key, Mapped, Node_And_It_Traits, _Alloc>
+
+#define PB_DS_PAT_TRIE_TRAITS_BASE \
+    types_traits<Key, Mapped, _Alloc, false>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key,	eq_by_less<Key, std::less<Key> >, \
+		 typename _Alloc::template rebind<Key>::other::const_reference>
+#endif
+
+
+    /**
+     *  @brief PATRICIA trie.
+     *  @ingroup branch-detail
+     *
+     *  This implementation loosely borrows ideas from:
+     *  1) Fast Mergeable Integer Maps, Okasaki, Gill 1998
+     *  2) Ptset: Sets of integers implemented as Patricia trees,
+     *     Jean-Christophe Filliatr, 2000
+     */
+    template<typename Key, typename Mapped, typename Node_And_It_Traits,
+	     typename _Alloc>
+    class PB_DS_PAT_TRIE_NAME :
+#ifdef _GLIBCXX_DEBUG
+      public PB_DS_DEBUG_MAP_BASE_C_DEC,
+#endif
+      public Node_And_It_Traits::synth_access_traits,
+      public Node_And_It_Traits::node_update,
+      public PB_DS_PAT_TRIE_TRAITS_BASE,
+      public pat_trie_base
+    {
+    private:
+      typedef pat_trie_base				base_type;
+      typedef PB_DS_PAT_TRIE_TRAITS_BASE 	       	traits_base;
+      typedef Node_And_It_Traits			traits_type;
+
+      typedef typename traits_type::synth_access_traits synth_access_traits;
+      typedef typename synth_access_traits::const_iterator a_const_iterator;
+
+      typedef typename traits_type::node 		node;
+      typedef typename _Alloc::template rebind<node>	__rebind_n;
+      typedef typename __rebind_n::other::const_pointer node_const_pointer;
+      typedef typename __rebind_n::other::pointer 	node_pointer;
+
+      typedef typename traits_type::head 		head;
+      typedef typename _Alloc::template rebind<head>	__rebind_h;
+      typedef typename __rebind_h::other 		head_allocator;
+      typedef typename head_allocator::pointer 		head_pointer;
+
+      typedef typename traits_type::leaf 		leaf;
+      typedef typename _Alloc::template rebind<leaf>	__rebind_l;
+      typedef typename __rebind_l::other 		leaf_allocator;
+      typedef typename leaf_allocator::pointer 		leaf_pointer;
+      typedef typename leaf_allocator::const_pointer 	leaf_const_pointer;
+
+      typedef typename traits_type::inode 		inode;
+      typedef typename inode::iterator 			inode_iterator;
+      typedef typename _Alloc::template rebind<inode> 	__rebind_in;
+      typedef typename __rebind_in::other 		__rebind_ina;
+      typedef typename __rebind_in::other      	       	inode_allocator;
+      typedef typename __rebind_ina::pointer 		inode_pointer;
+      typedef typename __rebind_ina::const_pointer 	inode_const_pointer;
+
+
+      /// Conditional deallocator.
+      class cond_dealtor
+      {
+      protected:
+	leaf_pointer 		m_p_nd;
+	bool 			m_no_action_dtor;
+	bool 			m_call_destructor;
+
+      public:
+	cond_dealtor(leaf_pointer p_nd)
+	: m_p_nd(p_nd), m_no_action_dtor(false), m_call_destructor(false)
+	{ }
+
+	void
+	set_no_action_dtor()
+	{ m_no_action_dtor = true; }
+
+	void
+	set_call_destructor()
+	{ m_call_destructor = true; }
+
+	~cond_dealtor()
+	{
+	  if (m_no_action_dtor)
+	    return;
+
+	  if (m_call_destructor)
+	    m_p_nd->~leaf();
+
+	  s_leaf_allocator.deallocate(m_p_nd, 1);
+	}
+      };
+
+
+      /// Branch bag, for split-join.
+      class branch_bag
+      {
+      private:
+	typedef inode_pointer 			       	__inp;
+	typedef typename _Alloc::template rebind<__inp>::other 	__rebind_inp;
+
+#ifdef _GLIBCXX_DEBUG
+	typedef std::_GLIBCXX_STD_C::list<__inp, __rebind_inp> 	bag_type;
+#else
+	typedef std::list<__inp, __rebind_inp> 			bag_type;
+#endif
+
+	bag_type 						m_bag;
+      public:
+	void
+	add_branch()
+	{
+	  inode_pointer p_nd = s_inode_allocator.allocate(1);
+	  __try
+	    {
+	      m_bag.push_back(p_nd);
+	    }
+	  __catch(...)
+	    {
+	      s_inode_allocator.deallocate(p_nd, 1);
+	      __throw_exception_again;
+	    }
+	}
+
+	inode_pointer
+	get_branch()
+	{
+	  _GLIBCXX_DEBUG_ASSERT(!m_bag.empty());
+	  inode_pointer p_nd = *m_bag.begin();
+	  m_bag.pop_front();
+	  return p_nd;
+	}
+
+	~branch_bag()
+	{
+	  while (!m_bag.empty())
+	    {
+	      inode_pointer p_nd = *m_bag.begin();
+	      s_inode_allocator.deallocate(p_nd, 1);
+	      m_bag.pop_front();
+	    }
+	}
+
+	inline bool
+	empty() const
+	{ return m_bag.empty(); }
+      };
+
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC 		debug_base;
+#endif
+
+      typedef typename traits_type::null_node_update_pointer null_node_update_pointer;
+
+    public:
+      typedef pat_trie_tag 				container_category;
+      typedef _Alloc 					allocator_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+
+      typedef typename traits_base::key_type 		key_type;
+      typedef typename traits_base::key_pointer 	key_pointer;
+      typedef typename traits_base::key_const_pointer 	key_const_pointer;
+      typedef typename traits_base::key_reference 	key_reference;
+      typedef typename traits_base::key_const_reference key_const_reference;
+      typedef typename traits_base::mapped_type 	mapped_type;
+      typedef typename traits_base::mapped_pointer 	mapped_pointer;
+      typedef typename traits_base::mapped_const_pointer mapped_const_pointer;
+      typedef typename traits_base::mapped_reference 	mapped_reference;
+      typedef typename traits_base::mapped_const_reference mapped_const_reference;
+      typedef typename traits_base::value_type 		value_type;
+      typedef typename traits_base::pointer 		pointer;
+      typedef typename traits_base::const_pointer 	const_pointer;
+      typedef typename traits_base::reference 		reference;
+      typedef typename traits_base::const_reference 	const_reference;
+
+      typedef typename traits_type::access_traits 	access_traits;
+      typedef typename traits_type::const_iterator 	point_const_iterator;
+      typedef typename traits_type::iterator 		point_iterator;
+      typedef point_const_iterator 			const_iterator;
+      typedef point_iterator 				iterator;
+
+      typedef typename traits_type::reverse_iterator 	reverse_iterator;
+      typedef typename traits_type::const_reverse_iterator const_reverse_iterator;
+      typedef typename traits_type::node_const_iterator node_const_iterator;
+      typedef typename traits_type::node_iterator 	node_iterator;
+      typedef typename traits_type::node_update 	node_update;
+
+      PB_DS_PAT_TRIE_NAME();
+
+      PB_DS_PAT_TRIE_NAME(const access_traits&);
+
+      PB_DS_PAT_TRIE_NAME(const PB_DS_CLASS_C_DEC&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      ~PB_DS_PAT_TRIE_NAME();
+
+      inline bool
+      empty() const;
+
+      inline size_type
+      size() const;
+
+      inline size_type
+      max_size() const;
+
+      access_traits&
+      get_access_traits();
+
+      const access_traits&
+      get_access_traits() const;
+
+      node_update&
+      get_node_update();
+
+      const node_update&
+      get_node_update() const;
+
+      inline std::pair<point_iterator, bool>
+      insert(const_reference);
+
+      inline mapped_reference
+      operator[](key_const_reference r_key)
+      {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+	return insert(std::make_pair(r_key, mapped_type())).first->second;
+#else
+	insert(r_key);
+	return traits_base::s_null_type;
+#endif
+      }
+
+      inline point_iterator
+      find(key_const_reference);
+
+      inline point_const_iterator
+      find(key_const_reference) const;
+
+      inline point_iterator
+      lower_bound(key_const_reference);
+
+      inline point_const_iterator
+      lower_bound(key_const_reference) const;
+
+      inline point_iterator
+      upper_bound(key_const_reference);
+
+      inline point_const_iterator
+      upper_bound(key_const_reference) const;
+
+      void
+      clear();
+
+      inline bool
+      erase(key_const_reference);
+
+      inline const_iterator
+      erase(const_iterator);
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      inline iterator
+      erase(iterator);
+#endif
+
+      inline const_reverse_iterator
+      erase(const_reverse_iterator);
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+      inline reverse_iterator
+      erase(reverse_iterator);
+#endif
+
+      template<typename Pred>
+      inline size_type
+      erase_if(Pred);
+
+      void
+      join(PB_DS_CLASS_C_DEC&);
+
+      void
+      split(key_const_reference, PB_DS_CLASS_C_DEC&);
+
+      inline iterator
+      begin();
+
+      inline const_iterator
+      begin() const;
+
+      inline iterator
+      end();
+
+      inline const_iterator
+      end() const;
+
+      inline reverse_iterator
+      rbegin();
+
+      inline const_reverse_iterator
+      rbegin() const;
+
+      inline reverse_iterator
+      rend();
+
+      inline const_reverse_iterator
+      rend() const;
+
+      /// Returns a const node_iterator corresponding to the node at the
+      /// root of the tree.
+      inline node_const_iterator
+      node_begin() const;
+
+      /// Returns a node_iterator corresponding to the node at the
+      /// root of the tree.
+      inline node_iterator
+      node_begin();
+
+      /// Returns a const node_iterator corresponding to a node just
+      /// after a leaf of the tree.
+      inline node_const_iterator
+      node_end() const;
+
+      /// Returns a node_iterator corresponding to a node just
+      /// after a leaf of the tree.
+      inline node_iterator
+      node_end();
+
+#ifdef PB_DS_PAT_TRIE_TRACE_
+      void
+      trace() const;
+#endif
+
+    protected:
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+      void
+      value_swap(PB_DS_CLASS_C_DEC&);
+
+      node_pointer
+      recursive_copy_node(node_const_pointer);
+
+    private:
+      void
+      initialize();
+
+      inline void
+      apply_update(node_pointer, null_node_update_pointer);
+
+      template<typename Node_Update_>
+      inline void
+      apply_update(node_pointer, Node_Update_*);
+
+      bool
+      join_prep(PB_DS_CLASS_C_DEC&, branch_bag&);
+
+      void
+      rec_join_prep(node_const_pointer, node_const_pointer, branch_bag&);
+
+      void
+      rec_join_prep(leaf_const_pointer, leaf_const_pointer, branch_bag&);
+
+      void
+      rec_join_prep(leaf_const_pointer, inode_const_pointer, branch_bag&);
+
+      void
+      rec_join_prep(inode_const_pointer, leaf_const_pointer, branch_bag&);
+
+      void
+      rec_join_prep(inode_const_pointer, inode_const_pointer, branch_bag&);
+
+      node_pointer
+      rec_join(node_pointer, node_pointer, size_type, branch_bag&);
+
+      node_pointer
+      rec_join(leaf_pointer, leaf_pointer, branch_bag&);
+
+      node_pointer
+      rec_join(leaf_pointer, inode_pointer, size_type, branch_bag&);
+
+      node_pointer
+      rec_join(inode_pointer, leaf_pointer, size_type, branch_bag&);
+
+      node_pointer
+      rec_join(inode_pointer, inode_pointer, branch_bag&);
+
+      size_type
+      keys_diff_ind(typename access_traits::const_iterator,
+		    typename access_traits::const_iterator,
+		    typename access_traits::const_iterator,
+		    typename access_traits::const_iterator);
+
+      inode_pointer
+      insert_branch(node_pointer, node_pointer, branch_bag&);
+
+      void
+      update_min_max_for_inserted_leaf(leaf_pointer);
+
+      void
+      erase_leaf(leaf_pointer);
+
+      inline void
+      actual_erase_leaf(leaf_pointer);
+
+      void
+      clear_imp(node_pointer);
+
+      void
+      erase_fixup(inode_pointer);
+
+      void
+      update_min_max_for_erased_leaf(leaf_pointer);
+
+      static inline a_const_iterator
+      pref_begin(node_const_pointer);
+
+      static inline a_const_iterator
+      pref_end(node_const_pointer);
+
+      inline node_pointer
+      find_imp(key_const_reference);
+
+      inline node_pointer
+      lower_bound_imp(key_const_reference);
+
+      inline node_pointer
+      upper_bound_imp(key_const_reference);
+
+      inline static leaf_const_pointer
+      leftmost_descendant(node_const_pointer);
+
+      inline static leaf_pointer
+      leftmost_descendant(node_pointer);
+
+      inline static leaf_const_pointer
+      rightmost_descendant(node_const_pointer);
+
+      inline static leaf_pointer
+      rightmost_descendant(node_pointer);
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+
+      void
+      assert_iterators(const char*, int) const;
+
+      void
+      assert_reverse_iterators(const char*, int) const;
+
+      static size_type
+      recursive_count_leafs(node_const_pointer, const char*, int);
+#endif
+
+#ifdef PB_DS_PAT_TRIE_TRACE_
+      static void
+      trace_node(node_const_pointer, size_type);
+
+      template<typename Metadata_>
+      static void
+      trace_node_metadata(node_const_pointer, type_to_type<Metadata_>);
+
+      static void
+      trace_node_metadata(node_const_pointer, type_to_type<null_type>);
+#endif
+
+      leaf_pointer
+      split_prep(key_const_reference, PB_DS_CLASS_C_DEC&, branch_bag&);
+
+      node_pointer
+      rec_split(node_pointer, a_const_iterator, a_const_iterator,
+		PB_DS_CLASS_C_DEC&, branch_bag&);
+
+      void
+      split_insert_branch(size_type, a_const_iterator, inode_iterator,
+			  size_type, branch_bag&);
+
+      static head_allocator 		s_head_allocator;
+      static inode_allocator 		s_inode_allocator;
+      static leaf_allocator 		s_leaf_allocator;
+
+      head_pointer 			m_p_head;
+      size_type 			m_size;
+    };
+
+#define PB_DS_ASSERT_NODE_VALID(X) \
+  _GLIBCXX_DEBUG_ONLY(X->assert_valid(this, __FILE__, __LINE__);)
+
+#define PB_DS_RECURSIVE_COUNT_LEAFS(X) \
+  recursive_count_leafs(X, __FILE__, __LINE__)
+
+#include <ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/info_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/policy_access_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp>
+#include <ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp>
+
+#undef PB_DS_RECURSIVE_COUNT_LEAFS
+#undef PB_DS_ASSERT_NODE_VALID
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_PAT_TRIE_NAME
+#undef PB_DS_PAT_TRIE_TRAITS_BASE
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_base.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_base.hpp
new file mode 100644
index 0000000..c14b1bc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_base.hpp
@@ -0,0 +1,1361 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/pat_trie_base.hpp
+ * Contains the base class for a patricia tree.
+ */
+
+#ifndef PB_DS_PAT_TRIE_BASE
+#define PB_DS_PAT_TRIE_BASE
+
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Base type for PATRICIA trees.
+    struct pat_trie_base
+    {
+      /**
+       *  @brief  Three types of nodes.
+       *
+       *  i_node is used by _Inode, leaf_node by _Leaf, and head_node by _Head.
+       */
+      enum node_type
+	{
+	  i_node,
+	  leaf_node,
+	  head_node
+	};
+
+      /// Metadata base primary template.
+      template<typename Metadata, typename _Alloc>
+	struct _Metadata
+	{
+	  typedef Metadata     					metadata_type;
+	  typedef _Alloc     					allocator_type;
+	  typedef typename _Alloc::template rebind<Metadata>	__rebind_m;
+	  typedef typename __rebind_m::other::const_reference  const_reference;
+
+	  const_reference
+	  get_metadata() const
+	  { return m_metadata; }
+
+	  metadata_type 					m_metadata;
+	};
+
+      /// Specialization for null metadata.
+      template<typename _Alloc>
+	struct _Metadata<null_type, _Alloc>
+	{
+	  typedef null_type 					metadata_type;
+	  typedef _Alloc     					allocator_type;
+	};
+
+
+      /// Node base.
+      template<typename _ATraits, typename Metadata>
+      struct _Node_base
+      : public Metadata
+      {
+      private:
+	typedef typename Metadata::allocator_type		_Alloc;
+
+      public:
+	typedef _Alloc						allocator_type;
+	typedef _ATraits					access_traits;
+	typedef typename _ATraits::type_traits			type_traits;
+	typedef typename _Alloc::template rebind<_Node_base>	__rebind_n;
+	typedef typename __rebind_n::other::pointer 		node_pointer;
+
+	node_pointer 						m_p_parent;
+	const node_type 	       				m_type;
+
+	_Node_base(node_type type) : m_type(type)
+	{ }
+
+	typedef typename _Alloc::template rebind<_ATraits>    __rebind_at;
+	typedef typename __rebind_at::other::const_pointer    a_const_pointer;
+	typedef typename _ATraits::const_iterator	      a_const_iterator;
+
+#ifdef _GLIBCXX_DEBUG
+	typedef std::pair<a_const_iterator, a_const_iterator> node_debug_info;
+
+	void
+	assert_valid(a_const_pointer p_traits,
+		     const char* __file, int __line) const
+	{ assert_valid_imp(p_traits, __file, __line); }
+
+	virtual node_debug_info
+	assert_valid_imp(a_const_pointer, const char*, int) const = 0;
+#endif
+      };
+
+
+    /// Head node for PATRICIA tree.
+    template<typename _ATraits, typename Metadata>
+    struct _Head
+    : public _Node_base<_ATraits, Metadata>
+    {
+      typedef _Node_base<_ATraits, Metadata> 			base_type;
+      typedef typename base_type::type_traits			type_traits;
+      typedef typename base_type::node_pointer			node_pointer;
+
+      node_pointer						m_p_min;
+      node_pointer						m_p_max;
+
+      _Head() : base_type(head_node) { }
+
+#ifdef _GLIBCXX_DEBUG
+      typedef typename base_type::node_debug_info      	       node_debug_info;
+      typedef typename base_type::a_const_pointer 	       a_const_pointer;
+
+      virtual node_debug_info
+      assert_valid_imp(a_const_pointer, const char* __file, int __line) const
+      {
+	_GLIBCXX_DEBUG_VERIFY_AT(false,
+				 _M_message("Assertion from %1;:%2;")
+				 ._M_string(__FILE__)._M_integer(__LINE__),
+				 __file, __line);
+	return node_debug_info();
+      }
+#endif
+    };
+
+
+    /// Leaf node for PATRICIA tree.
+    template<typename _ATraits, typename Metadata>
+    struct _Leaf
+    : public _Node_base<_ATraits, Metadata>
+    {
+      typedef _Node_base<_ATraits, Metadata> 	   	    	base_type;
+      typedef typename base_type::type_traits			type_traits;
+      typedef typename type_traits::value_type			value_type;
+      typedef typename type_traits::reference			reference;
+      typedef typename type_traits::const_reference    		const_reference;
+
+    private:
+      value_type						m_value;
+
+      _Leaf(const _Leaf&);
+
+    public:
+      _Leaf(const_reference other)
+      : base_type(leaf_node), m_value(other) { }
+
+      reference
+      value()
+      { return m_value; }
+
+      const_reference
+      value() const
+      { return m_value; }
+
+#ifdef _GLIBCXX_DEBUG
+      typedef typename base_type::node_debug_info      		node_debug_info;
+      typedef typename base_type::a_const_pointer      		a_const_pointer;
+
+      virtual node_debug_info
+      assert_valid_imp(a_const_pointer p_traits,
+		       const char* __file, int __line) const
+      {
+	PB_DS_DEBUG_VERIFY(base_type::m_type == leaf_node);
+	node_debug_info ret;
+	const_reference r_val = value();
+	return std::make_pair(p_traits->begin(p_traits->extract_key(r_val)),
+			      p_traits->end(p_traits->extract_key(r_val)));
+      }
+
+      virtual
+      ~_Leaf() { }
+#endif
+    };
+
+
+    /// Internal node type, PATRICIA tree.
+    template<typename _ATraits, typename Metadata>
+    struct _Inode
+    : public _Node_base<_ATraits, Metadata>
+    {
+      typedef _Node_base<_ATraits, Metadata> 			base_type;
+      typedef typename base_type::type_traits			type_traits;
+      typedef typename base_type::access_traits	       		access_traits;
+      typedef typename type_traits::value_type 			value_type;
+      typedef typename base_type::allocator_type		_Alloc;
+      typedef _Alloc						allocator_type;
+      typedef typename _Alloc::size_type 			size_type;
+
+    private:
+      typedef typename base_type::a_const_pointer      	       a_const_pointer;
+      typedef typename base_type::a_const_iterator     	      a_const_iterator;
+
+      typedef typename base_type::node_pointer			node_pointer;
+      typedef typename _Alloc::template rebind<base_type>	__rebind_n;
+      typedef typename __rebind_n::other::const_pointer      node_const_pointer;
+
+      typedef _Leaf<_ATraits, Metadata>	 			leaf;
+      typedef typename _Alloc::template rebind<leaf>::other 	__rebind_l;
+      typedef typename __rebind_l::pointer 			leaf_pointer;
+      typedef typename __rebind_l::const_pointer 	    leaf_const_pointer;
+
+      typedef typename _Alloc::template rebind<_Inode>::other 	__rebind_in;
+      typedef typename __rebind_in::pointer 			inode_pointer;
+      typedef typename __rebind_in::const_pointer 	    inode_const_pointer;
+
+      inline size_type
+      get_pref_pos(a_const_iterator, a_const_iterator, a_const_pointer) const;
+
+    public:
+      typedef typename _Alloc::template rebind<node_pointer>::other __rebind_np;
+      typedef typename __rebind_np::pointer 		node_pointer_pointer;
+      typedef typename __rebind_np::reference 		node_pointer_reference;
+
+      enum
+	{
+	  arr_size = _ATraits::max_size + 1
+	};
+      PB_DS_STATIC_ASSERT(min_arr_size, arr_size >= 2);
+
+
+      /// Constant child iterator.
+      struct const_iterator
+      {
+	node_pointer_pointer 				m_p_p_cur;
+	node_pointer_pointer 				m_p_p_end;
+
+	typedef std::forward_iterator_tag 		iterator_category;
+	typedef typename _Alloc::difference_type 	difference_type;
+	typedef node_pointer 				value_type;
+	typedef node_pointer_pointer 			pointer;
+	typedef node_pointer_reference 			reference;
+
+	const_iterator(node_pointer_pointer p_p_cur = 0,
+		       node_pointer_pointer p_p_end = 0)
+	: m_p_p_cur(p_p_cur), m_p_p_end(p_p_end)
+	{ }
+
+	bool
+	operator==(const const_iterator& other) const
+	{ return m_p_p_cur == other.m_p_p_cur; }
+
+	bool
+	operator!=(const const_iterator& other) const
+	{ return m_p_p_cur != other.m_p_p_cur; }
+
+	const_iterator&
+	operator++()
+	{
+	  do
+	    ++m_p_p_cur;
+	  while (m_p_p_cur != m_p_p_end && *m_p_p_cur == 0);
+	  return *this;
+	}
+
+	const_iterator
+	operator++(int)
+	{
+	  const_iterator ret_it(*this);
+	  operator++();
+	  return ret_it;
+	}
+
+	const node_pointer_pointer
+	operator->() const
+	{
+	  _GLIBCXX_DEBUG_ONLY(assert_referencible();)
+	  return m_p_p_cur;
+	}
+
+	node_const_pointer
+	operator*() const
+	{
+	  _GLIBCXX_DEBUG_ONLY(assert_referencible();)
+	  return *m_p_p_cur;
+	}
+
+      protected:
+#ifdef _GLIBCXX_DEBUG
+	void
+	assert_referencible() const
+	{ _GLIBCXX_DEBUG_ASSERT(m_p_p_cur != m_p_p_end && *m_p_p_cur != 0); }
+#endif
+      };
+
+
+      /// Child iterator.
+      struct iterator : public const_iterator
+      {
+      public:
+	typedef std::forward_iterator_tag 		iterator_category;
+	typedef typename _Alloc::difference_type 	difference_type;
+	typedef node_pointer 				value_type;
+	typedef node_pointer_pointer 			pointer;
+	typedef node_pointer_reference 			reference;
+
+	inline
+	iterator(node_pointer_pointer p_p_cur = 0,
+		 node_pointer_pointer p_p_end = 0)
+	: const_iterator(p_p_cur, p_p_end) { }
+
+	bool
+	operator==(const iterator& other) const
+	{ return const_iterator::m_p_p_cur == other.m_p_p_cur; }
+
+	bool
+	operator!=(const iterator& other) const
+	{ return const_iterator::m_p_p_cur != other.m_p_p_cur; }
+
+	iterator&
+	operator++()
+	{
+	  const_iterator::operator++();
+	  return *this;
+	}
+
+	iterator
+	operator++(int)
+	{
+	  iterator ret_it(*this);
+	  operator++();
+	  return ret_it;
+	}
+
+	node_pointer_pointer
+	operator->()
+	{
+	  _GLIBCXX_DEBUG_ONLY(const_iterator::assert_referencible();)
+	  return const_iterator::m_p_p_cur;
+	}
+
+	node_pointer
+	operator*()
+	{
+	  _GLIBCXX_DEBUG_ONLY(const_iterator::assert_referencible();)
+	  return *const_iterator::m_p_p_cur;
+	}
+      };
+
+
+      _Inode(size_type, const a_const_iterator);
+
+      void
+      update_prefixes(a_const_pointer);
+
+      const_iterator
+      begin() const;
+
+      iterator
+      begin();
+
+      const_iterator
+      end() const;
+
+      iterator
+      end();
+
+      inline node_pointer
+      get_child_node(a_const_iterator, a_const_iterator, a_const_pointer);
+
+      inline node_const_pointer
+      get_child_node(a_const_iterator, a_const_iterator, a_const_pointer) const;
+
+      inline iterator
+      get_child_it(a_const_iterator, a_const_iterator, a_const_pointer);
+
+      inline node_pointer
+      get_lower_bound_child_node(a_const_iterator, a_const_iterator,
+				 size_type, a_const_pointer);
+
+      inline node_pointer
+      add_child(node_pointer, a_const_iterator, a_const_iterator,
+		a_const_pointer);
+
+      inline node_const_pointer
+      get_join_child(node_const_pointer, a_const_pointer) const;
+
+      inline node_pointer
+      get_join_child(node_pointer, a_const_pointer);
+
+      void
+      remove_child(node_pointer);
+
+      void
+      remove_child(iterator);
+
+      void
+      replace_child(node_pointer, a_const_iterator, a_const_iterator,
+		    a_const_pointer);
+
+      inline a_const_iterator
+      pref_b_it() const;
+
+      inline a_const_iterator
+      pref_e_it() const;
+
+      bool
+      should_be_mine(a_const_iterator, a_const_iterator, size_type,
+		     a_const_pointer) const;
+
+      leaf_pointer
+      leftmost_descendant();
+
+      leaf_const_pointer
+      leftmost_descendant() const;
+
+      leaf_pointer
+      rightmost_descendant();
+
+      leaf_const_pointer
+      rightmost_descendant() const;
+
+#ifdef _GLIBCXX_DEBUG
+      typedef typename base_type::node_debug_info 	       node_debug_info;
+
+      virtual node_debug_info
+      assert_valid_imp(a_const_pointer, const char*, int) const;
+#endif
+
+      size_type
+      get_e_ind() const
+      { return m_e_ind; }
+
+    private:
+      _Inode(const _Inode&);
+
+      size_type
+      get_begin_pos() const;
+
+      static __rebind_l			s_leaf_alloc;
+      static __rebind_in 		s_inode_alloc;
+
+      const size_type 			m_e_ind;
+      a_const_iterator 			m_pref_b_it;
+      a_const_iterator 			m_pref_e_it;
+      node_pointer 			m_a_p_children[arr_size];
+    };
+
+#define PB_DS_CONST_IT_C_DEC \
+    _CIter<Node, Leaf, Head, Inode, Is_Forward_Iterator>
+
+#define PB_DS_CONST_ODIR_IT_C_DEC \
+    _CIter<Node, Leaf, Head, Inode, !Is_Forward_Iterator>
+
+#define PB_DS_IT_C_DEC \
+    _Iter<Node, Leaf, Head, Inode, Is_Forward_Iterator>
+
+#define PB_DS_ODIR_IT_C_DEC \
+    _Iter<Node, Leaf, Head, Inode, !Is_Forward_Iterator>
+
+
+    /// Const iterator.
+    template<typename Node, typename Leaf, typename Head, typename Inode,
+	     bool Is_Forward_Iterator>
+    class _CIter
+    {
+    public:
+      // These types are all the same for the first four template arguments.
+      typedef typename Node::allocator_type		allocator_type;
+      typedef typename Node::type_traits		type_traits;
+
+      typedef std::bidirectional_iterator_tag 		iterator_category;
+      typedef typename allocator_type::difference_type	difference_type;
+      typedef typename type_traits::value_type		value_type;
+      typedef typename type_traits::pointer 		pointer;
+      typedef typename type_traits::reference 		reference;
+      typedef typename type_traits::const_pointer 	const_pointer;
+      typedef typename type_traits::const_reference 	const_reference;
+
+      typedef allocator_type				_Alloc;
+      typedef typename _Alloc::template rebind<Node>	__rebind_n;
+      typedef typename __rebind_n::other::pointer	node_pointer;
+      typedef typename _Alloc::template rebind<Leaf>	__rebind_l;
+      typedef typename __rebind_l::other::pointer	leaf_pointer;
+      typedef typename __rebind_l::other::const_pointer	leaf_const_pointer;
+      typedef typename _Alloc::template rebind<Head>	__rebind_h;
+      typedef typename __rebind_h::other::pointer	head_pointer;
+
+      typedef typename _Alloc::template rebind<Inode> __rebind_in;
+      typedef typename __rebind_in::other::pointer 	inode_pointer;
+      typedef typename Inode::iterator			inode_iterator;
+
+      node_pointer 					m_p_nd;
+
+      _CIter(node_pointer p_nd = 0) : m_p_nd(p_nd)
+      { }
+
+      _CIter(const PB_DS_CONST_ODIR_IT_C_DEC& other)
+      : m_p_nd(other.m_p_nd)
+      { }
+
+      _CIter&
+      operator=(const _CIter& other)
+      {
+	m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      _CIter&
+      operator=(const PB_DS_CONST_ODIR_IT_C_DEC& other)
+      {
+	m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      const_pointer
+      operator->() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == leaf_node);
+	return &static_cast<leaf_pointer>(m_p_nd)->value();
+      }
+
+      const_reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == leaf_node);
+	return static_cast<leaf_pointer>(m_p_nd)->value();
+      }
+
+      bool
+      operator==(const _CIter& other) const
+      { return m_p_nd == other.m_p_nd; }
+
+      bool
+      operator==(const PB_DS_CONST_ODIR_IT_C_DEC& other) const
+      { return m_p_nd == other.m_p_nd; }
+
+      bool
+      operator!=(const _CIter& other) const
+      { return m_p_nd != other.m_p_nd; }
+
+      bool
+      operator!=(const PB_DS_CONST_ODIR_IT_C_DEC& other) const
+      { return m_p_nd != other.m_p_nd; }
+
+      _CIter&
+      operator++()
+      {
+	inc(integral_constant<int, Is_Forward_Iterator>());
+	return *this;
+      }
+
+      _CIter
+      operator++(int)
+      {
+	_CIter ret_it(m_p_nd);
+	operator++();
+	return ret_it;
+      }
+
+      _CIter&
+      operator--()
+      {
+	dec(integral_constant<int, Is_Forward_Iterator>());
+	return *this;
+      }
+
+      _CIter
+      operator--(int)
+      {
+	_CIter ret_it(m_p_nd);
+	operator--();
+	return ret_it;
+      }
+
+    protected:
+      void
+      inc(false_type)
+      { dec(true_type()); }
+
+      void
+      inc(true_type)
+      {
+	if (m_p_nd->m_type == head_node)
+	  {
+	    m_p_nd = static_cast<head_pointer>(m_p_nd)->m_p_min;
+	    return;
+	  }
+
+	node_pointer p_y = m_p_nd->m_p_parent;
+	while (p_y->m_type != head_node && get_larger_sibling(m_p_nd) == 0)
+	  {
+	    m_p_nd = p_y;
+	    p_y = p_y->m_p_parent;
+	  }
+
+	if (p_y->m_type == head_node)
+	  {
+	    m_p_nd = p_y;
+	    return;
+	  }
+	m_p_nd = leftmost_descendant(get_larger_sibling(m_p_nd));
+      }
+
+      void
+      dec(false_type)
+      { inc(true_type()); }
+
+      void
+      dec(true_type)
+      {
+	if (m_p_nd->m_type == head_node)
+	  {
+	    m_p_nd = static_cast<head_pointer>(m_p_nd)->m_p_max;
+	    return;
+	  }
+
+	node_pointer p_y = m_p_nd->m_p_parent;
+	while (p_y->m_type != head_node && get_smaller_sibling(m_p_nd) == 0)
+	  {
+	    m_p_nd = p_y;
+	    p_y = p_y->m_p_parent;
+	  }
+
+	if (p_y->m_type == head_node)
+	  {
+	    m_p_nd = p_y;
+	    return;
+	  }
+	m_p_nd = rightmost_descendant(get_smaller_sibling(m_p_nd));
+      }
+
+      static node_pointer
+      get_larger_sibling(node_pointer p_nd)
+      {
+	inode_pointer p_parent = static_cast<inode_pointer>(p_nd->m_p_parent);
+
+	inode_iterator it = p_parent->begin();
+	while (*it != p_nd)
+	  ++it;
+
+	inode_iterator next_it = it;
+	++next_it;
+	return (next_it == p_parent->end())? 0 : *next_it;
+      }
+
+      static node_pointer
+      get_smaller_sibling(node_pointer p_nd)
+      {
+	inode_pointer p_parent = static_cast<inode_pointer>(p_nd->m_p_parent);
+
+	inode_iterator it = p_parent->begin();
+	if (*it == p_nd)
+	  return 0;
+
+	inode_iterator prev_it;
+	do
+	  {
+	    prev_it = it;
+	    ++it;
+	    if (*it == p_nd)
+	      return *prev_it;
+	  }
+	while (true);
+
+	_GLIBCXX_DEBUG_ASSERT(false);
+	return 0;
+      }
+
+      static leaf_pointer
+      leftmost_descendant(node_pointer p_nd)
+      {
+	if (p_nd->m_type == leaf_node)
+	  return static_cast<leaf_pointer>(p_nd);
+	return static_cast<inode_pointer>(p_nd)->leftmost_descendant();
+      }
+
+      static leaf_pointer
+      rightmost_descendant(node_pointer p_nd)
+      {
+	if (p_nd->m_type == leaf_node)
+	  return static_cast<leaf_pointer>(p_nd);
+	return static_cast<inode_pointer>(p_nd)->rightmost_descendant();
+      }
+    };
+
+
+    /// Iterator.
+    template<typename Node, typename Leaf, typename Head, typename Inode,
+	     bool Is_Forward_Iterator>
+    class _Iter
+    : public _CIter<Node, Leaf, Head, Inode, Is_Forward_Iterator>
+    {
+    public:
+      typedef _CIter<Node, Leaf, Head, Inode, Is_Forward_Iterator>
+      							base_type;
+      typedef typename base_type::allocator_type	allocator_type;
+      typedef typename base_type::type_traits		type_traits;
+      typedef typename type_traits::value_type		value_type;
+      typedef typename type_traits::pointer 		pointer;
+      typedef typename type_traits::reference 		reference;
+
+      typedef typename base_type::node_pointer		node_pointer;
+      typedef typename base_type::leaf_pointer		leaf_pointer;
+      typedef typename base_type::leaf_const_pointer	leaf_const_pointer;
+      typedef typename base_type::head_pointer		head_pointer;
+      typedef typename base_type::inode_pointer 	inode_pointer;
+
+      _Iter(node_pointer p_nd = 0)
+      : base_type(p_nd) { }
+
+      _Iter(const PB_DS_ODIR_IT_C_DEC& other)
+      : base_type(other.m_p_nd) { }
+
+      _Iter&
+      operator=(const _Iter& other)
+      {
+	base_type::m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      _Iter&
+      operator=(const PB_DS_ODIR_IT_C_DEC& other)
+      {
+	base_type::m_p_nd = other.m_p_nd;
+	return *this;
+      }
+
+      pointer
+      operator->() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd->m_type == leaf_node);
+	return &static_cast<leaf_pointer>(base_type::m_p_nd)->value();
+      }
+
+      reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd->m_type == leaf_node);
+	return static_cast<leaf_pointer>(base_type::m_p_nd)->value();
+      }
+
+      _Iter&
+      operator++()
+      {
+	base_type::operator++();
+	return *this;
+      }
+
+      _Iter
+      operator++(int)
+      {
+	_Iter ret(base_type::m_p_nd);
+	operator++();
+	return ret;
+      }
+
+      _Iter&
+      operator--()
+      {
+	base_type::operator--();
+	return *this;
+      }
+
+      _Iter
+      operator--(int)
+      {
+	_Iter ret(base_type::m_p_nd);
+	operator--();
+	return ret;
+      }
+    };
+
+#undef PB_DS_CONST_ODIR_IT_C_DEC
+#undef PB_DS_ODIR_IT_C_DEC
+
+
+#define PB_DS_PAT_TRIE_NODE_CONST_ITERATOR_C_DEC \
+    _Node_citer<Node, Leaf, Head, Inode, _CIterator, Iterator, _ATraits, _Alloc>
+
+#define PB_DS_PAT_TRIE_NODE_ITERATOR_C_DEC \
+    _Node_iter<Node, Leaf, Head, Inode, _CIterator, Iterator, _ATraits, _Alloc>
+
+    /// Node const iterator.
+    template<typename Node,
+	     typename Leaf,
+	     typename Head,
+	     typename Inode,
+	     typename _CIterator,
+	     typename Iterator,
+	     typename _Alloc>
+    class _Node_citer
+    {
+    protected:
+      typedef typename _Alloc::template rebind<Node>	__rebind_n;
+      typedef typename __rebind_n::other::pointer	node_pointer;
+
+      typedef typename _Alloc::template rebind<Leaf>	__rebind_l;
+      typedef typename __rebind_l::other::pointer	leaf_pointer;
+      typedef typename __rebind_l::other::const_pointer	leaf_const_pointer;
+
+      typedef typename _Alloc::template rebind<Inode> 	__rebind_in;
+      typedef typename __rebind_in::other::pointer 	inode_pointer;
+      typedef typename __rebind_in::other::const_pointer inode_const_pointer;
+
+      typedef typename Node::a_const_pointer		a_const_pointer;
+      typedef typename Node::a_const_iterator		a_const_iterator;
+
+    private:
+      a_const_iterator
+      pref_begin() const
+      {
+	if (m_p_nd->m_type == leaf_node)
+	  {
+	    leaf_const_pointer lcp = static_cast<leaf_const_pointer>(m_p_nd);
+	    return m_p_traits->begin(m_p_traits->extract_key(lcp->value()));
+	  }
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == i_node);
+	return static_cast<inode_const_pointer>(m_p_nd)->pref_b_it();
+      }
+
+      a_const_iterator
+      pref_end() const
+      {
+	if (m_p_nd->m_type == leaf_node)
+	  {
+	    leaf_const_pointer lcp = static_cast<leaf_const_pointer>(m_p_nd);
+	    return m_p_traits->end(m_p_traits->extract_key(lcp->value()));
+	  }
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == i_node);
+	return static_cast<inode_const_pointer>(m_p_nd)->pref_e_it();
+      }
+
+    public:
+      typedef trivial_iterator_tag 			iterator_category;
+      typedef trivial_iterator_difference_type 		difference_type;
+      typedef typename _Alloc::size_type 		size_type;
+
+      typedef _CIterator 		       		value_type;
+      typedef value_type 				reference;
+      typedef value_type 				const_reference;
+
+      /// Metadata type.
+      typedef typename Node::metadata_type 		metadata_type;
+
+      /// Const metadata reference type.
+      typedef typename _Alloc::template rebind<metadata_type> __rebind_m;
+      typedef typename __rebind_m::other 		__rebind_ma;
+      typedef typename __rebind_ma::const_reference    metadata_const_reference;
+
+      inline
+      _Node_citer(node_pointer p_nd = 0, a_const_pointer p_traits = 0)
+      : m_p_nd(const_cast<node_pointer>(p_nd)), m_p_traits(p_traits)
+      { }
+
+      /// Subtree valid prefix.
+      std::pair<a_const_iterator, a_const_iterator>
+      valid_prefix() const
+      { return std::make_pair(pref_begin(), pref_end()); }
+
+      /// Const access; returns the __const iterator* associated with
+      /// the current leaf.
+      const_reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(num_children() == 0);
+	return _CIterator(m_p_nd);
+      }
+
+      /// Metadata access.
+      metadata_const_reference
+      get_metadata() const
+      { return m_p_nd->get_metadata(); }
+
+      /// Returns the number of children in the corresponding node.
+      size_type
+      num_children() const
+      {
+	if (m_p_nd->m_type == leaf_node)
+	  return 0;
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == i_node);
+	inode_pointer inp = static_cast<inode_pointer>(m_p_nd);
+	return std::distance(inp->begin(), inp->end());
+      }
+
+      /// Returns a __const node __iterator to the corresponding node's
+      /// i-th child.
+      _Node_citer
+      get_child(size_type i) const
+      {
+	_GLIBCXX_DEBUG_ASSERT(m_p_nd->m_type == i_node);
+	inode_pointer inp = static_cast<inode_pointer>(m_p_nd);
+	typename Inode::iterator it = inp->begin();
+	std::advance(it, i);
+	return _Node_citer(*it, m_p_traits);
+      }
+
+      /// Compares content to a different iterator object.
+      bool
+      operator==(const _Node_citer& other) const
+      { return m_p_nd == other.m_p_nd; }
+
+      /// Compares content (negatively) to a different iterator object.
+      bool
+      operator!=(const _Node_citer& other) const
+      { return m_p_nd != other.m_p_nd; }
+
+      node_pointer 			m_p_nd;
+      a_const_pointer 			m_p_traits;
+    };
+
+
+    /// Node iterator.
+    template<typename Node,
+	     typename Leaf,
+	     typename Head,
+	     typename Inode,
+	     typename _CIterator,
+	     typename Iterator,
+	     typename _Alloc>
+    class _Node_iter
+    : public _Node_citer<Node, Leaf, Head, Inode, _CIterator, Iterator, _Alloc>
+    {
+    private:
+      typedef _Node_citer<Node, Leaf, Head, Inode,
+			  _CIterator, Iterator, _Alloc>	base_type;
+      typedef typename _Alloc::template rebind<Node>	__rebind_n;
+      typedef typename __rebind_n::other::pointer	node_pointer;
+      typedef typename base_type::inode_pointer 	inode_pointer;
+      typedef typename base_type::a_const_pointer 	a_const_pointer;
+      typedef Iterator 					iterator;
+
+    public:
+      typedef typename base_type::size_type 		size_type;
+
+      typedef Iterator 					value_type;
+      typedef value_type 				reference;
+      typedef value_type 				const_reference;
+
+      _Node_iter(node_pointer p_nd = 0, a_const_pointer p_traits = 0)
+      : base_type(p_nd, p_traits)
+      { }
+
+      /// Access; returns the iterator*  associated with the current leaf.
+      reference
+      operator*() const
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_type::num_children() == 0);
+	return iterator(base_type::m_p_nd);
+      }
+
+      /// Returns a node __iterator to the corresponding node's i-th child.
+      _Node_iter
+      get_child(size_type i) const
+      {
+	_GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd->m_type == i_node);
+
+	typename Inode::iterator it =
+	  static_cast<inode_pointer>(base_type::m_p_nd)->begin();
+
+	std::advance(it, i);
+	return _Node_iter(*it, base_type::m_p_traits);
+      }
+    };
+    };
+
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename _ATraits, typename Metadata>
+
+#define PB_DS_CLASS_C_DEC \
+    pat_trie_base::_Inode<_ATraits, Metadata>
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::__rebind_l
+    PB_DS_CLASS_C_DEC::s_leaf_alloc;
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::__rebind_in
+    PB_DS_CLASS_C_DEC::s_inode_alloc;
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    get_pref_pos(a_const_iterator b_it, a_const_iterator e_it,
+		 a_const_pointer p_traits) const
+    {
+      if (static_cast<std::size_t>(std::distance(b_it, e_it)) <= m_e_ind)
+	return 0;
+      std::advance(b_it, m_e_ind);
+      return 1 + p_traits->e_pos(*b_it);
+    }
+
+    PB_DS_CLASS_T_DEC
+    PB_DS_CLASS_C_DEC::
+    _Inode(size_type len, const a_const_iterator it)
+    : base_type(i_node), m_e_ind(len), m_pref_b_it(it), m_pref_e_it(it)
+    {
+      std::advance(m_pref_e_it, m_e_ind);
+      std::fill(m_a_p_children, m_a_p_children + arr_size,
+		static_cast<node_pointer>(0));
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    update_prefixes(a_const_pointer p_traits)
+    {
+      node_pointer p_first = *begin();
+      if (p_first->m_type == leaf_node)
+	{
+	  leaf_const_pointer p = static_cast<leaf_const_pointer>(p_first);
+	  m_pref_b_it = p_traits->begin(access_traits::extract_key(p->value()));
+	}
+      else
+	{
+	  inode_pointer p = static_cast<inode_pointer>(p_first);
+	  _GLIBCXX_DEBUG_ASSERT(p_first->m_type == i_node);
+	  m_pref_b_it = p->pref_b_it();
+	}
+      m_pref_e_it = m_pref_b_it;
+      std::advance(m_pref_e_it, m_e_ind);
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::const_iterator
+    PB_DS_CLASS_C_DEC::
+    begin() const
+    {
+      typedef node_pointer_pointer pointer_type;
+      pointer_type p = const_cast<pointer_type>(m_a_p_children);
+      return const_iterator(p + get_begin_pos(), p + arr_size);
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::iterator
+    PB_DS_CLASS_C_DEC::
+    begin()
+    {
+      return iterator(m_a_p_children + get_begin_pos(),
+		      m_a_p_children + arr_size);
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::const_iterator
+    PB_DS_CLASS_C_DEC::
+    end() const
+    {
+      typedef node_pointer_pointer pointer_type;
+      pointer_type p = const_cast<pointer_type>(m_a_p_children) + arr_size;
+      return const_iterator(p, p);
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::iterator
+    PB_DS_CLASS_C_DEC::
+    end()
+    { return iterator(m_a_p_children + arr_size, m_a_p_children + arr_size); }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::node_pointer
+    PB_DS_CLASS_C_DEC::
+    get_child_node(a_const_iterator b_it, a_const_iterator e_it,
+		   a_const_pointer p_traits)
+    {
+      const size_type i = get_pref_pos(b_it, e_it, p_traits);
+      _GLIBCXX_DEBUG_ASSERT(i < arr_size);
+      return m_a_p_children[i];
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::iterator
+    PB_DS_CLASS_C_DEC::
+    get_child_it(a_const_iterator b_it, a_const_iterator e_it,
+		 a_const_pointer p_traits)
+    {
+      const size_type i = get_pref_pos(b_it, e_it, p_traits);
+      _GLIBCXX_DEBUG_ASSERT(i < arr_size);
+      _GLIBCXX_DEBUG_ASSERT(m_a_p_children[i] != 0);
+      return iterator(m_a_p_children + i, m_a_p_children + i);
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::node_const_pointer
+    PB_DS_CLASS_C_DEC::
+    get_child_node(a_const_iterator b_it, a_const_iterator e_it,
+		   a_const_pointer p_traits) const
+    { return const_cast<node_pointer>(get_child_node(b_it, e_it, p_traits)); }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::node_pointer
+    PB_DS_CLASS_C_DEC::
+    get_lower_bound_child_node(a_const_iterator b_it, a_const_iterator e_it,
+			       size_type checked_ind,
+			       a_const_pointer p_traits)
+    {
+      if (!should_be_mine(b_it, e_it, checked_ind, p_traits))
+	{
+	  if (p_traits->cmp_prefixes(b_it, e_it, m_pref_b_it,
+				     m_pref_e_it, true))
+	    return leftmost_descendant();
+	  return rightmost_descendant();
+	}
+
+      size_type i = get_pref_pos(b_it, e_it, p_traits);
+      _GLIBCXX_DEBUG_ASSERT(i < arr_size);
+
+      if (m_a_p_children[i] != 0)
+	return m_a_p_children[i];
+
+      while (++i < arr_size)
+	if (m_a_p_children[i] != 0)
+	  {
+	    const node_type& __nt = m_a_p_children[i]->m_type;
+	    node_pointer ret = m_a_p_children[i];
+
+	    if (__nt == leaf_node)
+	      return ret;
+
+	    _GLIBCXX_DEBUG_ASSERT(__nt == i_node);
+	    inode_pointer inp = static_cast<inode_pointer>(ret);
+	    return inp->leftmost_descendant();
+	  }
+
+      return rightmost_descendant();
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::node_pointer
+    PB_DS_CLASS_C_DEC::
+    add_child(node_pointer p_nd, a_const_iterator b_it, a_const_iterator e_it,
+	      a_const_pointer p_traits)
+    {
+      const size_type i = get_pref_pos(b_it, e_it, p_traits);
+      _GLIBCXX_DEBUG_ASSERT(i < arr_size);
+      if (m_a_p_children[i] == 0)
+	{
+	  m_a_p_children[i] = p_nd;
+	  p_nd->m_p_parent = this;
+	  return p_nd;
+	}
+      return m_a_p_children[i];
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::node_const_pointer
+    PB_DS_CLASS_C_DEC::
+    get_join_child(node_const_pointer p_nd,
+		   a_const_pointer p_tr) const
+    {
+      node_pointer p = const_cast<node_pointer>(p_nd);
+      return const_cast<inode_pointer>(this)->get_join_child(p, p_tr);
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::node_pointer
+    PB_DS_CLASS_C_DEC::
+    get_join_child(node_pointer p_nd, a_const_pointer p_traits)
+    {
+      size_type i;
+      a_const_iterator b_it;
+      a_const_iterator e_it;
+      if (p_nd->m_type == leaf_node)
+	{
+	  leaf_const_pointer p = static_cast<leaf_const_pointer>(p_nd);
+
+	  typedef typename type_traits::key_const_reference kcr;
+	  kcr r_key = access_traits::extract_key(p->value());
+	  b_it = p_traits->begin(r_key);
+	  e_it = p_traits->end(r_key);
+	}
+      else
+	{
+	  b_it = static_cast<inode_pointer>(p_nd)->pref_b_it();
+	  e_it = static_cast<inode_pointer>(p_nd)->pref_e_it();
+	}
+      i = get_pref_pos(b_it, e_it, p_traits);
+      _GLIBCXX_DEBUG_ASSERT(i < arr_size);
+      return m_a_p_children[i];
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    remove_child(node_pointer p_nd)
+    {
+      size_type i = 0;
+      for (; i < arr_size; ++i)
+	if (m_a_p_children[i] == p_nd)
+	  {
+	    m_a_p_children[i] = 0;
+	    return;
+	  }
+      _GLIBCXX_DEBUG_ASSERT(i != arr_size);
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    remove_child(iterator it)
+    { *it.m_p_p_cur = 0; }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    replace_child(node_pointer p_nd, a_const_iterator b_it,
+		  a_const_iterator e_it,
+		  a_const_pointer p_traits)
+    {
+      const size_type i = get_pref_pos(b_it, e_it, p_traits);
+      _GLIBCXX_DEBUG_ASSERT(i < arr_size);
+      m_a_p_children[i] = p_nd;
+      p_nd->m_p_parent = this;
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::a_const_iterator
+    PB_DS_CLASS_C_DEC::
+    pref_b_it() const
+    { return m_pref_b_it; }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::a_const_iterator
+    PB_DS_CLASS_C_DEC::
+    pref_e_it() const
+    { return m_pref_e_it; }
+
+    PB_DS_CLASS_T_DEC
+    bool
+    PB_DS_CLASS_C_DEC::
+    should_be_mine(a_const_iterator b_it, a_const_iterator e_it,
+		   size_type checked_ind,
+		   a_const_pointer p_traits) const
+    {
+      if (m_e_ind == 0)
+	return true;
+
+      const size_type num_es = std::distance(b_it, e_it);
+      if (num_es < m_e_ind)
+	return false;
+
+      a_const_iterator key_b_it = b_it;
+      std::advance(key_b_it, checked_ind);
+      a_const_iterator key_e_it = b_it;
+      std::advance(key_e_it, m_e_ind);
+
+      a_const_iterator value_b_it = m_pref_b_it;
+      std::advance(value_b_it, checked_ind);
+      a_const_iterator value_e_it = m_pref_b_it;
+      std::advance(value_e_it, m_e_ind);
+
+      return p_traits->equal_prefixes(key_b_it, key_e_it, value_b_it,
+				      value_e_it);
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::leaf_pointer
+    PB_DS_CLASS_C_DEC::
+    leftmost_descendant()
+    {
+      node_pointer p_pot = *begin();
+      if (p_pot->m_type == leaf_node)
+	return (static_cast<leaf_pointer>(p_pot));
+      _GLIBCXX_DEBUG_ASSERT(p_pot->m_type == i_node);
+      return static_cast<inode_pointer>(p_pot)->leftmost_descendant();
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::leaf_const_pointer
+    PB_DS_CLASS_C_DEC::
+    leftmost_descendant() const
+    { return const_cast<inode_pointer>(this)->leftmost_descendant(); }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::leaf_pointer
+    PB_DS_CLASS_C_DEC::
+    rightmost_descendant()
+    {
+      const size_type num_children = std::distance(begin(), end());
+      _GLIBCXX_DEBUG_ASSERT(num_children >= 2);
+
+      iterator it = begin();
+      std::advance(it, num_children - 1);
+      node_pointer p_pot =* it;
+      if (p_pot->m_type == leaf_node)
+	return static_cast<leaf_pointer>(p_pot);
+      _GLIBCXX_DEBUG_ASSERT(p_pot->m_type == i_node);
+      return static_cast<inode_pointer>(p_pot)->rightmost_descendant();
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::leaf_const_pointer
+    PB_DS_CLASS_C_DEC::
+    rightmost_descendant() const
+    { return const_cast<inode_pointer>(this)->rightmost_descendant(); }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    get_begin_pos() const
+    {
+      size_type i = 0;
+      for (; i < arr_size && m_a_p_children[i] == 0; ++i)
+	;
+      return i;
+    }
+
+#ifdef _GLIBCXX_DEBUG
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::node_debug_info
+    PB_DS_CLASS_C_DEC::
+    assert_valid_imp(a_const_pointer p_traits,
+		     const char* __file, int __line) const
+    {
+      PB_DS_DEBUG_VERIFY(base_type::m_type == i_node);
+      PB_DS_DEBUG_VERIFY(static_cast<size_type>(std::distance(pref_b_it(), pref_e_it())) == m_e_ind);
+      PB_DS_DEBUG_VERIFY(std::distance(begin(), end()) >= 2);
+
+      for (typename _Inode::const_iterator it = begin(); it != end(); ++it)
+	{
+	  node_const_pointer p_nd = *it;
+	  PB_DS_DEBUG_VERIFY(p_nd->m_p_parent == this);
+	  node_debug_info child_ret = p_nd->assert_valid_imp(p_traits,
+							     __file, __line);
+
+	  PB_DS_DEBUG_VERIFY(static_cast<size_type>(std::distance(child_ret.first, child_ret.second)) >= m_e_ind);
+	  PB_DS_DEBUG_VERIFY(should_be_mine(child_ret.first, child_ret.second, 0, p_traits));
+	  PB_DS_DEBUG_VERIFY(get_pref_pos(child_ret.first, child_ret.second, p_traits) == static_cast<size_type>(it.m_p_p_cur - m_a_p_children));
+	}
+      return std::make_pair(pref_b_it(), pref_e_it());
+    }
+#endif
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/policy_access_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/policy_access_fn_imps.hpp
new file mode 100644
index 0000000..56f7616
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/policy_access_fn_imps.hpp
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/policy_access_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::access_traits& 
+PB_DS_CLASS_C_DEC::
+get_access_traits()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const typename PB_DS_CLASS_C_DEC::access_traits& 
+PB_DS_CLASS_C_DEC::
+get_access_traits() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_update& 
+PB_DS_CLASS_C_DEC::
+get_node_update()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const typename PB_DS_CLASS_C_DEC::node_update& 
+PB_DS_CLASS_C_DEC::
+get_node_update() const
+{ return *this; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp
new file mode 100644
index 0000000..38d6062
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/r_erase_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+actual_erase_node(node_pointer p_z)
+{
+  _GLIBCXX_DEBUG_ASSERT(m_size > 0);
+  --m_size;
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_z->m_value)));
+  p_z->~node();
+  s_node_allocator.deallocate(p_z, 1);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+update_min_max_for_erased_node(node_pointer p_z)
+{
+  if (m_size == 1)
+    {
+      m_p_head->m_p_left = m_p_head->m_p_right = m_p_head;
+      return;
+    }
+
+  if (m_p_head->m_p_left == p_z)
+    {
+      iterator it(p_z);
+      ++it;
+      m_p_head->m_p_left = it.m_p_nd;
+    }
+  else if (m_p_head->m_p_right == p_z)
+    {
+      iterator it(p_z);
+      --it;
+      m_p_head->m_p_right = it.m_p_nd;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  _GLIBCXX_DEBUG_ONLY(assert_valid(true, true);)
+  clear_imp(m_p_head->m_p_parent);
+  m_size = 0;
+  initialize();
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
+  _GLIBCXX_DEBUG_ONLY(assert_valid(true, true);)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear_imp(node_pointer p_nd)
+{
+  if (p_nd == 0)
+    return;
+  clear_imp(p_nd->m_p_left);
+  clear_imp(p_nd->m_p_right);
+  p_nd->~Node();
+  s_node_allocator.deallocate(p_nd, 1);
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp
new file mode 100644
index 0000000..f240bfa
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp
@@ -0,0 +1,150 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/rotate_fn_imps.hpp
+ * Contains imps for rotating nodes.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+rotate_left(node_pointer p_x)
+{
+  node_pointer p_y = p_x->m_p_right;
+  p_x->m_p_right = p_y->m_p_left;
+
+  if (p_y->m_p_left != 0)
+    p_y->m_p_left->m_p_parent = p_x;
+
+  p_y->m_p_parent = p_x->m_p_parent;
+  if (p_x == m_p_head->m_p_parent)
+    m_p_head->m_p_parent = p_y;
+  else if (p_x == p_x->m_p_parent->m_p_left)
+    p_x->m_p_parent->m_p_left = p_y;
+  else
+    p_x->m_p_parent->m_p_right = p_y;
+
+  p_y->m_p_left = p_x;
+  p_x->m_p_parent = p_y;
+
+  _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_x);)
+  _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_y);)
+
+  apply_update(p_x, (Node_Update*)this);
+  apply_update(p_x->m_p_parent, (Node_Update*)this);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+rotate_right(node_pointer p_x)
+{
+  node_pointer p_y = p_x->m_p_left;
+  p_x->m_p_left = p_y->m_p_right;
+
+  if (p_y->m_p_right != 0)
+    p_y->m_p_right->m_p_parent = p_x;
+
+  p_y->m_p_parent = p_x->m_p_parent;
+  if (p_x == m_p_head->m_p_parent)
+    m_p_head->m_p_parent = p_y;
+  else if (p_x == p_x->m_p_parent->m_p_right)
+    p_x->m_p_parent->m_p_right = p_y;
+  else
+    p_x->m_p_parent->m_p_left = p_y;
+
+  p_y->m_p_right = p_x;
+  p_x->m_p_parent = p_y;
+
+  _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_x);)
+  _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_y);)
+
+  apply_update(p_x, (Node_Update*)this);
+  apply_update(p_x->m_p_parent, (Node_Update*)this);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+rotate_parent(node_pointer p_nd)
+{
+  node_pointer p_parent = p_nd->m_p_parent;
+  if (p_nd == p_parent->m_p_left)
+    rotate_right(p_parent);
+  else
+    rotate_left(p_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_parent = p_nd);
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left == p_parent || p_nd->m_p_right == p_parent);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+apply_update(node_pointer /*p_nd*/, __gnu_pbds::null_node_update*  /*p_update*/)
+{ }
+
+PB_DS_CLASS_T_DEC
+template<typename Node_Update_>
+inline void
+PB_DS_CLASS_C_DEC::
+apply_update(node_pointer p_nd, Node_Update_* p_update)
+{
+  p_update->operator()(& PB_DS_V2F(p_nd->m_value),(p_nd->m_p_left == 0) ?
+			0 :
+			& PB_DS_V2F(p_nd->m_p_left->m_value),(p_nd->m_p_right == 0) ?
+			0 :
+			& PB_DS_V2F(p_nd->m_p_right->m_value));
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Node_Update_>
+inline void
+PB_DS_CLASS_C_DEC::
+update_to_top(node_pointer p_nd, Node_Update_* p_update)
+{
+  while (p_nd != m_p_head)
+    {
+      apply_update(p_nd, p_update);
+      p_nd = p_nd->m_p_parent;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+update_to_top(node_pointer /*p_nd*/, __gnu_pbds::null_node_update*  /*p_update*/)
+{ }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp
new file mode 100644
index 0000000..56a79d4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp
@@ -0,0 +1,250 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/split_fn_imps.hpp
+ * Contains an implementation class for pat_trie.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+split(key_const_reference r_key, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  branch_bag bag;
+  leaf_pointer p_split_lf = split_prep(r_key, other, bag);
+  if (p_split_lf == 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(bag.empty());
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(!bag.empty());
+  other.clear();
+
+  m_p_head->m_p_parent = rec_split(m_p_head->m_p_parent, pref_begin(p_split_lf),
+				   pref_end(p_split_lf), other, bag);
+
+  m_p_head->m_p_parent->m_p_parent = m_p_head;
+
+  head_pointer __ohead = other.m_p_head;
+  __ohead->m_p_max = m_p_head->m_p_max;
+  m_p_head->m_p_max = rightmost_descendant(m_p_head->m_p_parent);
+  __ohead->m_p_min = other.leftmost_descendant(__ohead->m_p_parent);
+
+  other.m_size = std::distance(other.PB_DS_CLASS_C_DEC::begin(),
+			       other.PB_DS_CLASS_C_DEC::end());
+  m_size -= other.m_size;
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::leaf_pointer
+PB_DS_CLASS_C_DEC::
+split_prep(key_const_reference r_key, PB_DS_CLASS_C_DEC& other,
+	   branch_bag& r_bag)
+{
+  _GLIBCXX_DEBUG_ASSERT(r_bag.empty());
+  if (m_size == 0)
+    {
+      other.clear();
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return 0;
+    }
+
+  if (synth_access_traits::cmp_keys(r_key,
+				    PB_DS_V2F(static_cast<leaf_const_pointer>(m_p_head->m_p_min)->value())))
+    {
+      other.clear();
+      value_swap(other);
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return 0;
+    }
+
+  if (!synth_access_traits::cmp_keys(r_key,
+				       PB_DS_V2F(static_cast<leaf_const_pointer>(m_p_head->m_p_max)->value())))
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return 0;
+    }
+
+  iterator it = lower_bound(r_key);
+
+  if (!synth_access_traits::equal_keys(PB_DS_V2F(*it), r_key))
+    --it;
+
+  node_pointer p_nd = it.m_p_nd;
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == leaf_node);
+  leaf_pointer p_ret_l = static_cast<leaf_pointer>(p_nd);
+  while (p_nd->m_type != head_node)
+    {
+      r_bag.add_branch();
+      p_nd = p_nd->m_p_parent;
+    }
+  _GLIBCXX_DEBUG_ONLY(debug_base::split(r_key,(synth_access_traits&)(*this), other);)
+
+  return p_ret_l;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+rec_split(node_pointer p_nd, a_const_iterator b_it, a_const_iterator e_it,
+	  PB_DS_CLASS_C_DEC& other, branch_bag& r_bag)
+{
+  if (p_nd->m_type == leaf_node)
+    {
+      _GLIBCXX_DEBUG_ASSERT(other.m_p_head->m_p_parent == 0);
+      return p_nd;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == i_node);
+  inode_pointer p_ind = static_cast<inode_pointer>(p_nd);
+
+  node_pointer pfirst = p_ind->get_child_node(b_it, e_it, this);
+  node_pointer p_child_ret = rec_split(pfirst, b_it, e_it, other, r_bag);
+  PB_DS_ASSERT_NODE_VALID(p_child_ret)
+  p_ind->replace_child(p_child_ret, b_it, e_it, this);
+  apply_update(p_ind, (node_update*)this);
+
+  inode_iterator child_it = p_ind->get_child_it(b_it, e_it, this);
+  const size_type lhs_dist = std::distance(p_ind->begin(), child_it);
+  const size_type lhs_num_children = lhs_dist + 1;
+  _GLIBCXX_DEBUG_ASSERT(lhs_num_children > 0);
+
+  const size_type rhs_dist =  std::distance(p_ind->begin(), p_ind->end());
+  size_type rhs_num_children = rhs_dist - lhs_num_children;
+  if (rhs_num_children == 0)
+    {
+      apply_update(p_ind, (node_update*)this);
+      return p_ind;
+    }
+
+  other.split_insert_branch(p_ind->get_e_ind(), b_it, child_it,
+			    rhs_num_children, r_bag);
+
+  child_it = p_ind->get_child_it(b_it, e_it, this);
+  while (rhs_num_children != 0)
+    {
+      ++child_it;
+      p_ind->remove_child(child_it);
+      --rhs_num_children;
+    }
+  apply_update(p_ind, (node_update*)this);
+
+  const size_type int_dist = std::distance(p_ind->begin(), p_ind->end());
+  _GLIBCXX_DEBUG_ASSERT(int_dist >= 1);
+  if (int_dist > 1)
+    {
+      p_ind->update_prefixes(this);
+      PB_DS_ASSERT_NODE_VALID(p_ind)
+      apply_update(p_ind, (node_update*)this);
+      return p_ind;
+    }
+
+  node_pointer p_ret = *p_ind->begin();
+  p_ind->~inode();
+  s_inode_allocator.deallocate(p_ind, 1);
+  apply_update(p_ret, (node_update*)this);
+  return p_ret;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+split_insert_branch(size_type e_ind, a_const_iterator b_it,
+		    inode_iterator child_b_it,
+		    size_type num_children, branch_bag& r_bag)
+{
+#ifdef _GLIBCXX_DEBUG
+  if (m_p_head->m_p_parent != 0)
+    PB_DS_ASSERT_NODE_VALID(m_p_head->m_p_parent)
+#endif
+
+  const size_type start = m_p_head->m_p_parent == 0 ? 0 : 1;
+  const size_type total_num_children = start + num_children;
+  if (total_num_children == 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == 0);
+      return;
+    }
+
+  if (total_num_children == 1)
+    {
+      if (m_p_head->m_p_parent != 0)
+	{
+	  PB_DS_ASSERT_NODE_VALID(m_p_head->m_p_parent)
+	  return;
+	}
+
+      _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == 0);
+      ++child_b_it;
+      m_p_head->m_p_parent = *child_b_it;
+      m_p_head->m_p_parent->m_p_parent = m_p_head;
+      apply_update(m_p_head->m_p_parent, (node_update*)this);
+      PB_DS_ASSERT_NODE_VALID(m_p_head->m_p_parent)
+      return;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(total_num_children > 1);
+  inode_pointer p_new_root = r_bag.get_branch();
+  new (p_new_root) inode(e_ind, b_it);
+  size_type num_inserted = 0;
+  while (num_inserted++ < num_children)
+    {
+      ++child_b_it;
+      PB_DS_ASSERT_NODE_VALID((*child_b_it))
+      p_new_root->add_child(*child_b_it, pref_begin(*child_b_it),
+			    pref_end(*child_b_it), this);
+    }
+
+  if (m_p_head->m_p_parent != 0)
+    p_new_root->add_child(m_p_head->m_p_parent,
+			  pref_begin(m_p_head->m_p_parent),
+			  pref_end(m_p_head->m_p_parent), this);
+
+  m_p_head->m_p_parent = p_new_root;
+  p_new_root->m_p_parent = m_p_head;
+  apply_update(m_p_head->m_p_parent, (node_update*)this);
+  PB_DS_ASSERT_NODE_VALID(m_p_head->m_p_parent)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/synth_access_traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/synth_access_traits.hpp
new file mode 100644
index 0000000..10615e2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/synth_access_traits.hpp
@@ -0,0 +1,218 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/synth_access_traits.hpp
+ * Contains an implementation class for a patricia tree.
+ */
+
+#ifndef PB_DS_SYNTH_E_ACCESS_TRAITS_HPP
+#define PB_DS_SYNTH_E_ACCESS_TRAITS_HPP
+
+#include <ext/pb_ds/detail/type_utils.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+
+#define PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC \
+    template<typename Type_Traits, bool Set, typename _ATraits>
+
+#define PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC \
+    synth_access_traits<Type_Traits, Set, _ATraits>
+
+    /// Synthetic element access traits.
+    template<typename Type_Traits, bool Set, typename _ATraits>
+    struct synth_access_traits : public _ATraits
+    {
+      typedef _ATraits 					base_type;
+      typedef typename base_type::const_iterator	const_iterator;
+      typedef Type_Traits 				type_traits;
+      typedef typename type_traits::const_reference 	const_reference;
+      typedef typename type_traits::key_const_reference key_const_reference;
+
+      synth_access_traits();
+
+      synth_access_traits(const base_type&);
+
+      inline bool
+      equal_prefixes(const_iterator, const_iterator, const_iterator,
+		     const_iterator, bool compare_after = true) const;
+
+      bool
+      equal_keys(key_const_reference, key_const_reference) const;
+
+      bool
+      cmp_prefixes(const_iterator, const_iterator, const_iterator,
+		   const_iterator, bool compare_after = false) const;
+
+      bool
+      cmp_keys(key_const_reference, key_const_reference) const;
+
+      inline static key_const_reference
+      extract_key(const_reference);
+
+#ifdef _GLIBCXX_DEBUG
+      bool
+      operator()(key_const_reference, key_const_reference);
+#endif
+
+    private:
+      inline static key_const_reference
+      extract_key(const_reference, true_type);
+
+      inline static key_const_reference
+      extract_key(const_reference, false_type);
+
+      static integral_constant<int, Set> s_set_ind;
+    };
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    integral_constant<int,Set>
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::s_set_ind;
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    synth_access_traits()
+    { }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    synth_access_traits(const _ATraits& r_traits) 
+    : _ATraits(r_traits)
+    { }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    inline bool
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    equal_prefixes(const_iterator b_l, const_iterator e_l, const_iterator b_r,
+		   const_iterator e_r, bool compare_after /*= false */) const
+    {
+      while (b_l != e_l)
+	{
+	  if (b_r == e_r)
+	    return false;
+	  if (base_type::e_pos(*b_l) != base_type::e_pos(*b_r))
+	    return false;
+	  ++b_l;
+	  ++b_r;
+	}
+      return (!compare_after || b_r == e_r);
+    }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    bool
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    equal_keys(key_const_reference r_lhs_key,
+	       key_const_reference r_rhs_key) const
+    {
+      return equal_prefixes(base_type::begin(r_lhs_key),
+			    base_type::end(r_lhs_key),
+			    base_type::begin(r_rhs_key),
+			    base_type::end(r_rhs_key),
+			    true);
+    }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    bool
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    cmp_prefixes(const_iterator b_l, const_iterator e_l, const_iterator b_r,
+		 const_iterator e_r, bool compare_after /* = false*/) const
+    {
+      while (b_l != e_l)
+	{
+	  if (b_r == e_r)
+	    return false;
+
+	  const typename base_type::size_type l_pos = base_type::e_pos(*b_l);
+	  const typename base_type::size_type r_pos = base_type::e_pos(*b_r);
+	  if (l_pos != r_pos)
+	    return l_pos < r_pos;
+	  ++b_l;
+	  ++b_r;
+	}
+
+      if (!compare_after)
+	return false;
+      return b_r != e_r;
+    }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    bool
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    cmp_keys(key_const_reference r_lhs_key,
+	     key_const_reference r_rhs_key) const
+    {
+      return cmp_prefixes(base_type::begin(r_lhs_key),
+			  base_type::end(r_lhs_key),
+			  base_type::begin(r_rhs_key),
+			  base_type::end(r_rhs_key),
+			  true);
+    }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    inline typename PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::key_const_reference
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    extract_key(const_reference r_val)
+    { return extract_key(r_val, s_set_ind); }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    inline typename PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::key_const_reference
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    extract_key(const_reference r_val, true_type)
+    { return r_val; }
+
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    inline typename PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::key_const_reference
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    extract_key(const_reference r_val, false_type)
+    { return r_val.first; }
+
+#ifdef _GLIBCXX_DEBUG
+    PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+    bool
+    PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC::
+    operator()(key_const_reference r_lhs, key_const_reference r_rhs)
+    { return cmp_keys(r_lhs, r_rhs); }
+#endif
+
+#undef PB_DS_SYNTH_E_ACCESS_TRAITS_T_DEC
+#undef PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp
new file mode 100644
index 0000000..73d98f4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/trace_fn_imps.hpp
+ * Contains an implementation class for pat_trie_.
+ */
+
+#ifdef PB_DS_PAT_TRIE_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  std::cerr << std::endl;
+  if (m_p_head->m_p_parent == 0)
+    return;
+  trace_node(m_p_head->m_p_parent, 0);
+  std::cerr << std::endl;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace_node(node_const_pointer p_nd, size_type level)
+{
+  for (size_type i = 0; i < level; ++i)
+    std::cerr << ' ';
+  std::cerr << p_nd << " ";
+  std::cerr << ((p_nd->m_type == pat_trie_leaf_node_type) ? "l " : "i ");
+
+  trace_node_metadata(p_nd, type_to_type<typename node::metadata_type>());
+  typename access_traits::const_iterator el_it = pref_begin(p_nd);
+  while (el_it != pref_end(p_nd))
+    {
+      std::cerr <<* el_it;
+      ++el_it;
+    }
+
+  if (p_nd->m_type == pat_trie_leaf_node_type)
+    {
+      std::cerr << std::endl;
+      return;
+    }
+
+  inode_const_pointer p_internal = static_cast<inode_const_pointer>(p_nd);
+
+  std::cerr << " " <<
+    static_cast<unsigned long>(p_internal->get_e_ind()) << std::endl;
+
+  const size_type num_children = std::distance(p_internal->begin(),
+					       p_internal->end());
+
+  for (size_type child_i = 0; child_i < num_children; ++child_i)
+    {
+      typename inode::const_iterator child_it = p_internal->begin();
+      std::advance(child_it, num_children - child_i - 1);
+      trace_node(*child_it, level + 1);
+    }
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Metadata_>
+void
+PB_DS_CLASS_C_DEC::
+trace_node_metadata(node_const_pointer p_nd, type_to_type<Metadata_>)
+{
+  std::cerr << "(" << static_cast<unsigned long>(p_nd->get_metadata()) << ") ";
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace_node_metadata(node_const_pointer, type_to_type<null_type>)
+{ }
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/traits.hpp
new file mode 100644
index 0000000..65bfee2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/traits.hpp
@@ -0,0 +1,148 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/traits.hpp
+ * Contains an implementation class for pat_trie_.
+ */
+
+#ifndef PB_DS_PAT_TRIE_NODE_AND_IT_TRAITS_HPP
+#define PB_DS_PAT_TRIE_NODE_AND_IT_TRAITS_HPP
+
+#include <ext/pb_ds/detail/pat_trie_/pat_trie_base.hpp>
+#include <ext/pb_ds/detail/pat_trie_/synth_access_traits.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     typename Mapped,
+	     typename _ATraits,
+	     template<typename Node_CItr,
+		      typename Node_Itr,
+		      typename Cmp_Fn_,
+		      typename _Alloc_>
+	     class Node_Update,
+	     typename _Alloc>
+    struct trie_traits<Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc>
+    {
+    private:
+      typedef pat_trie_base				    	base_type;
+      typedef types_traits<Key, Mapped, _Alloc, false> 		type_traits;
+
+    public:
+      typedef typename trie_node_metadata_dispatch<Key, Mapped, _ATraits, Node_Update, _Alloc>::type metadata_type;
+      typedef base_type::_Metadata<metadata_type, _Alloc>      	metadata;
+      typedef _ATraits 		       			       	access_traits;
+
+      /// Type for synthesized traits.
+      typedef __gnu_pbds::detail::synth_access_traits<type_traits, false, access_traits>   synth_access_traits;
+
+      typedef base_type::_Node_base<synth_access_traits, metadata>     	node;
+      typedef base_type::_Head<synth_access_traits, metadata>	       	head;
+      typedef base_type::_Leaf<synth_access_traits, metadata>	       	leaf;
+      typedef base_type::_Inode<synth_access_traits, metadata> 		inode;
+
+      typedef base_type::_Iter<node, leaf, head, inode, true>	       	iterator;
+      typedef base_type::_CIter<node, leaf, head, inode, true> 	 	const_iterator;
+      typedef base_type::_Iter<node, leaf, head, inode, false> 		reverse_iterator;
+      typedef base_type::_CIter<node, leaf, head, inode, false>	 	const_reverse_iterator;
+
+      /// This is an iterator to an iterator: it iterates over nodes,
+      /// and de-referencing it returns one of the tree's iterators.
+      typedef base_type::_Node_citer<node, leaf, head, inode, const_iterator, iterator, _Alloc> node_const_iterator;
+
+      typedef base_type::_Node_iter<node, leaf, head, inode, const_iterator, iterator, _Alloc> node_iterator;
+
+      /// Type for node update.
+      typedef Node_Update<node_const_iterator, node_iterator, _ATraits, _Alloc> 		node_update;
+
+      typedef null_node_update<node_const_iterator, node_iterator, _ATraits, _Alloc>* 		null_node_update_pointer;
+    };
+
+
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     typename _ATraits,
+	     template<typename Node_CItr,
+		      typename Node_Itr,
+		      typename Cmp_Fn_,
+		      typename _Alloc_>
+	     class Node_Update,
+	     typename _Alloc>
+    struct trie_traits<Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc>
+    {
+    private:
+      typedef pat_trie_base					base_type;
+      typedef types_traits<Key, null_type, _Alloc, false> 	type_traits;
+
+    public:
+      typedef typename trie_node_metadata_dispatch<Key, null_type, _ATraits, Node_Update, _Alloc>::type metadata_type;
+      typedef base_type::_Metadata<metadata_type, _Alloc>				metadata;
+      typedef _ATraits 				     					access_traits;
+
+      /// Type for synthesized traits.
+      typedef __gnu_pbds::detail::synth_access_traits<type_traits, true, access_traits> synth_access_traits;
+
+      typedef base_type::_Node_base<synth_access_traits, metadata>     	node;
+      typedef base_type::_Head<synth_access_traits, metadata> 	       	head;
+      typedef base_type::_Leaf<synth_access_traits, metadata> 	       	leaf;
+      typedef base_type::_Inode<synth_access_traits, metadata> 	       	inode;
+
+      typedef base_type::_CIter<node, leaf, head, inode, true> 		const_iterator;
+      typedef const_iterator 					       	iterator;
+      typedef base_type::_CIter<node, leaf, head, inode, false>	       	const_reverse_iterator;
+      typedef const_reverse_iterator 			       		reverse_iterator;
+
+      /// This is an iterator to an iterator: it iterates over nodes,
+      /// and de-referencing it returns one of the tree's iterators.
+      typedef base_type::_Node_citer<node, leaf, head, inode, const_iterator, iterator, _Alloc> node_const_iterator;
+
+      typedef node_const_iterator 								node_iterator;
+
+      /// Type for node update.
+      typedef Node_Update<node_const_iterator, node_iterator, _ATraits, _Alloc> 		node_update;
+
+      typedef null_node_update<node_const_iterator, node_const_iterator, _ATraits, _Alloc>* 	null_node_update_pointer;
+    };
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_PAT_TRIE_NODE_AND_IT_TRAITS_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp
new file mode 100644
index 0000000..8b4e532
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp
@@ -0,0 +1,55 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file pat_trie_/update_fn_imps.hpp
+ * Contains an implementation class for pat_trie_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+apply_update(node_pointer, null_node_update_pointer)
+{ }
+
+PB_DS_CLASS_T_DEC
+template<typename Node_Update_>
+inline void
+PB_DS_CLASS_C_DEC::
+apply_update(node_pointer p_nd, Node_Update_*)
+{
+  Node_Update_::operator()(node_iterator(p_nd, this),
+			   node_const_iterator(0, this));
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/priority_queue_base_dispatch.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/priority_queue_base_dispatch.hpp
new file mode 100644
index 0000000..c20bcd1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/priority_queue_base_dispatch.hpp
@@ -0,0 +1,114 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/priority_queue_base_dispatch.hpp
+ * Contains an pqiative container dispatching base.
+ */
+
+#ifndef PB_DS_PRIORITY_QUEUE_BASE_DS_DISPATCHER_HPP
+#define PB_DS_PRIORITY_QUEUE_BASE_DS_DISPATCHER_HPP
+
+#define PB_DS_ASSERT_VALID(X)						\
+  _GLIBCXX_DEBUG_ONLY(X.assert_valid(__FILE__, __LINE__);)
+
+#define PB_DS_DEBUG_VERIFY(_Cond)					\
+  _GLIBCXX_DEBUG_VERIFY_AT(_Cond,					\
+			   _M_message(#_Cond" assertion from %1;:%2;")	\
+			   ._M_string(__FILE__)._M_integer(__LINE__)	\
+			   ,__file,__line)
+
+#include <ext/pb_ds/detail/pairing_heap_/pairing_heap_.hpp>
+#include <ext/pb_ds/detail/binomial_heap_/binomial_heap_.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp>
+#include <ext/pb_ds/detail/binary_heap_/binary_heap_.hpp>
+#include <ext/pb_ds/detail/thin_heap_/thin_heap_.hpp>
+
+#undef PB_DS_DEBUG_VERIFY
+#undef PB_DS_ASSERT_VALID
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Specialization for pairing_heap.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc>
+      struct container_base_dispatch<_VTp, Cmp_Fn, _Alloc, pairing_heap_tag,
+				     null_type>
+      {
+	/// Dispatched type.
+	typedef pairing_heap<_VTp, Cmp_Fn, _Alloc> 		type;
+      };
+
+    /// Specialization for binomial_heap.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc>
+      struct container_base_dispatch<_VTp, Cmp_Fn, _Alloc, binomial_heap_tag,
+				     null_type>
+      {
+	/// Dispatched type.
+	typedef binomial_heap<_VTp, Cmp_Fn, _Alloc> 		type;
+      };
+
+    /// Specialization for rc_binary_heap.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc>
+      struct container_base_dispatch<_VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag,
+  				     null_type>
+      {
+	/// Dispatched type.
+	typedef rc_binomial_heap<_VTp, Cmp_Fn, _Alloc>	       	type;
+      };
+
+    /// Specialization for binary_heap.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc>
+      struct container_base_dispatch<_VTp, Cmp_Fn, _Alloc, binary_heap_tag,
+  				     null_type>
+      {
+	/// Dispatched type.
+	typedef binary_heap<_VTp, Cmp_Fn, _Alloc> 		type;
+      };
+
+    /// Specialization for thin_heap.
+    template<typename _VTp, typename Cmp_Fn, typename _Alloc>
+      struct container_base_dispatch<_VTp, Cmp_Fn, _Alloc, thin_heap_tag,
+  				     null_type>    
+      {
+	/// Dispatched type.
+	typedef thin_heap<_VTp, Cmp_Fn, _Alloc> 		type;
+      };
+    //@} group pbds
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_PRIORITY_QUEUE_BASE_DS_DISPATCHER_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..9f17857
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    insert(*(first_it++));
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_RB_TREE_NAME()
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_RB_TREE_NAME(const Cmp_Fn& r_cmp_fn) :
+  base_type(r_cmp_fn)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_RB_TREE_NAME(const Cmp_Fn& r_cmp_fn, const node_update& r_node_update) :
+  base_type(r_cmp_fn, r_node_update)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_RB_TREE_NAME(const PB_DS_CLASS_C_DEC& other) :
+  base_type(other)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  base_type::swap(other);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize()
+{ base_type::m_p_head->m_red = true; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp
new file mode 100644
index 0000000..907c42c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp
@@ -0,0 +1,81 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/debug_fn_imps.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+assert_node_consistent(const node_pointer p_nd, const char* __file,
+						int __line) const
+{
+  if (p_nd == 0)
+    return 1;
+
+  const size_type l_height =
+    assert_node_consistent(p_nd->m_p_left, __file, __line);
+  const size_type r_height =
+    assert_node_consistent(p_nd->m_p_right, __file, __line);
+  if (p_nd->m_red)
+    {
+      PB_DS_DEBUG_VERIFY(is_effectively_black(p_nd->m_p_left));
+      PB_DS_DEBUG_VERIFY(is_effectively_black(p_nd->m_p_right));
+    }
+  PB_DS_DEBUG_VERIFY(l_height == r_height);
+  return (p_nd->m_red ? 0 : 1) + l_height;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  base_type::assert_valid(__file, __line);
+  const node_pointer p_head = base_type::m_p_head;
+  PB_DS_DEBUG_VERIFY(p_head->m_red);
+  if (p_head->m_p_parent != 0)
+    {
+      PB_DS_DEBUG_VERIFY(!p_head->m_p_parent->m_red);
+      assert_node_consistent(p_head->m_p_parent, __file, __line);
+    }
+}
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp
new file mode 100644
index 0000000..9b15edc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp
@@ -0,0 +1,289 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/erase_fn_imps.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase(key_const_reference r_key)
+{
+  point_iterator it = this->find(r_key);
+  if (it == base_type::end())
+    return false;
+  erase(it);
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+erase(iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (it == base_type::end())
+    return it;
+
+  iterator ret_it = it;
+  ++ret_it;
+  erase_node(it.m_p_nd);
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::reverse_iterator
+PB_DS_CLASS_C_DEC::
+erase(reverse_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (it.m_p_nd == base_type::m_p_head)
+    return it;
+
+  reverse_iterator ret_it = it;
+  ++ret_it;
+  erase_node(it.m_p_nd);
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+  size_type num_ersd = 0;
+  iterator it = base_type::begin();
+  while (it != base_type::end())
+    {
+      if (pred(*it))
+        {
+	  ++num_ersd;
+	  it = erase(it);
+        }
+      else
+	++it;
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+  return num_ersd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_node(node_pointer p_nd)
+{
+  remove_node(p_nd);
+  base_type::actual_erase_node(p_nd);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+remove_node(node_pointer p_z)
+{
+  this->update_min_max_for_erased_node(p_z);
+  node_pointer p_y = p_z;
+  node_pointer p_x = 0;
+  node_pointer p_new_x_parent = 0;
+
+  if (p_y->m_p_left == 0)
+    p_x = p_y->m_p_right;
+  else if (p_y->m_p_right == 0)
+    p_x = p_y->m_p_left;
+  else
+    {
+      p_y = p_y->m_p_right;
+      while (p_y->m_p_left != 0)
+	p_y = p_y->m_p_left;
+      p_x = p_y->m_p_right;
+    }
+
+  if (p_y == p_z)
+    {
+      p_new_x_parent = p_y->m_p_parent;
+      if (p_x != 0)
+	p_x->m_p_parent = p_y->m_p_parent;
+
+      if (base_type::m_p_head->m_p_parent == p_z)
+	base_type::m_p_head->m_p_parent = p_x;
+      else if (p_z->m_p_parent->m_p_left == p_z)
+        {
+	  p_y->m_p_left = p_z->m_p_parent;
+	  p_z->m_p_parent->m_p_left = p_x;
+        }
+      else
+        {
+	  p_y->m_p_left = 0;
+	  p_z->m_p_parent->m_p_right = p_x;
+        }
+    }
+  else
+    {
+      p_z->m_p_left->m_p_parent = p_y;
+      p_y->m_p_left = p_z->m_p_left;
+      if (p_y != p_z->m_p_right)
+        {
+	  p_new_x_parent = p_y->m_p_parent;
+	  if (p_x != 0)
+	    p_x->m_p_parent = p_y->m_p_parent;
+	  p_y->m_p_parent->m_p_left = p_x;
+	  p_y->m_p_right = p_z->m_p_right;
+	  p_z->m_p_right->m_p_parent = p_y;
+        }
+      else
+	p_new_x_parent = p_y;
+
+      if (base_type::m_p_head->m_p_parent == p_z)
+	base_type::m_p_head->m_p_parent = p_y;
+      else if (p_z->m_p_parent->m_p_left == p_z)
+	p_z->m_p_parent->m_p_left = p_y;
+      else
+	p_z->m_p_parent->m_p_right = p_y;
+
+      p_y->m_p_parent = p_z->m_p_parent;
+      std::swap(p_y->m_red, p_z->m_red);
+      p_y = p_z;
+    }
+
+  this->update_to_top(p_new_x_parent, (node_update* )this);
+
+  if (p_y->m_red)
+    return;
+
+  remove_fixup(p_x, p_new_x_parent);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+remove_fixup(node_pointer p_x, node_pointer p_new_x_parent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_x == 0 || p_x->m_p_parent == p_new_x_parent);
+
+  while (p_x != base_type::m_p_head->m_p_parent && is_effectively_black(p_x))
+    if (p_x == p_new_x_parent->m_p_left)
+      {
+	node_pointer p_w = p_new_x_parent->m_p_right;
+	if (p_w->m_red)
+	  {
+	    p_w->m_red = false;
+	    p_new_x_parent->m_red = true;
+	    base_type::rotate_left(p_new_x_parent);
+	    p_w = p_new_x_parent->m_p_right;
+	  }
+
+	if (is_effectively_black(p_w->m_p_left) 
+	    && is_effectively_black(p_w->m_p_right))
+	  {
+	    p_w->m_red = true;
+	    p_x = p_new_x_parent;
+	    p_new_x_parent = p_new_x_parent->m_p_parent;
+	  }
+	else
+	  {
+	    if (is_effectively_black(p_w->m_p_right))
+	      {
+		if (p_w->m_p_left != 0)
+		  p_w->m_p_left->m_red = false;
+
+		p_w->m_red = true;
+		base_type::rotate_right(p_w);
+		p_w = p_new_x_parent->m_p_right;
+	      }
+
+	    p_w->m_red = p_new_x_parent->m_red;
+	    p_new_x_parent->m_red = false;
+
+	    if (p_w->m_p_right != 0)
+	      p_w->m_p_right->m_red = false;
+
+	    base_type::rotate_left(p_new_x_parent);
+	    this->update_to_top(p_new_x_parent, (node_update* )this);
+	    break;
+	  }
+      }
+    else
+      {
+	node_pointer p_w = p_new_x_parent->m_p_left;
+	if (p_w->m_red == true)
+	  {
+	    p_w->m_red = false;
+	    p_new_x_parent->m_red = true;
+	    base_type::rotate_right(p_new_x_parent);
+	    p_w = p_new_x_parent->m_p_left;
+	  }
+
+	if (is_effectively_black(p_w->m_p_right) 
+	    && is_effectively_black(p_w->m_p_left))
+	  {
+	    p_w->m_red = true;
+	    p_x = p_new_x_parent;
+	    p_new_x_parent = p_new_x_parent->m_p_parent;
+	  }
+	else
+	  {
+	    if (is_effectively_black(p_w->m_p_left))
+	      {
+		if (p_w->m_p_right != 0)
+		  p_w->m_p_right->m_red = false;
+
+		p_w->m_red = true;
+		base_type::rotate_left(p_w);
+		p_w = p_new_x_parent->m_p_left;
+	      }
+
+	    p_w->m_red = p_new_x_parent->m_red;
+	    p_new_x_parent->m_red = false;
+
+	    if (p_w->m_p_left != 0)
+	      p_w->m_p_left->m_red = false;
+
+	    base_type::rotate_right(p_new_x_parent);
+	    this->update_to_top(p_new_x_parent, (node_update* )this);
+	    break;
+	  }
+      }
+
+  if (p_x != 0)
+    p_x->m_red = false;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/find_fn_imps.hpp
new file mode 100644
index 0000000..838b92f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/find_fn_imps.hpp
@@ -0,0 +1,39 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/find_fn_imps.hpp
+ * Contains an implementation for rb_tree_.
+ */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp
new file mode 100644
index 0000000..8fa593e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/info_fn_imps.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+is_effectively_black(const node_pointer p_nd)
+{ return (p_nd == 0 || !p_nd->m_red); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp
new file mode 100644
index 0000000..40cb248
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp
@@ -0,0 +1,115 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/insert_fn_imps.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert(const_reference r_value)
+{
+  PB_DS_ASSERT_VALID((*this))
+  std::pair<point_iterator, bool> ins_pair = base_type::insert_leaf(r_value);
+  if (ins_pair.second == true)
+    {
+      ins_pair.first.m_p_nd->m_red = true;
+      PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+      insert_fixup(ins_pair.first.m_p_nd);
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+  return ins_pair;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+insert_fixup(node_pointer p_nd)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_red == true);
+  while (p_nd != base_type::m_p_head->m_p_parent && p_nd->m_p_parent->m_red)
+    {
+      if (p_nd->m_p_parent == p_nd->m_p_parent->m_p_parent->m_p_left)
+        {
+	  node_pointer p_y = p_nd->m_p_parent->m_p_parent->m_p_right;
+	  if (p_y != 0 && p_y->m_red)
+            {
+	      p_nd->m_p_parent->m_red = false;
+	      p_y->m_red = false;
+	      p_nd->m_p_parent->m_p_parent->m_red = true;
+	      p_nd = p_nd->m_p_parent->m_p_parent;
+            }
+	  else
+            {
+	      if (p_nd == p_nd->m_p_parent->m_p_right)
+                {
+		  p_nd = p_nd->m_p_parent;
+		  base_type::rotate_left(p_nd);
+                }
+	      p_nd->m_p_parent->m_red = false;
+	      p_nd->m_p_parent->m_p_parent->m_red = true;
+	      base_type::rotate_right(p_nd->m_p_parent->m_p_parent);
+            }
+        }
+      else
+        {
+	  node_pointer p_y = p_nd->m_p_parent->m_p_parent->m_p_left;
+	  if (p_y != 0 && p_y->m_red)
+            {
+	      p_nd->m_p_parent->m_red = false;
+	      p_y->m_red = false;
+	      p_nd->m_p_parent->m_p_parent->m_red = true;
+	      p_nd = p_nd->m_p_parent->m_p_parent;
+            }
+	  else
+            {
+	      if (p_nd == p_nd->m_p_parent->m_p_left)
+                {
+		  p_nd = p_nd->m_p_parent;
+		  base_type::rotate_right(p_nd);
+                }
+	      p_nd->m_p_parent->m_red = false;
+	      p_nd->m_p_parent->m_p_parent->m_red = true;
+	      base_type::rotate_left(p_nd->m_p_parent->m_p_parent);
+            }
+        }
+    }
+
+  base_type::update_to_top(p_nd, (node_update* )this);
+  base_type::m_p_head->m_p_parent->m_red = false;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/node.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/node.hpp
new file mode 100644
index 0000000..3859ab3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/node.hpp
@@ -0,0 +1,139 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/node.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+#ifndef PB_DS_RB_TREE_NODE_HPP
+#define PB_DS_RB_TREE_NODE_HPP
+
+#include <ext/pb_ds/detail/branch_policy/null_node_metadata.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Node for Red-Black trees.
+    template<typename Value_Type, class Metadata, typename _Alloc>
+    struct rb_tree_node_
+    {
+    public:
+      typedef Value_Type 		value_type;
+      typedef Metadata 			metadata_type;
+
+      typedef
+      typename _Alloc::template rebind<
+      rb_tree_node_<
+      Value_Type,
+      Metadata,
+      _Alloc> >::other::pointer
+      node_pointer;
+
+      typedef
+      typename _Alloc::template rebind<
+	metadata_type>::other::reference
+      metadata_reference;
+
+      typedef
+      typename _Alloc::template rebind<
+	metadata_type>::other::const_reference
+      metadata_const_reference;
+
+      bool
+      special() const
+      { return m_red; }
+
+      metadata_const_reference
+      get_metadata() const
+      { return m_metadata; }
+
+      metadata_reference
+      get_metadata()
+      { return m_metadata; }
+
+#ifdef PB_DS_BIN_SEARCH_TREE_TRACE_
+      void
+      trace() const
+      {
+	std::cout << PB_DS_V2F(m_value) <<(m_red? " <r> " : " <b> ") 
+		  << "(" << m_metadata << ")";
+      }
+#endif
+
+      node_pointer 	m_p_left;
+      node_pointer 	m_p_right;
+      node_pointer 	m_p_parent;
+      value_type 	m_value;
+      bool 		m_red;
+      metadata_type 	m_metadata;
+    };
+
+    template<typename Value_Type, typename _Alloc>
+    struct rb_tree_node_<Value_Type, null_type, _Alloc>
+    {
+    public:
+      typedef Value_Type 		value_type;
+      typedef null_type 	metadata_type;
+
+      typedef
+      typename _Alloc::template rebind<
+      rb_tree_node_<
+      Value_Type,
+      null_type,
+      _Alloc> >::other::pointer
+      node_pointer;
+
+      bool
+      special() const
+      { return m_red; }
+
+#ifdef PB_DS_BIN_SEARCH_TREE_TRACE_
+      void
+      trace() const
+      { std::cout << PB_DS_V2F(m_value) <<(m_red? " <r> " : " <b> "); }
+#endif 
+
+      node_pointer 	m_p_left;
+      node_pointer 	m_p_right;
+      node_pointer 	m_p_parent;
+      value_type 	m_value;
+      bool 		m_red;
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp
new file mode 100644
index 0000000..a5f66f2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp
@@ -0,0 +1,248 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/rb_tree_.hpp
+ * Contains an implementation for Red Black trees.
+ */
+
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <utility>
+#include <vector>
+#include <assert.h>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Cmp_Fn, \
+	     typename Node_And_It_Traits, typename _Alloc>
+
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+# define PB_DS_RB_TREE_NAME rb_tree_map
+# define PB_DS_RB_TREE_BASE_NAME bin_search_tree_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+# define PB_DS_RB_TREE_NAME rb_tree_set
+# define PB_DS_RB_TREE_BASE_NAME bin_search_tree_set
+#endif
+
+#define PB_DS_CLASS_C_DEC \
+    PB_DS_RB_TREE_NAME<Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc>
+
+#define PB_DS_RB_TREE_BASE \
+    PB_DS_RB_TREE_BASE_NAME<Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc>
+
+
+    /**
+     *  @brief Red-Black tree.
+     *  @ingroup branch-detail
+     *
+     *  This implementation uses an idea from the SGI STL (using a
+     *  @a header node which is needed for efficient iteration).
+     */
+    template<typename Key,
+	     typename Mapped,
+	     typename Cmp_Fn,
+	     typename Node_And_It_Traits,
+	     typename _Alloc>
+    class PB_DS_RB_TREE_NAME : public PB_DS_RB_TREE_BASE
+    {
+    private:
+      typedef PB_DS_RB_TREE_BASE 		       	 base_type;
+      typedef typename base_type::node_pointer 		 node_pointer;
+
+    public:
+      typedef rb_tree_tag 				 container_category;
+      typedef Cmp_Fn 					 cmp_fn;
+      typedef _Alloc 					 allocator_type;
+      typedef typename _Alloc::size_type 		 size_type;
+      typedef typename _Alloc::difference_type 		 difference_type;
+      typedef typename base_type::key_type 		 key_type;
+      typedef typename base_type::key_pointer 		 key_pointer;
+      typedef typename base_type::key_const_pointer 	 key_const_pointer;
+      typedef typename base_type::key_reference 	 key_reference;
+      typedef typename base_type::key_const_reference 	 key_const_reference;
+      typedef typename base_type::mapped_type 		 mapped_type;
+      typedef typename base_type::mapped_pointer 	 mapped_pointer;
+      typedef typename base_type::mapped_const_pointer 	 mapped_const_pointer;
+      typedef typename base_type::mapped_reference 	 mapped_reference;
+      typedef typename base_type::mapped_const_reference mapped_const_reference;
+      typedef typename base_type::value_type 		 value_type;
+      typedef typename base_type::pointer 		 pointer;
+      typedef typename base_type::const_pointer 	 const_pointer;
+      typedef typename base_type::reference 		 reference;
+      typedef typename base_type::const_reference 	 const_reference;
+      typedef typename base_type::point_iterator 	 point_iterator;
+      typedef typename base_type::const_iterator 	 point_const_iterator;
+      typedef typename base_type::iterator 		 iterator;
+      typedef typename base_type::const_iterator 	 const_iterator;
+      typedef typename base_type::reverse_iterator 	 reverse_iterator;
+      typedef typename base_type::const_reverse_iterator const_reverse_iterator;
+      typedef typename base_type::node_update 		 node_update;
+
+      PB_DS_RB_TREE_NAME();
+
+      PB_DS_RB_TREE_NAME(const Cmp_Fn&);
+
+      PB_DS_RB_TREE_NAME(const Cmp_Fn&, const node_update&);
+
+      PB_DS_RB_TREE_NAME(const PB_DS_CLASS_C_DEC&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+      inline std::pair<point_iterator, bool>
+      insert(const_reference);
+
+      inline mapped_reference
+      operator[](key_const_reference r_key)
+      {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	std::pair<point_iterator, bool> ins_pair =
+	base_type::insert_leaf(value_type(r_key, mapped_type()));
+
+	if (ins_pair.second == true)
+	  {
+	    ins_pair.first.m_p_nd->m_red = true;
+	    _GLIBCXX_DEBUG_ONLY(this->structure_only_assert_valid(__FILE__, __LINE__);)
+	    insert_fixup(ins_pair.first.m_p_nd);
+	  }
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	return ins_pair.first.m_p_nd->m_value.second;
+#else
+	insert(r_key);
+	return base_type::s_null_type;
+#endif
+      }
+
+      inline bool
+      erase(key_const_reference);
+
+      inline iterator
+      erase(iterator);
+
+      inline reverse_iterator
+      erase(reverse_iterator);
+
+      template<typename Pred>
+      inline size_type
+      erase_if(Pred);
+
+      void
+      join(PB_DS_CLASS_C_DEC&);
+
+      void
+      split(key_const_reference, PB_DS_CLASS_C_DEC&);
+
+    private:
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+
+      size_type
+      assert_node_consistent(const node_pointer, const char*, int) const;
+#endif
+
+      inline static bool
+      is_effectively_black(const node_pointer);
+
+      void
+      initialize();
+
+      void
+      insert_fixup(node_pointer);
+
+      void
+      erase_node(node_pointer);
+
+      void
+      remove_node(node_pointer);
+
+      void
+      remove_fixup(node_pointer, node_pointer);
+
+      void
+      split_imp(node_pointer, PB_DS_CLASS_C_DEC&);
+
+      inline node_pointer
+      split_min();
+
+      std::pair<node_pointer, node_pointer>
+      split_min_imp();
+
+      void
+      join_imp(node_pointer, node_pointer);
+
+      std::pair<node_pointer, node_pointer>
+      find_join_pos_right(node_pointer, size_type, size_type);
+
+      std::pair<node_pointer, node_pointer>
+      find_join_pos_left(node_pointer, size_type, size_type);
+
+      inline size_type
+      black_height(node_pointer);
+
+      void
+      split_at_node(node_pointer, PB_DS_CLASS_C_DEC&);
+    };
+
+#define PB_DS_STRUCT_ONLY_ASSERT_VALID(X)				\
+  _GLIBCXX_DEBUG_ONLY(X.structure_only_assert_valid(__FILE__, __LINE__);)
+
+#include <ext/pb_ds/detail/rb_tree_map_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp>
+#include <ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp>
+
+#undef PB_DS_STRUCT_ONLY_ASSERT_VALID
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_RB_TREE_NAME
+#undef PB_DS_RB_TREE_BASE_NAME
+#undef PB_DS_RB_TREE_BASE
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..ea26574
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp
@@ -0,0 +1,306 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/split_join_fn_imps.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  if (base_type::join_prep(other) == false)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  const node_pointer p_x = other.split_min();
+  join_imp(p_x, other.m_p_head->m_p_parent);
+  base_type::join_finish(other);
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+join_imp(node_pointer p_x, node_pointer p_r)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_x != 0);
+  if (p_r != 0)
+    p_r->m_red = false;
+
+  const size_type h = black_height(base_type::m_p_head->m_p_parent);
+  const size_type other_h = black_height(p_r);
+  node_pointer p_x_l;
+  node_pointer p_x_r;
+  std::pair<node_pointer, node_pointer> join_pos;
+  const bool right_join = h >= other_h;
+  if (right_join)
+    {
+      join_pos = find_join_pos_right(base_type::m_p_head->m_p_parent, 
+				     h, other_h);
+      p_x_l = join_pos.first;
+      p_x_r = p_r;
+    }
+  else
+    {
+      p_x_l = base_type::m_p_head->m_p_parent;
+      base_type::m_p_head->m_p_parent = p_r;
+      if (p_r != 0)
+	p_r->m_p_parent = base_type::m_p_head;
+
+      join_pos = find_join_pos_left(base_type::m_p_head->m_p_parent, 
+				    h, other_h);
+      p_x_r = join_pos.first;
+    }
+
+  node_pointer p_parent = join_pos.second;
+  if (p_parent == base_type::m_p_head)
+    {
+      base_type::m_p_head->m_p_parent = p_x;
+      p_x->m_p_parent = base_type::m_p_head;
+    }
+  else
+    {
+      p_x->m_p_parent = p_parent;
+      if (right_join)
+	p_x->m_p_parent->m_p_right = p_x;
+      else
+	p_x->m_p_parent->m_p_left = p_x;
+    }
+
+  p_x->m_p_left = p_x_l;
+  if (p_x_l != 0)
+    p_x_l->m_p_parent = p_x;
+
+  p_x->m_p_right = p_x_r;
+  if (p_x_r != 0)
+    p_x_r->m_p_parent = p_x;
+
+  p_x->m_red = true;
+
+  base_type::initialize_min_max();
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  base_type::update_to_top(p_x, (node_update* )this);
+  insert_fixup(p_x);
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+split_min()
+{
+  node_pointer p_min = base_type::m_p_head->m_p_left;
+
+#ifdef _GLIBCXX_DEBUG
+  const node_pointer p_head = base_type::m_p_head;
+  _GLIBCXX_DEBUG_ASSERT(p_min != p_head);
+#endif 
+
+  remove_node(p_min);
+  return p_min;
+}
+
+PB_DS_CLASS_T_DEC
+std::pair<
+  typename PB_DS_CLASS_C_DEC::node_pointer,
+  typename PB_DS_CLASS_C_DEC::node_pointer>
+PB_DS_CLASS_C_DEC::
+find_join_pos_right(node_pointer p_l, size_type h_l, size_type h_r)
+{
+  _GLIBCXX_DEBUG_ASSERT(h_l >= h_r);
+
+  if (base_type::m_p_head->m_p_parent == 0)
+    return (std::make_pair((node_pointer)0, base_type::m_p_head));
+
+  node_pointer p_l_parent = base_type::m_p_head;
+  while (h_l > h_r)
+    {
+      if (p_l->m_red == false)
+        {
+	  _GLIBCXX_DEBUG_ASSERT(h_l > 0);
+	  --h_l;
+        }
+
+      p_l_parent = p_l;
+      p_l = p_l->m_p_right;
+    }
+
+  if (!is_effectively_black(p_l))
+    {
+      p_l_parent = p_l;
+      p_l = p_l->m_p_right;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_l));
+  _GLIBCXX_DEBUG_ASSERT(black_height(p_l) == h_r);
+  _GLIBCXX_DEBUG_ASSERT(p_l == 0 || p_l->m_p_parent == p_l_parent);
+  return std::make_pair(p_l, p_l_parent);
+}
+
+PB_DS_CLASS_T_DEC
+std::pair<
+  typename PB_DS_CLASS_C_DEC::node_pointer,
+  typename PB_DS_CLASS_C_DEC::node_pointer>
+PB_DS_CLASS_C_DEC::
+find_join_pos_left(node_pointer p_r, size_type h_l, size_type h_r)
+{
+  _GLIBCXX_DEBUG_ASSERT(h_r > h_l);
+  if (base_type::m_p_head->m_p_parent == 0)
+    return (std::make_pair((node_pointer)0,
+			   base_type::m_p_head));
+  node_pointer p_r_parent = base_type::m_p_head;
+  while (h_r > h_l)
+    {
+      if (p_r->m_red == false)
+        {
+	  _GLIBCXX_DEBUG_ASSERT(h_r > 0);
+	  --h_r;
+        }
+
+      p_r_parent = p_r;
+      p_r = p_r->m_p_left;
+    }
+
+  if (!is_effectively_black(p_r))
+    {
+      p_r_parent = p_r;
+      p_r = p_r->m_p_left;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_r));
+  _GLIBCXX_DEBUG_ASSERT(black_height(p_r) == h_l);
+  _GLIBCXX_DEBUG_ASSERT(p_r == 0 || p_r->m_p_parent == p_r_parent);
+  return std::make_pair(p_r, p_r_parent);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+black_height(node_pointer p_nd)
+{
+  size_type h = 1;
+  while (p_nd != 0)
+    {
+      if (p_nd->m_red == false)
+	++h;
+      p_nd = p_nd->m_p_left;
+    }
+  return h;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+split(key_const_reference r_key, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  if (base_type::split_prep(r_key, other) == false)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  PB_DS_STRUCT_ONLY_ASSERT_VALID(other)
+  node_pointer p_nd = this->upper_bound(r_key).m_p_nd;
+  do
+    {
+      node_pointer p_next_nd = p_nd->m_p_parent;
+      if (Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value)))
+	split_at_node(p_nd, other);
+
+      PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+      PB_DS_STRUCT_ONLY_ASSERT_VALID(other)
+      p_nd = p_next_nd;
+    }
+  while (p_nd != base_type::m_p_head);
+
+  base_type::split_finish(other);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+split_at_node(node_pointer p_nd, PB_DS_CLASS_C_DEC& other)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+
+  node_pointer p_l = p_nd->m_p_left;
+  node_pointer p_r = p_nd->m_p_right;
+  node_pointer p_parent = p_nd->m_p_parent;
+  if (p_parent == base_type::m_p_head)
+    {
+      base_type::m_p_head->m_p_parent = p_l;
+      if (p_l != 0)
+        {
+	  p_l->m_p_parent = base_type::m_p_head;
+	  p_l->m_red = false;
+        }
+    }
+  else
+    {
+      if (p_parent->m_p_left == p_nd)
+	p_parent->m_p_left = p_l;
+      else
+	p_parent->m_p_right = p_l;
+
+      if (p_l != 0)
+	p_l->m_p_parent = p_parent;
+
+      this->update_to_top(p_parent, (node_update* )this);
+
+      if (!p_nd->m_red)
+	remove_fixup(p_l, p_parent);
+    }
+
+  base_type::initialize_min_max();
+  other.join_imp(p_nd, p_r);
+  PB_DS_STRUCT_ONLY_ASSERT_VALID((*this))
+  PB_DS_STRUCT_ONLY_ASSERT_VALID(other)
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/traits.hpp
new file mode 100644
index 0000000..d13b179
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/traits.hpp
@@ -0,0 +1,102 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rb_tree_map_/traits.hpp
+ * Contains an implementation for rb_tree_.
+ */
+
+#ifndef PB_DS_RB_TREE_NODE_AND_IT_TRAITS_HPP
+#define PB_DS_RB_TREE_NODE_AND_IT_TRAITS_HPP
+
+#include <ext/pb_ds/detail/rb_tree_map_/node.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     typename Mapped,
+	     typename Cmp_Fn,
+	     template<typename Node_CItr,
+		      typename Node_Itr,
+		      typename Cmp_Fn_,
+		      typename _Alloc_>
+	     class Node_Update,
+	     typename _Alloc>
+    struct tree_traits<Key, Mapped, Cmp_Fn, Node_Update, rb_tree_tag,_Alloc> 
+    : public bin_search_tree_traits<
+      Key,
+      Mapped,
+      Cmp_Fn,
+      Node_Update,
+      rb_tree_node_<
+	typename types_traits<Key, Mapped, _Alloc, false>::value_type,
+	typename tree_node_metadata_dispatch<Key, Mapped, Cmp_Fn, Node_Update,
+					     _Alloc>::type,
+	_Alloc>,
+      _Alloc>
+    { };
+
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     typename Cmp_Fn,
+	     template<typename Node_CItr,
+		      typename Node_Itr,
+		      typename Cmp_Fn_,
+		      typename _Alloc_>
+	     class Node_Update,
+	     typename _Alloc>
+    struct tree_traits<Key, null_type, Cmp_Fn, Node_Update, rb_tree_tag,_Alloc> 
+    : public bin_search_tree_traits<
+      Key,
+      null_type,
+      Cmp_Fn,
+      Node_Update,
+      rb_tree_node_<
+      typename types_traits<Key, null_type, _Alloc, false>::value_type,
+      typename tree_node_metadata_dispatch<Key, null_type, Cmp_Fn, Node_Update,
+					   _Alloc>::type,
+	_Alloc>,
+	  _Alloc>
+    { };
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..a563445
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation for rc_binomial_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+rc_binomial_heap()
+{
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+rc_binomial_heap(const Cmp_Fn& r_cmp_fn) 
+: base_type(r_cmp_fn)
+{
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+rc_binomial_heap(const PB_DS_CLASS_C_DEC& other) 
+: base_type(other)
+{
+  make_binomial_heap();
+  base_type::find_max();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~rc_binomial_heap()
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  base_type::swap(other);
+  m_rc.swap(other.m_rc);
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp
new file mode 100644
index 0000000..d42f418
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp
@@ -0,0 +1,121 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/debug_fn_imps.hpp
+ * Contains an implementation for rc_binomial_heap_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  base_type::assert_valid(false, __file, __line);
+  if (!base_type::empty())
+    {
+      PB_DS_DEBUG_VERIFY(base_type::m_p_max != 0);
+      base_type::assert_max(__file, __line);
+    }
+
+  m_rc.assert_valid(__file, __line);
+
+  if (m_rc.empty())
+    {
+      base_type::assert_valid(true, __file, __line);
+      PB_DS_DEBUG_VERIFY(next_2_pointer(base_type::m_p_root) == 0);
+      return;
+    }
+
+  node_const_pointer p_nd = next_2_pointer(base_type::m_p_root);
+  typename rc_t::const_iterator it = m_rc.end();
+  --it;
+
+  while (p_nd != 0)
+    {
+      PB_DS_DEBUG_VERIFY(*it == p_nd);
+      node_const_pointer p_next = p_nd->m_p_next_sibling;
+      PB_DS_DEBUG_VERIFY(p_next != 0);
+      PB_DS_DEBUG_VERIFY(p_nd->m_metadata == p_next->m_metadata);
+      PB_DS_DEBUG_VERIFY(p_next->m_p_next_sibling == 0 ||
+		       p_next->m_metadata < p_next->m_p_next_sibling->m_metadata);
+
+      --it;
+      p_nd = next_2_pointer(next_after_0_pointer(p_nd));
+    }
+  PB_DS_DEBUG_VERIFY(it + 1 == m_rc.begin());
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_const_pointer
+PB_DS_CLASS_C_DEC::
+next_2_pointer(node_const_pointer p_nd)
+{
+  if (p_nd == 0)
+    return 0;
+
+  node_pointer p_next = p_nd->m_p_next_sibling;
+
+  if (p_next == 0)
+    return 0;
+
+  if (p_nd->m_metadata == p_next->m_metadata)
+    return p_nd;
+
+  return next_2_pointer(p_next);
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_const_pointer
+PB_DS_CLASS_C_DEC::
+next_after_0_pointer(node_const_pointer p_nd)
+{
+  if (p_nd == 0)
+    return 0;
+
+  node_pointer p_next = p_nd->m_p_next_sibling;
+
+  if (p_next == 0)
+    return 0;
+
+  if (p_nd->m_metadata < p_next->m_metadata)
+    return p_next;
+
+  return next_after_0_pointer(p_next);
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp
new file mode 100644
index 0000000..2d6a6e1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp
@@ -0,0 +1,107 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/erase_fn_imps.hpp
+ * Contains an implementation for rc_binomial_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+pop()
+{
+  make_binomial_heap();
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+  base_type::pop();
+  base_type::find_max();
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  base_type::clear();
+  m_rc.clear();
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+make_binomial_heap()
+{
+  node_pointer p_nd = base_type::m_p_root;
+  while (p_nd != 0)
+    {
+      node_pointer p_next = p_nd->m_p_next_sibling;
+      if (p_next == 0)
+	p_nd = p_next;
+      else if (p_nd->m_metadata == p_next->m_metadata)
+	p_nd = link_with_next_sibling(p_nd);
+      else if (p_nd->m_metadata < p_next->m_metadata)
+	p_nd = p_next;
+#ifdef _GLIBCXX_DEBUG
+      else
+	_GLIBCXX_DEBUG_ASSERT(0);
+#endif 
+    }
+
+  m_rc.clear();
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  make_binomial_heap();
+  const size_type ersd = base_type::erase_if(pred);
+  base_type::find_max();
+  PB_DS_ASSERT_VALID((*this))
+  return ersd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase(point_iterator it)
+{
+  make_binomial_heap();
+  base_type::erase(it);
+  base_type::find_max();
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp
new file mode 100644
index 0000000..35ae5a0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp
@@ -0,0 +1,154 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/insert_fn_imps.hpp
+ * Contains an implementation for rc_binomial_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+push(const_reference r_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  make_0_exposed();
+
+  PB_DS_ASSERT_VALID((*this))
+
+  node_pointer p_nd = base_type::get_new_node_for_insert(r_val);
+
+  p_nd->m_p_l_child = p_nd->m_p_prev_or_parent = 0;
+  p_nd->m_metadata = 0;
+
+  if (base_type::m_p_max == 0 || Cmp_Fn::operator()(base_type::m_p_max->m_value, r_val))
+    base_type::m_p_max = p_nd;
+
+  p_nd->m_p_next_sibling = base_type::m_p_root;
+
+  if (base_type::m_p_root != 0)
+    base_type::m_p_root->m_p_prev_or_parent = p_nd;
+
+  base_type::m_p_root = p_nd;
+
+  if (p_nd->m_p_next_sibling != 0&&  p_nd->m_p_next_sibling->m_metadata == 0)
+    m_rc.push(p_nd);
+
+  PB_DS_ASSERT_VALID((*this))
+
+  return point_iterator(p_nd);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+modify(point_iterator it, const_reference r_new_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+
+  make_binomial_heap();
+
+  base_type::modify(it, r_new_val);
+
+  base_type::find_max();
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+link_with_next_sibling(node_pointer p_nd)
+{
+  node_pointer p_next = p_nd->m_p_next_sibling;
+
+  _GLIBCXX_DEBUG_ASSERT(p_next != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_next->m_p_prev_or_parent == p_nd);
+
+  if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value))
+    {
+      p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent;
+
+      if (p_next->m_p_prev_or_parent == 0)
+	base_type::m_p_root = p_next;
+      else
+	p_next->m_p_prev_or_parent->m_p_next_sibling = p_next;
+
+      if (base_type::m_p_max == p_nd)
+	base_type::m_p_max = p_next;
+
+      base_type::make_child_of(p_nd, p_next);
+
+      ++p_next->m_metadata;
+
+      return p_next;
+    }
+
+  p_nd->m_p_next_sibling = p_next->m_p_next_sibling;
+
+  if (p_nd->m_p_next_sibling != 0)
+    p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd;
+
+  if (base_type::m_p_max == p_next)
+    base_type::m_p_max = p_nd;
+
+  base_type::make_child_of(p_next, p_nd);
+
+  ++p_nd->m_metadata;
+
+  return p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+make_0_exposed()
+{
+  if (m_rc.empty())
+    return;
+
+  node_pointer p_nd = m_rc.top();
+
+  m_rc.pop();
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata);
+
+  node_pointer p_res = link_with_next_sibling(p_nd);
+
+  if (p_res->m_p_next_sibling != 0&&  p_res->m_metadata == p_res->m_p_next_sibling->m_metadata)
+    m_rc.push(p_res);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc.hpp
new file mode 100644
index 0000000..eaf8f48
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc.hpp
@@ -0,0 +1,240 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/rc.hpp
+ * Contains a redundant (binary counter).
+ */
+
+#ifndef PB_DS_RC_HPP
+#define PB_DS_RC_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Redundant binary counter.
+    template<typename _Node, typename _Alloc>
+    class rc
+    {
+    private:
+      typedef _Alloc 					 allocator_type;
+      typedef typename allocator_type::size_type 	 size_type;
+      typedef _Node 					 node;
+
+      typedef typename _Alloc::template rebind<node>	 __rebind_n;
+      typedef typename __rebind_n::other::pointer      	 node_pointer;
+
+      typedef typename _Alloc::template rebind<node_pointer>  __rebind_np;
+
+      typedef typename __rebind_np::other::pointer 	 entry_pointer;
+      typedef typename __rebind_np::other::const_pointer entry_const_pointer;
+
+      enum
+	{
+	  max_entries = sizeof(size_type) << 3
+	};
+
+    public:
+      typedef node_pointer 				 entry;
+      typedef entry_const_pointer 			 const_iterator;
+
+      rc();
+
+      rc(const rc&);
+
+      inline void
+      swap(rc&);
+
+      inline void
+      push(entry);
+
+      inline node_pointer
+      top() const;
+
+      inline void
+      pop();
+
+      inline bool
+      empty() const;
+
+      inline size_type
+      size() const;
+
+      void
+      clear();
+
+      const const_iterator
+      begin() const;
+
+      const const_iterator
+      end() const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+
+#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    private:
+      node_pointer 	m_a_entries[max_entries];
+      size_type 	m_over_top;
+    };
+
+    template<typename _Node, typename _Alloc>
+    rc<_Node, _Alloc>::
+    rc() : m_over_top(0)
+    { PB_DS_ASSERT_VALID((*this)) }
+
+    template<typename _Node, typename _Alloc>
+    rc<_Node, _Alloc>::
+    rc(const rc<_Node, _Alloc>& other) : m_over_top(0)
+    { PB_DS_ASSERT_VALID((*this)) }
+
+    template<typename _Node, typename _Alloc>
+    inline void
+    rc<_Node, _Alloc>::
+    swap(rc<_Node, _Alloc>& other)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+
+      const size_type over_top = std::max(m_over_top, other.m_over_top);
+
+      for (size_type i = 0; i < over_top; ++i)
+	std::swap(m_a_entries[i], other.m_a_entries[i]);
+
+      std::swap(m_over_top, other.m_over_top);
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+     }
+
+    template<typename _Node, typename _Alloc>
+    inline void
+    rc<_Node, _Alloc>::
+    push(entry p_nd)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      _GLIBCXX_DEBUG_ASSERT(m_over_top < max_entries);
+      m_a_entries[m_over_top++] = p_nd;
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    template<typename _Node, typename _Alloc>
+    inline void
+    rc<_Node, _Alloc>::
+    pop()
+    {
+      PB_DS_ASSERT_VALID((*this))
+      _GLIBCXX_DEBUG_ASSERT(!empty());
+      --m_over_top;
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    template<typename _Node, typename _Alloc>
+    inline typename rc<_Node, _Alloc>::node_pointer
+    rc<_Node, _Alloc>::
+    top() const
+    {
+      PB_DS_ASSERT_VALID((*this))
+      _GLIBCXX_DEBUG_ASSERT(!empty());
+      return *(m_a_entries + m_over_top - 1);
+    }
+
+    template<typename _Node, typename _Alloc>
+    inline bool
+    rc<_Node, _Alloc>::
+    empty() const
+    {
+      PB_DS_ASSERT_VALID((*this))
+      return m_over_top == 0;
+    }
+
+    template<typename _Node, typename _Alloc>
+    inline typename rc<_Node, _Alloc>::size_type
+    rc<_Node, _Alloc>::
+    size() const
+    { return m_over_top; }
+
+    template<typename _Node, typename _Alloc>
+    void
+    rc<_Node, _Alloc>::
+    clear()
+    {
+      PB_DS_ASSERT_VALID((*this))
+      m_over_top = 0;
+      PB_DS_ASSERT_VALID((*this))
+    }
+
+    template<typename _Node, typename _Alloc>
+    const typename rc<_Node, _Alloc>::const_iterator
+    rc<_Node, _Alloc>::
+    begin() const
+    { return& m_a_entries[0]; }
+
+    template<typename _Node, typename _Alloc>
+    const typename rc<_Node, _Alloc>::const_iterator
+    rc<_Node, _Alloc>::
+    end() const
+    { return& m_a_entries[m_over_top]; }
+
+#ifdef _GLIBCXX_DEBUG
+    template<typename _Node, typename _Alloc>
+    void
+    rc<_Node, _Alloc>::
+    assert_valid(const char* __file, int __line) const
+    { PB_DS_DEBUG_VERIFY(m_over_top < max_entries); }
+#endif
+
+#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_
+    template<typename _Node, typename _Alloc>
+    void
+    rc<_Node, _Alloc>::
+    trace() const
+    {
+      std::cout << "rc" << std::endl;
+      for (size_type i = 0; i < m_over_top; ++i)
+	std::cerr << m_a_entries[i] << std::endl;
+      std::cout << std::endl;
+    }
+#endif
+} // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp
new file mode 100644
index 0000000..189e92e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp
@@ -0,0 +1,171 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/rc_binomial_heap_.hpp
+ * Contains an implementation for redundant-counter binomial heap.
+ */
+
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/rc.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_T_DEC \
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    rc_binomial_heap<Value_Type, Cmp_Fn, _Alloc>
+
+#define PB_DS_RC_C_DEC \
+    rc<typename binomial_heap_base<Value_Type, Cmp_Fn, _Alloc>::node, _Alloc>
+
+    /**
+     *  Redundant-counter binomial heap.
+     *
+     *  @ingroup heap-detail
+     */
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+    class rc_binomial_heap
+    : public binomial_heap_base<Value_Type, Cmp_Fn, _Alloc>
+    {
+    private:
+      typedef binomial_heap_base<Value_Type, Cmp_Fn, _Alloc>
+      							base_type;
+      typedef typename base_type::node_pointer 		node_pointer;
+      typedef typename base_type::node_const_pointer 	node_const_pointer;
+      typedef PB_DS_RC_C_DEC 				rc_t;
+
+    public:
+      typedef Value_Type 				value_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+      typedef typename base_type::pointer 		pointer;
+      typedef typename base_type::const_pointer 	const_pointer;
+      typedef typename base_type::reference 		reference;
+      typedef typename base_type::const_reference 	const_reference;
+      typedef typename base_type::point_const_iterator 	point_const_iterator;
+      typedef typename base_type::point_iterator 	point_iterator;
+      typedef typename base_type::const_iterator 	const_iterator;
+      typedef typename base_type::iterator 		iterator;
+      typedef typename base_type::cmp_fn 		cmp_fn;
+      typedef typename base_type::allocator_type 	allocator_type;
+
+      rc_binomial_heap();
+
+      rc_binomial_heap(const Cmp_Fn&);
+
+      rc_binomial_heap(const PB_DS_CLASS_C_DEC&);
+
+      ~rc_binomial_heap();
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      inline point_iterator
+      push(const_reference);
+
+      void
+      modify(point_iterator, const_reference);
+
+      inline void
+      pop();
+
+      void
+      erase(point_iterator);
+
+      inline void
+      clear();
+
+      template<typename Pred>
+      size_type
+      erase_if(Pred);
+
+      template<typename Pred>
+      void
+      split(Pred, PB_DS_CLASS_C_DEC&);
+
+      void
+      join(PB_DS_CLASS_C_DEC&);
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+#endif
+
+#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    private:
+
+      inline node_pointer
+      link_with_next_sibling(node_pointer);
+
+      void
+      make_0_exposed();
+
+      void
+      make_binomial_heap();
+
+#ifdef _GLIBCXX_DEBUG
+      static node_const_pointer
+      next_2_pointer(node_const_pointer);
+
+      static node_const_pointer
+      next_after_0_pointer(node_const_pointer);
+#endif
+
+      rc_t 			m_rc;
+    };
+
+#include <ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp>
+
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_RC_C_DEC
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..9497226
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp
@@ -0,0 +1,77 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/split_join_fn_imps.hpp
+ * Contains an implementation for rc_binomial_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+void
+PB_DS_CLASS_C_DEC::
+split(Pred pred, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  make_binomial_heap();
+  other.make_binomial_heap();
+  base_type::split(pred, other);
+  base_type::find_max();
+  other.find_max();
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  make_binomial_heap();
+  other.make_binomial_heap();
+  base_type::join(other);
+  base_type::find_max();
+  other.find_max();
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp
new file mode 100644
index 0000000..e4dfd3a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp
@@ -0,0 +1,52 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file rc_binomial_heap_/trace_fn_imps.hpp
+ * Contains an implementation for rc_binomial_heap_.
+ */
+
+#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  base_type::trace();
+  m_rc.trace();
+}
+
+#endif // #ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp
new file mode 100644
index 0000000..3ffe2c5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp
@@ -0,0 +1,211 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cc_hash_max_collision_check_resize_trigger_imp.hpp
+ * Contains a resize trigger implementation.
+ */
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+cc_hash_max_collision_check_resize_trigger(float load) :
+  m_load(load),
+  m_size(0),
+  m_num_col(0),
+  m_max_col(0),
+  m_resize_needed(false)
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_start()
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_collision()
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_end()
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_start()
+{ m_num_col = 0; }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_collision()
+{ ++m_num_col; }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_end()
+{ calc_resize_needed(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_start()
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_collision()
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_end()
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_inserted(size_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erased(size_type)
+{ m_resize_needed = true; }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_cleared()
+{ m_resize_needed = false; }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+is_resize_needed() const
+{ return m_resize_needed; }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+is_grow_needed(size_type /*size*/, size_type /*num_used_e*/) const
+{ return m_num_col >= m_max_col; }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_resized(size_type new_size)
+{
+  m_size = new_size;
+
+#ifdef PB_DS_HT_MAP_RESIZE_TRACE_
+  std::cerr << "chmccrt::notify_resized " 
+	    << static_cast<unsigned long>(new_size) << std::endl;
+#endif 
+
+  calc_max_num_coll();
+  calc_resize_needed();
+  m_num_col = 0;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+calc_max_num_coll()
+{
+  // max_col <-- \sqrt{2 load \ln( 2 m \ln( m ) ) }
+  const double ln_arg = 2 * m_size * std::log(double(m_size));
+  m_max_col = size_type(std::ceil(std::sqrt(2 * m_load * std::log(ln_arg))));
+
+#ifdef PB_DS_HT_MAP_RESIZE_TRACE_
+  std::cerr << "chmccrt::calc_max_num_coll " 
+	    << static_cast<unsigned long>(m_size) <<    "    " 
+	    << static_cast<unsigned long>(m_max_col) << std::endl;
+#endif 
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_externally_resized(size_type new_size)
+{ notify_resized(new_size); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  std::swap(m_load, other.m_load);
+  std::swap(m_size, other.m_size);
+  std::swap(m_num_col, other.m_num_col);
+  std::swap(m_max_col, other.m_max_col);
+  std::swap(m_resize_needed, other.m_resize_needed);
+}
+
+PB_DS_CLASS_T_DEC
+inline float
+PB_DS_CLASS_C_DEC::
+get_load() const
+{
+  PB_DS_STATIC_ASSERT(access, external_load_access);
+  return m_load;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+calc_resize_needed()
+{ m_resize_needed = m_resize_needed || m_num_col >= m_max_col; }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+set_load(float load)
+{
+  PB_DS_STATIC_ASSERT(access, external_load_access);
+  m_load = load;
+  calc_max_num_coll();
+  calc_resize_needed();
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_exponential_size_policy_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_exponential_size_policy_imp.hpp
new file mode 100644
index 0000000..a30a1ab
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_exponential_size_policy_imp.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_exponential_size_policy_imp.hpp
+ * Contains a resize size policy implementation.
+ */
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+hash_exponential_size_policy(size_type start_size, size_type grow_factor) :
+  m_start_size(start_size),
+  m_grow_factor(grow_factor)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  std::swap(m_start_size, other.m_start_size);
+  std::swap(m_grow_factor, other.m_grow_factor);
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+get_nearest_larger_size(size_type size) const
+{
+  size_type ret = m_start_size;
+  while (ret <= size)
+    {
+      const size_type next_ret = ret*  m_grow_factor;
+      if (next_ret < ret)
+	__throw_insert_error();
+      ret = next_ret;
+    }
+  return ret;
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+get_nearest_smaller_size(size_type size) const
+{
+  size_type ret = m_start_size;
+  while (true)
+    {
+      const size_type next_ret = ret*  m_grow_factor;
+      if (next_ret < ret)
+	__throw_resize_error();
+      if (next_ret >= size)
+	return (ret);
+      ret = next_ret;
+    }
+  return ret;
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp
new file mode 100644
index 0000000..a20289a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp
@@ -0,0 +1,293 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_load_check_resize_trigger_imp.hpp
+ * Contains a resize trigger implementation.
+ */
+
+#define PB_DS_ASSERT_VALID(X)						\
+  _GLIBCXX_DEBUG_ONLY(X.assert_valid(__FILE__, __LINE__);)
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+hash_load_check_resize_trigger(float load_min, float load_max)
+: m_load_min(load_min), m_load_max(load_max), m_next_shrink_size(0),
+  m_next_grow_size(0), m_resize_needed(false)
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_start()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_collision()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_end()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_start()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_collision()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_end()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_start()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_collision()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_end()
+{ PB_DS_ASSERT_VALID((*this)) }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_inserted(size_type num_entries)
+{
+  m_resize_needed = (num_entries >= m_next_grow_size);
+  size_base::set_size(num_entries);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erased(size_type num_entries)
+{
+  size_base::set_size(num_entries);
+  m_resize_needed = num_entries <= m_next_shrink_size;
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+is_resize_needed() const
+{
+  PB_DS_ASSERT_VALID((*this))
+  return m_resize_needed;
+}
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+is_grow_needed(size_type /*size*/, size_type num_entries) const
+{
+  _GLIBCXX_DEBUG_ASSERT(m_resize_needed);
+  return num_entries >= m_next_grow_size;
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~hash_load_check_resize_trigger() { }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_resized(size_type new_size)
+{
+  m_resize_needed = false;
+  m_next_grow_size = size_type(m_load_max * new_size - 1);
+  m_next_shrink_size = size_type(m_load_min * new_size);
+
+#ifdef PB_DS_HT_MAP_RESIZE_TRACE_
+  std::cerr << "hlcrt::notify_resized "  << std::endl
+	    << "1 " << new_size << std::endl
+	    << "2 " << m_load_min << std::endl
+	    << "3 " << m_load_max << std::endl
+	    << "4 " << m_next_shrink_size << std::endl
+	    << "5 " << m_next_grow_size << std::endl;
+#endif
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_externally_resized(size_type new_size)
+{
+  m_resize_needed = false;
+  size_type new_grow_size = size_type(m_load_max * new_size - 1);
+  size_type new_shrink_size = size_type(m_load_min * new_size);
+
+#ifdef PB_DS_HT_MAP_RESIZE_TRACE_
+  std::cerr << "hlcrt::notify_externally_resized "  << std::endl
+	    << "1 " << new_size << std::endl
+	    << "2 " << m_load_min << std::endl
+	    << "3 " << m_load_max << std::endl
+	    << "4 " << m_next_shrink_size << std::endl
+	    << "5 " << m_next_grow_size << std::endl
+	    << "6 " << new_shrink_size << std::endl
+	    << "7 " << new_grow_size << std::endl;
+#endif
+
+  if (new_grow_size >= m_next_grow_size)
+    {
+      _GLIBCXX_DEBUG_ASSERT(new_shrink_size >= m_next_shrink_size);
+      m_next_grow_size = new_grow_size;
+    }
+  else
+    {
+      _GLIBCXX_DEBUG_ASSERT(new_shrink_size <= m_next_shrink_size);
+      m_next_shrink_size = new_shrink_size;
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_cleared()
+{
+  PB_DS_ASSERT_VALID((*this))
+  size_base::set_size(0);
+  m_resize_needed = (0 < m_next_shrink_size);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  size_base::swap(other);
+  std::swap(m_load_min, other.m_load_min);
+  std::swap(m_load_max, other.m_load_max);
+  std::swap(m_resize_needed, other.m_resize_needed);
+  std::swap(m_next_grow_size, other.m_next_grow_size);
+  std::swap(m_next_shrink_size, other.m_next_shrink_size);
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+inline std::pair<float, float>
+PB_DS_CLASS_C_DEC::
+get_loads() const
+{
+  PB_DS_STATIC_ASSERT(access, external_load_access);
+  return std::make_pair(m_load_min, m_load_max);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+set_loads(std::pair<float, float> load_pair)
+{
+  PB_DS_STATIC_ASSERT(access, external_load_access);
+  const float old_load_min = m_load_min;
+  const float old_load_max = m_load_max;
+  const size_type old_next_shrink_size = m_next_shrink_size;
+  const size_type old_next_grow_size = m_next_grow_size;
+  const bool old_resize_needed = m_resize_needed;
+
+  __try
+    {
+      m_load_min = load_pair.first;
+      m_load_max = load_pair.second;
+      do_resize(static_cast<size_type>(size_base::get_size() / ((m_load_min + m_load_max) / 2)));
+    }
+  __catch(...)
+    {
+      m_load_min = old_load_min;
+      m_load_max = old_load_max;
+      m_next_shrink_size = old_next_shrink_size;
+      m_next_grow_size = old_next_grow_size;
+      m_resize_needed = old_resize_needed;
+      __throw_exception_again;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+do_resize(size_type)
+{ std::abort(); }
+
+#ifdef _GLIBCXX_DEBUG
+# define PB_DS_DEBUG_VERIFY(_Cond)					\
+  _GLIBCXX_DEBUG_VERIFY_AT(_Cond,					\
+			   _M_message(#_Cond" assertion from %1;:%2;")	\
+			   ._M_string(__FILE__)._M_integer(__LINE__)	\
+			   ,__file,__line)
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  PB_DS_DEBUG_VERIFY(m_load_max > m_load_min);
+  PB_DS_DEBUG_VERIFY(m_next_grow_size >= m_next_shrink_size);
+}
+# undef PB_DS_DEBUG_VERIFY
+#endif
+#undef PB_DS_ASSERT_VALID
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp
new file mode 100644
index 0000000..9670472
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp
@@ -0,0 +1,94 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_load_check_resize_trigger_size_base.hpp
+ * Contains an base holding size for some resize policies.
+ */
+
+#ifndef PB_DS_HASH_LOAD_CHECK_RESIZE_TRIGGER_SIZE_BASE_HPP
+#define PB_DS_HASH_LOAD_CHECK_RESIZE_TRIGGER_SIZE_BASE_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Primary template.
+    template<typename Size_Type, bool Hold_Size>
+    class hash_load_check_resize_trigger_size_base;
+
+    /// Specializations.
+    template<typename Size_Type>
+    class hash_load_check_resize_trigger_size_base<Size_Type, true>
+    {
+    protected:
+      typedef Size_Type size_type;
+
+      hash_load_check_resize_trigger_size_base(): m_size(0)
+      { }
+
+      inline void
+      swap(hash_load_check_resize_trigger_size_base& other)
+      { std::swap(m_size, other.m_size); }
+
+      inline void
+      set_size(size_type size)
+      { m_size = size; }
+
+      inline size_type
+      get_size() const
+      { return m_size; }
+
+    private:
+      size_type m_size;
+    };
+
+    template<typename Size_Type>
+    class hash_load_check_resize_trigger_size_base<Size_Type, false>
+    {
+    protected:
+      typedef Size_Type size_type;
+
+    protected:
+      inline void
+      swap(hash_load_check_resize_trigger_size_base& other) { }
+
+      inline void
+      set_size(size_type size) { }
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp
new file mode 100644
index 0000000..ad27f58
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp
@@ -0,0 +1,161 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_prime_size_policy_imp.hpp
+ * Contains a resize size policy implementation.
+ */
+
+#pragma GCC system_header
+
+namespace detail
+{
+  enum
+    {
+      num_distinct_sizes_32_bit = 30,
+      num_distinct_sizes_64_bit = 62,
+      num_distinct_sizes = sizeof(std::size_t) != 8 ? 
+            num_distinct_sizes_32_bit : num_distinct_sizes_64_bit,	
+    };
+
+  // Originally taken from the SGI implementation; acknowledged in the docs.
+  // Further modified (for 64 bits) from tr1's hashtable.
+  static const std::size_t g_a_sizes[num_distinct_sizes_64_bit] =
+    {
+      /* 0     */              5ul,
+      /* 1     */              11ul, 
+      /* 2     */              23ul, 
+      /* 3     */              47ul, 
+      /* 4     */              97ul, 
+      /* 5     */              199ul, 
+      /* 6     */              409ul, 
+      /* 7     */              823ul, 
+      /* 8     */              1741ul, 
+      /* 9     */              3469ul, 
+      /* 10    */              6949ul, 
+      /* 11    */              14033ul, 
+      /* 12    */              28411ul, 
+      /* 13    */              57557ul, 
+      /* 14    */              116731ul, 
+      /* 15    */              236897ul,
+      /* 16    */              480881ul, 
+      /* 17    */              976369ul,
+      /* 18    */              1982627ul, 
+      /* 19    */              4026031ul,
+      /* 20    */              8175383ul, 
+      /* 21    */              16601593ul, 
+      /* 22    */              33712729ul,
+      /* 23    */              68460391ul, 
+      /* 24    */              139022417ul, 
+      /* 25    */              282312799ul, 
+      /* 26    */              573292817ul, 
+      /* 27    */              1164186217ul,
+      /* 28    */              2364114217ul, 
+      /* 29    */              4294967291ul,
+      /* 30    */ (std::size_t)8589934583ull,
+      /* 31    */ (std::size_t)17179869143ull,
+      /* 32    */ (std::size_t)34359738337ull,
+      /* 33    */ (std::size_t)68719476731ull,
+      /* 34    */ (std::size_t)137438953447ull,
+      /* 35    */ (std::size_t)274877906899ull,
+      /* 36    */ (std::size_t)549755813881ull,
+      /* 37    */ (std::size_t)1099511627689ull,
+      /* 38    */ (std::size_t)2199023255531ull,
+      /* 39    */ (std::size_t)4398046511093ull,
+      /* 40    */ (std::size_t)8796093022151ull,
+      /* 41    */ (std::size_t)17592186044399ull,
+      /* 42    */ (std::size_t)35184372088777ull,
+      /* 43    */ (std::size_t)70368744177643ull,
+      /* 44    */ (std::size_t)140737488355213ull,
+      /* 45    */ (std::size_t)281474976710597ull,
+      /* 46    */ (std::size_t)562949953421231ull, 
+      /* 47    */ (std::size_t)1125899906842597ull,
+      /* 48    */ (std::size_t)2251799813685119ull, 
+      /* 49    */ (std::size_t)4503599627370449ull,
+      /* 50    */ (std::size_t)9007199254740881ull, 
+      /* 51    */ (std::size_t)18014398509481951ull,
+      /* 52    */ (std::size_t)36028797018963913ull, 
+      /* 53    */ (std::size_t)72057594037927931ull,
+      /* 54    */ (std::size_t)144115188075855859ull,
+      /* 55    */ (std::size_t)288230376151711717ull,
+      /* 56    */ (std::size_t)576460752303423433ull,
+      /* 57    */ (std::size_t)1152921504606846883ull,
+      /* 58    */ (std::size_t)2305843009213693951ull,
+      /* 59    */ (std::size_t)4611686018427387847ull,
+      /* 60    */ (std::size_t)9223372036854775783ull,
+      /* 61    */ (std::size_t)18446744073709551557ull,
+    };
+
+} // namespace detail
+
+PB_DS_CLASS_T_DEC
+inline
+PB_DS_CLASS_C_DEC::
+hash_prime_size_policy(size_type n) : m_start_size(n)
+{ m_start_size = get_nearest_larger_size(n); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{ std::swap(m_start_size, other.m_start_size); }
+
+PB_DS_CLASS_T_DEC
+inline PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+get_nearest_larger_size(size_type n) const
+{
+  const std::size_t* const p_upper = std::upper_bound(detail::g_a_sizes, 
+		     detail::g_a_sizes + detail::num_distinct_sizes, n);
+
+  if (p_upper == detail::g_a_sizes + detail::num_distinct_sizes)
+    __throw_resize_error();
+  return *p_upper;
+}
+
+PB_DS_CLASS_T_DEC
+inline PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+get_nearest_smaller_size(size_type n) const
+{
+  const std::size_t* p_lower = std::lower_bound(detail::g_a_sizes, 
+		       detail::g_a_sizes + detail::num_distinct_sizes, n);
+
+  if (*p_lower >= n &&  p_lower != detail::g_a_sizes)
+    --p_lower;
+  if (*p_lower < m_start_size)
+    return m_start_size;
+  return *p_lower;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp
new file mode 100644
index 0000000..16a76f6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp
@@ -0,0 +1,249 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_standard_resize_policy_imp.hpp
+ * Contains a resize policy implementation.
+ */
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+hash_standard_resize_policy() 
+: m_size(Size_Policy::get_nearest_larger_size(1))
+{ trigger_policy_base::notify_externally_resized(m_size); }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+hash_standard_resize_policy(const Size_Policy& r_size_policy) 
+: Size_Policy(r_size_policy), m_size(Size_Policy::get_nearest_larger_size(1))
+{ trigger_policy_base::notify_externally_resized(m_size); }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+hash_standard_resize_policy(const Size_Policy& r_size_policy, 
+			    const Trigger_Policy& r_trigger_policy) 
+: Size_Policy(r_size_policy), Trigger_Policy(r_trigger_policy),
+  m_size(Size_Policy::get_nearest_larger_size(1))
+{ trigger_policy_base::notify_externally_resized(m_size); }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~hash_standard_resize_policy()
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  trigger_policy_base::swap(other);
+  size_policy_base::swap(other);
+  std::swap(m_size, other.m_size);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_start()
+{ trigger_policy_base::notify_find_search_start(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_collision()
+{ trigger_policy_base::notify_find_search_collision(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_find_search_end()
+{ trigger_policy_base::notify_find_search_end(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_start()
+{ trigger_policy_base::notify_insert_search_start(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_collision()
+{ trigger_policy_base::notify_insert_search_collision(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_insert_search_end()
+{ trigger_policy_base::notify_insert_search_end(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_start()
+{ trigger_policy_base::notify_erase_search_start(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_collision()
+{ trigger_policy_base::notify_erase_search_collision(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erase_search_end()
+{ trigger_policy_base::notify_erase_search_end(); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_inserted(size_type num_e)
+{ trigger_policy_base::notify_inserted(num_e); }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+notify_erased(size_type num_e)
+{ trigger_policy_base::notify_erased(num_e); }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_cleared()
+{ trigger_policy_base::notify_cleared(); }
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+is_resize_needed() const
+{ return trigger_policy_base::is_resize_needed(); }
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+get_new_size(size_type size, size_type num_used_e) const
+{
+  if (trigger_policy_base::is_grow_needed(size, num_used_e))
+    return size_policy_base::get_nearest_larger_size(size);
+  return size_policy_base::get_nearest_smaller_size(size);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+notify_resized(size_type new_size)
+{
+  trigger_policy_base::notify_resized(new_size);
+  m_size = new_size;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+get_actual_size() const
+{
+  PB_DS_STATIC_ASSERT(access, external_size_access);
+  return m_size;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+resize(size_type new_size)
+{
+  PB_DS_STATIC_ASSERT(access, external_size_access);
+  size_type actual_size = size_policy_base::get_nearest_larger_size(1);
+  while (actual_size < new_size)
+    {
+      const size_type pot = size_policy_base::get_nearest_larger_size(actual_size);
+
+      if (pot == actual_size && pot < new_size)
+	__throw_resize_error();
+      actual_size = pot;
+    }
+
+  if (actual_size > 0)
+    --actual_size;
+
+  const size_type old_size = m_size;
+  __try
+    {
+      do_resize(actual_size - 1);
+    }
+  __catch(insert_error& )
+    {
+      m_size = old_size;
+      __throw_resize_error();
+    }
+  __catch(...)
+    {
+      m_size = old_size;
+      __throw_exception_again;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+do_resize(size_type)
+{
+  // Do nothing
+}
+
+PB_DS_CLASS_T_DEC
+Trigger_Policy& 
+PB_DS_CLASS_C_DEC::
+get_trigger_policy()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Trigger_Policy& 
+PB_DS_CLASS_C_DEC::
+get_trigger_policy() const
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+Size_Policy& 
+PB_DS_CLASS_C_DEC::
+get_size_policy()
+{ return *this; }
+
+PB_DS_CLASS_T_DEC
+const Size_Policy& 
+PB_DS_CLASS_C_DEC::
+get_size_policy() const
+{ return *this; }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp
new file mode 100644
index 0000000..b42fee9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp
@@ -0,0 +1,125 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_resize_policy.hpp
+ * Contains a sample resize policy for hash tables.
+ */
+
+#ifndef PB_DS_SAMPLE_RESIZE_POLICY_HPP
+#define PB_DS_SAMPLE_RESIZE_POLICY_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample resize policy.
+  class sample_resize_policy
+  {
+  public:
+    /// Size type.
+    typedef std::size_t size_type;
+
+    /// Default constructor.
+    sample_resize_policy();
+
+    /// Copy constructor.
+    sample_range_hashing(const sample_resize_policy& other);
+
+    /// Swaps content.
+    inline void
+    swap(sample_resize_policy& other);
+
+  protected:
+    /// Notifies a search started.
+    inline void
+    notify_insert_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_insert_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_insert_search_end();
+
+    /// Notifies a search started.
+    inline void
+    notify_find_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_find_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_find_search_end();
+
+    /// Notifies a search started.
+    inline void
+    notify_erase_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_erase_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_erase_search_end();
+
+    /// Notifies an element was inserted.
+    inline void
+    notify_inserted(size_type num_e);
+
+    /// Notifies an element was erased.
+    inline void
+    notify_erased(size_type num_e);
+
+    /// Notifies the table was cleared.
+    void
+    notify_cleared();
+
+    /// Notifies the table was resized to new_size.
+    void
+    notify_resized(size_type new_size);
+
+    /// Queries whether a resize is needed.
+    inline bool
+    is_resize_needed() const;
+
+    /// Queries what the new size should be.
+    size_type
+    get_new_size(size_type size, size_type num_used_e) const;
+  };
+}
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp
new file mode 100644
index 0000000..2dc587f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp
@@ -0,0 +1,136 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_resize_trigger.hpp
+ * Contains a sample resize trigger policy class.
+ */
+
+#ifndef PB_DS_SAMPLE_RESIZE_TRIGGER_HPP
+#define PB_DS_SAMPLE_RESIZE_TRIGGER_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample resize trigger policy.
+  class sample_resize_trigger
+  {
+  public:
+    /// Size type.
+    typedef std::size_t size_type;
+
+    /// Default constructor.
+    sample_resize_trigger();
+
+    /// Copy constructor.
+    sample_range_hashing(const sample_resize_trigger&);
+
+    /// Swaps content.
+    inline void
+    swap(sample_resize_trigger&);
+
+  protected:
+    /// Notifies a search started.
+    inline void
+    notify_insert_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_insert_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_insert_search_end();
+
+    /// Notifies a search started.
+    inline void
+    notify_find_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_find_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_find_search_end();
+
+    /// Notifies a search started.
+    inline void
+    notify_erase_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_erase_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_erase_search_end();
+
+    /// Notifies an element was inserted. the total number of entries in
+    /// the table is num_entries.
+    inline void
+    notify_inserted(size_type num_entries);
+
+    /// Notifies an element was erased.
+    inline void
+    notify_erased(size_type num_entries);
+
+    /// Notifies the table was cleared.
+    void
+    notify_cleared();
+
+    /// Notifies the table was resized as a result of this object's
+    /// signifying that a resize is needed.
+    void
+    notify_resized(size_type new_size);
+
+    /// Notifies the table was resized externally.
+    void
+    notify_externally_resized(size_type new_size);
+
+    /// Queries whether a resize is needed.
+    inline bool
+    is_resize_needed() const;
+
+    /// Queries whether a grow is needed.
+    inline bool
+    is_grow_needed(size_type size, size_type num_entries) const;
+
+  private:
+    /// Resizes to new_size.
+    virtual void
+    do_resize(size_type);
+  };
+}
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp
new file mode 100644
index 0000000..3558a0d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file sample_size_policy.hpp
+ * Contains a sample size resize-policy.
+ */
+
+#ifndef PB_DS_SAMPLE_SIZE_POLICY_HPP
+#define PB_DS_SAMPLE_SIZE_POLICY_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample size policy.
+  class sample_size_policy
+  {
+  public:
+    /// Size type.
+    typedef std::size_t size_type;
+
+    /// Default constructor.
+    sample_size_policy();
+
+    /// Copy constructor.
+    sample_range_hashing(const sample_size_policy&);
+
+    /// Swaps content.
+    inline void
+    swap(sample_size_policy& other);
+
+  protected:
+    /// Given a __size size, returns a __size that is larger.
+    inline size_type
+    get_nearest_larger_size(size_type size) const;
+
+    /// Given a __size size, returns a __size that is smaller.
+    inline size_type
+    get_nearest_smaller_size(size_type size) const;
+  };
+}
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..2d14055
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,102 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation class for splay_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    insert(*(first_it++));
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_S_TREE_NAME()
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_S_TREE_NAME(const Cmp_Fn& r_cmp_fn) :
+  base_type(r_cmp_fn)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_S_TREE_NAME(const Cmp_Fn& r_cmp_fn, const node_update& r_node_update) :
+  base_type(r_cmp_fn, r_node_update)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+PB_DS_S_TREE_NAME(const PB_DS_CLASS_C_DEC& other) :
+  base_type(other)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  base_type::swap(other);
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize()
+{ base_type::m_p_head->m_special = true; }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp
new file mode 100644
index 0000000..0eaaa73
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp
@@ -0,0 +1,75 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/debug_fn_imps.hpp
+ * Contains an implementation class for splay_tree_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  base_type::assert_valid(__file, __line);
+  const node_pointer p_head = base_type::m_p_head;
+  assert_special_imp(p_head, __file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_special_imp(const node_pointer p_nd,
+		   const char* __file, int __line) const
+{
+  if (p_nd == 0)
+    return;
+
+  if (p_nd == base_type::m_p_head)
+    {
+      PB_DS_DEBUG_VERIFY(p_nd->m_special);
+      assert_special_imp(p_nd->m_p_parent, __file, __line);
+      return;
+    }
+
+  PB_DS_DEBUG_VERIFY(!p_nd->m_special);
+  assert_special_imp(p_nd->m_p_left, __file, __line);
+  assert_special_imp(p_nd->m_p_right, __file, __line);
+}
+
+#endif 
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp
new file mode 100644
index 0000000..ef7151c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp
@@ -0,0 +1,157 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/erase_fn_imps.hpp
+ * Contains an implementation class for splay_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline bool
+PB_DS_CLASS_C_DEC::
+erase(key_const_reference r_key)
+{
+  point_iterator it = find(r_key);
+  if (it == base_type::end())
+    return false;
+  erase(it);
+  return true;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+erase(iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (it == base_type::end())
+    return it;
+  iterator ret_it = it;
+  ++ret_it;
+  erase_node(it.m_p_nd);
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::reverse_iterator
+PB_DS_CLASS_C_DEC::
+erase(reverse_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (it.m_p_nd == base_type::m_p_head)
+    return (it);
+  reverse_iterator ret_it = it;
+  ++ret_it;
+  erase_node(it.m_p_nd);
+  PB_DS_ASSERT_VALID((*this))
+  return ret_it;
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+  size_type num_ersd = 0;
+  iterator it = base_type::begin();
+  while (it != base_type::end())
+    {
+      if (pred(*it))
+        {
+	  ++num_ersd;
+	  it = erase(it);
+        }
+      else
+	++it;
+    }
+  PB_DS_ASSERT_VALID((*this))
+  return num_ersd;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase_node(node_pointer p_nd)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  splay(p_nd);
+
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(p_nd == this->m_p_head->m_p_parent);
+
+  node_pointer p_l = p_nd->m_p_left;
+  node_pointer p_r = p_nd->m_p_right;
+
+  base_type::update_min_max_for_erased_node(p_nd);
+  base_type::actual_erase_node(p_nd);
+  if (p_r == 0)
+    {
+      base_type::m_p_head->m_p_parent = p_l;
+      if (p_l != 0)
+	p_l->m_p_parent = base_type::m_p_head;
+      PB_DS_ASSERT_VALID((*this))
+      return;
+    }
+
+  node_pointer p_target_r = leftmost(p_r);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r != 0);
+  p_r->m_p_parent = base_type::m_p_head;
+  base_type::m_p_head->m_p_parent = p_r;
+  splay(p_target_r);
+
+  _GLIBCXX_DEBUG_ONLY(p_target_r->m_p_left = 0);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_parent == this->m_p_head);
+  _GLIBCXX_DEBUG_ASSERT(this->m_p_head->m_p_parent == p_target_r);
+
+  p_target_r->m_p_left = p_l;
+  if (p_l != 0)
+    p_l->m_p_parent = p_target_r;
+  PB_DS_ASSERT_VALID((*this))
+  this->apply_update(p_target_r, (node_update*)this);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+leftmost(node_pointer p_nd)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  while (p_nd->m_p_left != 0)
+    p_nd = p_nd->m_p_left;
+  return p_nd;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp
new file mode 100644
index 0000000..8cc0bb1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/find_fn_imps.hpp
+ * Contains an implementation class for splay_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key)
+{
+  node_pointer p_found = find_imp(r_key);
+  if (p_found != base_type::m_p_head)
+    splay(p_found);
+  return point_iterator(p_found);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_const_iterator
+PB_DS_CLASS_C_DEC::
+find(key_const_reference r_key) const
+{
+  const node_pointer p_found = find_imp(r_key);
+  if (p_found != base_type::m_p_head)
+    const_cast<PB_DS_CLASS_C_DEC* >(this)->splay(p_found);
+  return point_iterator(p_found);
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+find_imp(key_const_reference r_key)
+{
+  _GLIBCXX_DEBUG_ONLY(base_type::structure_only_assert_valid(__FILE__,
+							     __LINE__);)
+  node_pointer p_nd = base_type::m_p_head->m_p_parent;
+  while (p_nd != 0)
+    if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
+      {
+	if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value)))
+	  return p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+  return base_type::m_p_head;
+}
+
+PB_DS_CLASS_T_DEC
+inline const typename PB_DS_CLASS_C_DEC::node_pointer
+PB_DS_CLASS_C_DEC::
+find_imp(key_const_reference r_key) const
+{
+  PB_DS_ASSERT_VALID((*this))
+  node_pointer p_nd = base_type::m_p_head->m_p_parent;
+  while (p_nd != 0)
+    if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key))
+      {
+	if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value)))
+	  return p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+  return base_type::m_p_head;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/info_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/info_fn_imps.hpp
new file mode 100644
index 0000000..aacff32
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/info_fn_imps.hpp
@@ -0,0 +1,39 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/info_fn_imps.hpp
+ * Contains an implementation.
+ */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp
new file mode 100644
index 0000000..62f7d0a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp
@@ -0,0 +1,94 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/insert_fn_imps.hpp
+ * Contains an implementation class for splay_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert(const_reference r_value)
+{
+  PB_DS_ASSERT_VALID((*this))
+  std::pair<point_iterator, bool> ins_pair = insert_leaf_imp(r_value);
+  ins_pair.first.m_p_nd->m_special = false;
+  PB_DS_ASSERT_VALID((*this))
+  splay(ins_pair.first.m_p_nd);
+  PB_DS_ASSERT_VALID((*this))
+  return ins_pair;
+}
+
+PB_DS_CLASS_T_DEC
+inline std::pair<typename PB_DS_CLASS_C_DEC::point_iterator, bool>
+PB_DS_CLASS_C_DEC::
+insert_leaf_imp(const_reference r_value)
+{
+  _GLIBCXX_DEBUG_ONLY(base_type::structure_only_assert_valid(__FILE__,
+							     __LINE__);)
+  if (base_type::m_size == 0)
+    return std::make_pair(base_type::insert_imp_empty(r_value), true);
+
+  node_pointer p_nd = base_type::m_p_head->m_p_parent;
+  node_pointer p_pot = base_type::m_p_head;
+
+  while (p_nd != 0)
+    if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), PB_DS_V2F(r_value)))
+      {
+	if (!Cmp_Fn::operator()(PB_DS_V2F(r_value), PB_DS_V2F(p_nd->m_value)))
+	  {
+	    return std::make_pair(point_iterator(p_nd), false);
+	  }
+	p_pot = p_nd;
+	p_nd = p_nd->m_p_left;
+      }
+    else
+      p_nd = p_nd->m_p_right;
+
+  if (p_pot == base_type::m_p_head)
+    return std::make_pair(base_type::insert_leaf_new(r_value, base_type::m_p_head->m_p_right, false), true);
+
+  PB_DS_CHECK_KEY_DOES_NOT_EXIST(PB_DS_V2F(r_value))
+
+  p_nd = p_pot->m_p_left;
+  if (p_nd == 0)
+    return (std::make_pair(base_type::insert_leaf_new(r_value, p_pot, true), true));
+
+  while (p_nd->m_p_right != 0)
+    p_nd = p_nd->m_p_right;
+
+  return std::make_pair(this->insert_leaf_new(r_value, p_nd, false), true);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/node.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/node.hpp
new file mode 100644
index 0000000..9cb4cb5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/node.hpp
@@ -0,0 +1,126 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/node.hpp
+ * Contains an implementation struct for splay_tree_'s node.
+ */
+
+#ifndef PB_DS_SPLAY_TREE_NODE_HPP
+#define PB_DS_SPLAY_TREE_NODE_HPP
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Node for splay tree.
+    template<typename Value_Type, class Metadata, typename _Alloc>
+    struct splay_tree_node_
+    {
+    public:
+      typedef Value_Type value_type;
+      typedef Metadata metadata_type;
+
+      typedef
+      typename _Alloc::template rebind<
+      splay_tree_node_<Value_Type, Metadata, _Alloc> >::other::pointer
+      node_pointer;
+
+      typedef
+      typename _Alloc::template rebind<metadata_type>::other::reference
+      metadata_reference;
+
+      typedef
+      typename _Alloc::template rebind<metadata_type>::other::const_reference
+      metadata_const_reference;
+
+#ifdef PB_DS_BIN_SEARCH_TREE_TRACE_
+      void
+      trace() const
+      { std::cout << PB_DS_V2F(m_value) << "(" << m_metadata << ")"; }
+#endif
+
+      inline bool
+      special() const
+      { return m_special; }
+
+      inline metadata_const_reference
+      get_metadata() const
+      { return m_metadata; }
+
+      inline metadata_reference
+      get_metadata()
+      { return m_metadata; }
+
+      value_type m_value;
+      bool m_special;
+      node_pointer m_p_left;
+      node_pointer m_p_right;
+      node_pointer m_p_parent;
+      metadata_type m_metadata;
+    };
+
+    template<typename Value_Type, typename _Alloc>
+    struct splay_tree_node_<Value_Type, null_type, _Alloc>
+    {
+    public:
+      typedef Value_Type value_type;
+      typedef null_type metadata_type;
+
+      typedef
+      typename _Alloc::template rebind<
+      splay_tree_node_<Value_Type, null_type, _Alloc> >::other::pointer
+      node_pointer;
+
+      inline bool
+      special() const
+      { return m_special; }
+
+#ifdef PB_DS_BIN_SEARCH_TREE_TRACE_
+      void
+      trace() const
+      { std::cout << PB_DS_V2F(m_value); }
+#endif 
+
+      node_pointer m_p_left;
+      node_pointer m_p_right;
+      node_pointer m_p_parent;
+      value_type m_value;
+      bool m_special;
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp
new file mode 100644
index 0000000..10988a2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp
@@ -0,0 +1,281 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/splay_fn_imps.hpp
+ * Contains an implementation class for splay_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+splay(node_pointer p_nd)
+{
+  while (p_nd->m_p_parent != base_type::m_p_head)
+    {
+#ifdef _GLIBCXX_DEBUG
+      {
+	node_pointer p_head = base_type::m_p_head;
+	assert_special_imp(p_head, __FILE__, __LINE__);
+      }
+#endif
+
+      PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_nd)
+
+      if (p_nd->m_p_parent->m_p_parent == base_type::m_p_head)
+	{
+	  base_type::rotate_parent(p_nd);
+	  _GLIBCXX_DEBUG_ASSERT(p_nd == this->m_p_head->m_p_parent);
+	}
+      else
+	{
+	  const node_pointer p_parent = p_nd->m_p_parent;
+	  const node_pointer p_grandparent = p_parent->m_p_parent;
+
+#ifdef _GLIBCXX_DEBUG
+	  const size_type total =
+	    base_type::recursive_count(p_grandparent);
+	  _GLIBCXX_DEBUG_ASSERT(total >= 3);
+#endif
+
+	  if (p_parent->m_p_left == p_nd &&
+	      p_grandparent->m_p_right == p_parent)
+	    splay_zig_zag_left(p_nd, p_parent, p_grandparent);
+	  else if (p_parent->m_p_right == p_nd &&
+		   p_grandparent->m_p_left == p_parent)
+	    splay_zig_zag_right(p_nd, p_parent, p_grandparent);
+	  else if (p_parent->m_p_left == p_nd &&
+		   p_grandparent->m_p_left == p_parent)
+	    splay_zig_zig_left(p_nd, p_parent, p_grandparent);
+	  else
+	    splay_zig_zig_right(p_nd, p_parent, p_grandparent);
+	  _GLIBCXX_DEBUG_ASSERT(total ==this->recursive_count(p_nd));
+	}
+
+      PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_nd)
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+splay_zig_zag_left(node_pointer p_nd, node_pointer p_parent,
+		   node_pointer p_grandparent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_parent == p_nd->m_p_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_grandparent == p_parent->m_p_parent);
+
+  PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_grandparent)
+
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_left == p_nd &&
+			p_grandparent->m_p_right == p_parent);
+
+  splay_zz_start(p_nd, p_parent, p_grandparent);
+
+  node_pointer p_b = p_nd->m_p_right;
+  node_pointer p_c = p_nd->m_p_left;
+
+  p_nd->m_p_right = p_parent;
+  p_parent->m_p_parent = p_nd;
+
+  p_nd->m_p_left = p_grandparent;
+  p_grandparent->m_p_parent = p_nd;
+
+  p_parent->m_p_left = p_b;
+  if (p_b != 0)
+    p_b->m_p_parent = p_parent;
+
+  p_grandparent->m_p_right = p_c;
+  if (p_c != 0)
+    p_c->m_p_parent = p_grandparent;
+
+  splay_zz_end(p_nd, p_parent, p_grandparent);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+splay_zig_zag_right(node_pointer p_nd, node_pointer p_parent,
+		    node_pointer p_grandparent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_parent == p_nd->m_p_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_grandparent == p_parent->m_p_parent);
+
+  PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_grandparent)
+
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_right == p_nd &&
+	  		p_grandparent->m_p_left == p_parent);
+
+  splay_zz_start(p_nd, p_parent, p_grandparent);
+
+  node_pointer p_b = p_nd->m_p_left;
+  node_pointer p_c = p_nd->m_p_right;
+
+  p_nd->m_p_left = p_parent;
+  p_parent->m_p_parent = p_nd;
+
+  p_nd->m_p_right = p_grandparent;
+  p_grandparent->m_p_parent = p_nd;
+
+  p_parent->m_p_right = p_b;
+  if (p_b != 0)
+    p_b->m_p_parent = p_parent;
+
+  p_grandparent->m_p_left = p_c;
+  if (p_c != 0)
+    p_c->m_p_parent = p_grandparent;
+
+  splay_zz_end(p_nd, p_parent, p_grandparent);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+splay_zig_zig_left(node_pointer p_nd, node_pointer p_parent,
+		   node_pointer p_grandparent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_parent == p_nd->m_p_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_grandparent == p_parent->m_p_parent);
+
+  PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_grandparent)
+
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_left == p_nd &&
+		     p_nd->m_p_parent->m_p_parent->m_p_left == p_nd->m_p_parent);
+
+  splay_zz_start(p_nd, p_parent, p_grandparent);
+
+  node_pointer p_b = p_nd->m_p_right;
+  node_pointer p_c = p_parent->m_p_right;
+
+  p_nd->m_p_right = p_parent;
+  p_parent->m_p_parent = p_nd;
+
+  p_parent->m_p_right = p_grandparent;
+  p_grandparent->m_p_parent = p_parent;
+
+  p_parent->m_p_left = p_b;
+  if (p_b != 0)
+    p_b->m_p_parent = p_parent;
+
+  p_grandparent->m_p_left = p_c;
+  if (p_c != 0)
+    p_c->m_p_parent = p_grandparent;
+
+  splay_zz_end(p_nd, p_parent, p_grandparent);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+splay_zig_zig_right(node_pointer p_nd, node_pointer p_parent,
+		    node_pointer p_grandparent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_parent == p_nd->m_p_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_grandparent == p_parent->m_p_parent);
+  PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_grandparent)
+  _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_right == p_nd &&
+		  p_nd->m_p_parent->m_p_parent->m_p_right == p_nd->m_p_parent);
+
+  splay_zz_start(p_nd, p_parent, p_grandparent);
+
+  node_pointer p_b = p_nd->m_p_left;
+  node_pointer p_c = p_parent->m_p_left;
+
+  p_nd->m_p_left = p_parent;
+  p_parent->m_p_parent = p_nd;
+
+  p_parent->m_p_left = p_grandparent;
+  p_grandparent->m_p_parent = p_parent;
+
+  p_parent->m_p_right = p_b;
+  if (p_b != 0)
+    p_b->m_p_parent = p_parent;
+
+  p_grandparent->m_p_right = p_c;
+  if (p_c != 0)
+    p_c->m_p_parent = p_grandparent;
+
+  base_type::update_to_top(p_grandparent, (node_update*)this);
+  splay_zz_end(p_nd, p_parent, p_grandparent);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+splay_zz_start(node_pointer p_nd,
+#ifdef _GLIBCXX_DEBUG
+	       node_pointer p_parent,
+#else
+	       node_pointer /*p_parent*/,
+#endif
+	       node_pointer p_grandparent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_parent != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_grandparent != 0);
+
+  const bool grandparent_head = p_grandparent->m_p_parent == base_type::m_p_head;
+
+  if (grandparent_head)
+    {
+      base_type::m_p_head->m_p_parent = base_type::m_p_head->m_p_parent;
+      p_nd->m_p_parent = base_type::m_p_head;
+      return;
+    }
+
+  node_pointer p_greatgrandparent = p_grandparent->m_p_parent;
+
+  p_nd->m_p_parent = p_greatgrandparent;
+
+  if (p_grandparent == p_greatgrandparent->m_p_left)
+    p_greatgrandparent->m_p_left = p_nd;
+  else
+    p_greatgrandparent->m_p_right = p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+splay_zz_end(node_pointer p_nd, node_pointer p_parent,
+	     node_pointer p_grandparent)
+{
+  if (p_nd->m_p_parent == base_type::m_p_head)
+    base_type::m_p_head->m_p_parent = p_nd;
+
+  this->apply_update(p_grandparent, (node_update*)this);
+  this->apply_update(p_parent, (node_update*)this);
+  this->apply_update(p_nd, (node_update*)this);
+  PB_DS_ASSERT_BASE_NODE_CONSISTENT(p_nd)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_tree_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_tree_.hpp
new file mode 100644
index 0000000..e672793
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_tree_.hpp
@@ -0,0 +1,275 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/splay_tree_.hpp
+ * Contains an implementation class for splay trees.
+ */
+/*
+ * This implementation uses an idea from the SGI STL (using a @a header node
+ *    which is needed for efficient iteration). Following is the SGI STL
+ *    copyright.
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.    Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.    It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.    Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.    It is provided "as is" without express or implied warranty.
+ *
+ *
+ */
+
+#include <utility>
+#include <vector>
+#include <assert.h>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+# define PB_DS_S_TREE_NAME splay_tree_map
+# define PB_DS_S_TREE_BASE_NAME bin_search_tree_map
+#endif
+
+#ifdef PB_DS_DATA_FALSE_INDICATOR
+# define PB_DS_S_TREE_NAME splay_tree_set
+# define PB_DS_S_TREE_BASE_NAME bin_search_tree_set
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Cmp_Fn, \
+	     typename Node_And_It_Traits, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    PB_DS_S_TREE_NAME<Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc>
+
+#define PB_DS_S_TREE_BASE \
+    PB_DS_S_TREE_BASE_NAME<Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc>
+
+
+    /**
+     *  @brief Splay tree.
+     *  @ingroup branch-detail
+     */
+    template<typename Key, typename Mapped, typename Cmp_Fn,
+	     typename Node_And_It_Traits, typename _Alloc>
+    class PB_DS_S_TREE_NAME : public PB_DS_S_TREE_BASE
+    {
+    private:
+      typedef PB_DS_S_TREE_BASE 		       	 base_type;
+#ifdef _GLIBCXX_DEBUG
+      typedef base_type debug_base;
+#endif
+      typedef typename base_type::node_pointer 		 node_pointer;
+
+    public:
+      typedef splay_tree_tag 				 container_category;
+      typedef _Alloc 					 allocator_type;
+      typedef typename _Alloc::size_type 		 size_type;
+      typedef typename _Alloc::difference_type 		 difference_type;
+      typedef Cmp_Fn 					 cmp_fn;
+      typedef typename base_type::key_type 		 key_type;
+      typedef typename base_type::key_pointer 		 key_pointer;
+      typedef typename base_type::key_const_pointer 	 key_const_pointer;
+      typedef typename base_type::key_reference 	 key_reference;
+      typedef typename base_type::key_const_reference 	 key_const_reference;
+      typedef typename base_type::mapped_type 	 	 mapped_type;
+      typedef typename base_type::mapped_pointer 	 mapped_pointer;
+      typedef typename base_type::mapped_const_pointer 	 mapped_const_pointer;
+      typedef typename base_type::mapped_reference 	 mapped_reference;
+      typedef typename base_type::mapped_const_reference mapped_const_reference;
+      typedef typename base_type::value_type 		 value_type;
+      typedef typename base_type::pointer 		 pointer;
+      typedef typename base_type::const_pointer 	 const_pointer;
+      typedef typename base_type::reference 	 	 reference;
+      typedef typename base_type::const_reference 	 const_reference;
+      typedef typename base_type::point_iterator 	 point_iterator;
+      typedef typename base_type::const_iterator 	 point_const_iterator;
+      typedef typename base_type::iterator 		 iterator;
+      typedef typename base_type::const_iterator 	 const_iterator;
+      typedef typename base_type::reverse_iterator 	 reverse_iterator;
+      typedef typename base_type::const_reverse_iterator const_reverse_iterator;
+      typedef typename base_type::node_update 		 node_update;
+
+      PB_DS_S_TREE_NAME();
+
+      PB_DS_S_TREE_NAME(const Cmp_Fn&);
+
+      PB_DS_S_TREE_NAME(const Cmp_Fn&, const node_update&);
+
+      PB_DS_S_TREE_NAME(const PB_DS_CLASS_C_DEC&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+      void
+      initialize();
+
+      inline std::pair<point_iterator, bool>
+      insert(const_reference r_value);
+
+      inline mapped_reference
+      operator[](key_const_reference r_key)
+      {
+#ifdef PB_DS_DATA_TRUE_INDICATOR
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	std::pair<point_iterator, bool> ins_pair =
+	  insert_leaf_imp(value_type(r_key, mapped_type()));
+
+	ins_pair.first.m_p_nd->m_special = false;
+	_GLIBCXX_DEBUG_ONLY(base_type::assert_valid(__FILE__, __LINE__));
+	splay(ins_pair.first.m_p_nd);
+	_GLIBCXX_DEBUG_ONLY(assert_valid(__FILE__, __LINE__);)
+	return ins_pair.first.m_p_nd->m_value.second;
+#else
+	insert(r_key);
+	return base_type::s_null_type;
+#endif
+      }
+
+      inline point_iterator
+      find(key_const_reference);
+
+      inline point_const_iterator
+      find(key_const_reference) const;
+
+      inline bool
+      erase(key_const_reference);
+
+      inline iterator
+      erase(iterator it);
+
+      inline reverse_iterator
+      erase(reverse_iterator);
+
+      template<typename Pred>
+      inline size_type
+      erase_if(Pred);
+
+      void
+      join(PB_DS_CLASS_C_DEC&);
+
+      void
+      split(key_const_reference, PB_DS_CLASS_C_DEC&);
+
+    private:
+      inline std::pair<point_iterator, bool>
+      insert_leaf_imp(const_reference);
+
+      inline node_pointer
+      find_imp(key_const_reference);
+
+      inline const node_pointer
+      find_imp(key_const_reference) const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char* file, int line) const;
+
+      void
+      assert_special_imp(const node_pointer, const char* file, int line) const;
+#endif
+
+      void
+      splay(node_pointer);
+
+      inline void
+      splay_zig_zag_left(node_pointer, node_pointer, node_pointer);
+
+      inline void
+      splay_zig_zag_right(node_pointer, node_pointer, node_pointer);
+
+      inline void
+      splay_zig_zig_left(node_pointer, node_pointer, node_pointer);
+
+      inline void
+      splay_zig_zig_right(node_pointer, node_pointer, node_pointer);
+
+      inline void
+      splay_zz_start(node_pointer, node_pointer, node_pointer);
+
+      inline void
+      splay_zz_end(node_pointer, node_pointer, node_pointer);
+
+      inline node_pointer
+      leftmost(node_pointer);
+
+      void
+      erase_node(node_pointer);
+    };
+
+#define PB_DS_ASSERT_BASE_NODE_CONSISTENT(_Node)			\
+  _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(_Node,		\
+							__FILE__, __LINE__);)
+
+#include <ext/pb_ds/detail/splay_tree_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp>
+#include <ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp>
+
+#undef PB_DS_ASSERT_BASE_NODE_CONSISTENT
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_S_TREE_NAME
+#undef PB_DS_S_TREE_BASE_NAME
+#undef PB_DS_S_TREE_BASE
+  } // namespace detail
+} // namespace __gnu_pbds
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..07aec09
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp
@@ -0,0 +1,112 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/split_join_fn_imps.hpp
+ * Contains an implementation class for splay_tree_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+  if (base_type::join_prep(other) == false)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  node_pointer p_target_r = other.leftmost(other.m_p_head);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r != 0);
+  other.splay(p_target_r);
+
+  _GLIBCXX_DEBUG_ASSERT(p_target_r == other.m_p_head->m_p_parent);
+  _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left == 0);
+
+  p_target_r->m_p_left = base_type::m_p_head->m_p_parent;
+
+  _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left != 0);
+  p_target_r->m_p_left->m_p_parent = p_target_r;
+
+  base_type::m_p_head->m_p_parent = p_target_r;
+  p_target_r->m_p_parent = base_type::m_p_head;
+
+  this->apply_update(p_target_r, (node_update*)this);
+  base_type::join_finish(other);
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+split(key_const_reference r_key, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  if (base_type::split_prep(r_key, other) == false)
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  node_pointer p_upper_bound = this->upper_bound(r_key).m_p_nd;
+  _GLIBCXX_DEBUG_ASSERT(p_upper_bound != 0);
+
+  splay(p_upper_bound);
+  _GLIBCXX_DEBUG_ASSERT(p_upper_bound->m_p_parent == this->m_p_head);
+
+  node_pointer p_new_root = p_upper_bound->m_p_left;
+  _GLIBCXX_DEBUG_ASSERT(p_new_root != 0);
+
+  base_type::m_p_head->m_p_parent = p_new_root;
+  p_new_root->m_p_parent = base_type::m_p_head;
+  other.m_p_head->m_p_parent = p_upper_bound;
+  p_upper_bound->m_p_parent = other.m_p_head;
+  p_upper_bound->m_p_left = 0;
+  this->apply_update(p_upper_bound, (node_update*)this);
+  base_type::split_finish(other);
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/traits.hpp
new file mode 100644
index 0000000..b3e3e25
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/traits.hpp
@@ -0,0 +1,95 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file splay_tree_/traits.hpp
+ * Contains an implementation for splay_tree_.
+ */
+
+#ifndef PB_DS_SPLAY_TREE_NODE_AND_IT_TRAITS_HPP
+#define PB_DS_SPLAY_TREE_NODE_AND_IT_TRAITS_HPP
+
+#include <ext/pb_ds/detail/splay_tree_/node.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     typename Mapped,
+	     typename Cmp_Fn,
+	     template<typename Node_CItr,
+		      typename Node_Itr,
+		      typename Cmp_Fn_,
+		      typename _Alloc_>
+	     class Node_Update,
+	     typename _Alloc>
+    struct tree_traits<Key, Mapped, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc> 
+    : public bin_search_tree_traits<Key, Mapped, Cmp_Fn, Node_Update,
+				    splay_tree_node_<
+      typename types_traits<Key, Mapped, _Alloc, false>::value_type,
+      typename tree_node_metadata_dispatch<Key, Mapped, Cmp_Fn, Node_Update,
+					   _Alloc>::type,
+				      _Alloc>,
+				      _Alloc>
+    { };
+
+    /// Specialization.
+    /// @ingroup traits
+    template<typename Key,
+	     class Cmp_Fn,
+	     template<typename Node_CItr,
+		      class Node_Itr,
+		      class Cmp_Fn_,
+		      typename _Alloc_>
+             class Node_Update,
+	     typename _Alloc>
+    struct tree_traits<Key, null_type, Cmp_Fn, Node_Update,
+		       splay_tree_tag, _Alloc> 
+    : public bin_search_tree_traits<Key, null_type, Cmp_Fn, Node_Update, 
+				    splay_tree_node_<
+      typename types_traits<Key, null_type, _Alloc, false>::value_type,
+      typename tree_node_metadata_dispatch<Key, null_type, Cmp_Fn, Node_Update,
+					   _Alloc>::type,
+				      _Alloc>,
+				    _Alloc>
+    { };
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_SPLAY_TREE_NODE_AND_IT_TRAITS_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/standard_policies.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/standard_policies.hpp
new file mode 100644
index 0000000..1086fd8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/standard_policies.hpp
@@ -0,0 +1,158 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/standard_policies.hpp
+ * Contains standard policies for containers.
+ */
+
+#ifndef PB_DS_STANDARD_POLICIES_HPP
+#define PB_DS_STANDARD_POLICIES_HPP
+
+#include <memory>
+#include <ext/pb_ds/hash_policy.hpp>
+#include <ext/pb_ds/list_update_policy.hpp>
+#include <ext/pb_ds/detail/branch_policy/null_node_metadata.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+#include <ext/pb_ds/trie_policy.hpp>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <tr1/functional>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Primary template, default_hash_fn.
+    template<typename Key>
+    struct default_hash_fn
+    {
+	/// Dispatched type.
+      typedef std::tr1::hash<Key> 				type;
+    };
+
+    /// Primary template, default_eq_fn.
+    template<typename Key>
+    struct default_eq_fn
+    {
+	/// Dispatched type.
+      typedef std::equal_to<Key> 				type;
+    };
+
+    /// Enumeration for default behavior of stored hash data.
+    enum
+      {
+	default_store_hash = false
+      };
+
+    /// Primary template, default_comb_hash_fn.
+    struct default_comb_hash_fn
+    {
+	/// Dispatched type.
+      typedef direct_mask_range_hashing<> 			type;
+    };
+
+    /// Primary template, default_resize_policy.
+    template<typename Comb_Hash_Fn>
+    struct default_resize_policy
+    {
+    private:
+      typedef typename Comb_Hash_Fn::size_type 			size_type;
+
+      typedef direct_mask_range_hashing<size_type> 		default_fn;
+      typedef is_same<default_fn, Comb_Hash_Fn> 		same_type;
+      typedef hash_exponential_size_policy<size_type> 		iftrue;
+      typedef hash_prime_size_policy 				iffalse;
+      typedef __conditional_type<same_type::value, iftrue, iffalse> cond_type;
+      typedef typename cond_type::__type 		       size_policy_type;
+
+      typedef hash_load_check_resize_trigger<false, size_type> 	trigger;
+
+    public:
+	/// Dispatched type.
+      typedef hash_standard_resize_policy<size_policy_type, trigger, 
+					  false, size_type> 	type;
+    };
+
+    /// Default update policy.
+    struct default_update_policy
+    {
+	/// Dispatched type.
+      typedef lu_move_to_front_policy<> 			type;
+    };
+
+    /// Primary template, default_probe_fn.
+    template<typename Comb_Probe_Fn>
+    struct default_probe_fn
+    {
+    private:
+      typedef typename Comb_Probe_Fn::size_type 		size_type;
+      typedef direct_mask_range_hashing<size_type> 		default_fn;
+      typedef is_same<default_fn, Comb_Probe_Fn> 		same_type;
+      typedef linear_probe_fn<size_type> 			iftrue;
+      typedef quadratic_probe_fn<size_type> 			iffalse;
+      typedef __conditional_type<same_type::value, iftrue, iffalse> cond_type;
+
+    public:
+	/// Dispatched type.
+      typedef typename cond_type::__type 			type;
+    };
+
+
+    /// Primary template, default_trie_access_traits.
+    template<typename Key>
+      struct default_trie_access_traits;
+
+#define __dtrie_alloc std::allocator<char>  
+#define __dtrie_string std::basic_string<Char, Char_Traits, __dtrie_alloc> 
+
+    /// Partial specialization, default_trie_access_traits.
+    template<typename Char, typename Char_Traits>
+      struct default_trie_access_traits<__dtrie_string>
+      {
+      private:
+	typedef __dtrie_string					string_type;
+
+      public:
+	/// Dispatched type.
+	typedef trie_string_access_traits<string_type> 		type;
+      };
+
+#undef __dtrie_alloc
+#undef __dtrie_string
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_STANDARD_POLICIES_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp
new file mode 100644
index 0000000..a01b121
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp
@@ -0,0 +1,105 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/constructors_destructor_fn_imps.hpp
+ * Contains an implementation for thin_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename It>
+void
+PB_DS_CLASS_C_DEC::
+copy_from_range(It first_it, It last_it)
+{
+  while (first_it != last_it)
+    push(*(first_it++));
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+thin_heap() : m_p_max(0)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+thin_heap(const Cmp_Fn& r_cmp_fn) 
+: base_type(r_cmp_fn), m_p_max(0)
+{
+  initialize();
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+thin_heap(const PB_DS_CLASS_C_DEC& other) 
+: base_type(other)
+{
+  initialize();
+  m_p_max = base_type::m_p_root;
+  for (node_pointer p_nd = base_type::m_p_root; p_nd != 0; 
+       p_nd = p_nd->m_p_next_sibling)
+    if (Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value))
+      m_p_max = p_nd;
+
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  base_type::swap(other);
+  std::swap(m_p_max, other.m_p_max);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~thin_heap()
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+initialize()
+{ std::fill(m_a_aux, m_a_aux + max_rank, static_cast<node_pointer>(0)); }
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp
new file mode 100644
index 0000000..f99fcaf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp
@@ -0,0 +1,119 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/debug_fn_imps.hpp
+ * Contains an implementation for thin_heap_.
+ */
+
+#ifdef _GLIBCXX_DEBUG
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_valid(const char* __file, int __line) const
+{
+  base_type::assert_valid(__file, __line);
+  assert_node_consistent(base_type::m_p_root, true, __file, __line);
+  assert_max(__file, __line);
+  assert_aux_null(__file, __line);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_aux_null(const char* __file, int __line) const
+{
+  for (size_type i = 0; i < max_rank; ++i)
+    PB_DS_DEBUG_VERIFY(m_a_aux[i] == 0);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_max(const char* __file, int __line) const
+{
+  if (m_p_max == 0)
+    {
+      PB_DS_DEBUG_VERIFY(base_type::empty());
+      return;
+    }
+
+  PB_DS_DEBUG_VERIFY(!base_type::empty());
+  PB_DS_DEBUG_VERIFY(base_type::parent(m_p_max) == 0);
+  PB_DS_DEBUG_VERIFY(m_p_max->m_p_prev_or_parent == 0);
+  for (const_iterator it = base_type::begin(); it != base_type::end(); ++it)
+    PB_DS_DEBUG_VERIFY(!Cmp_Fn::operator()(m_p_max->m_value, it.m_p_nd->m_value));
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+assert_node_consistent(node_const_pointer p_nd, bool root,
+		       const char* __file, int __line) const
+{
+  base_type::assert_node_consistent(p_nd, root, __file, __line);
+  if (p_nd == 0)
+    return;
+
+  assert_node_consistent(p_nd->m_p_next_sibling, root, __file, __line);
+  assert_node_consistent(p_nd->m_p_l_child, false, __file, __line);
+  if (!root)
+    {
+      if (p_nd->m_metadata == 0)
+	PB_DS_DEBUG_VERIFY(p_nd->m_p_next_sibling == 0);
+      else
+	PB_DS_DEBUG_VERIFY(p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata + 1);
+    }
+
+  if (p_nd->m_p_l_child != 0)
+    PB_DS_DEBUG_VERIFY(p_nd->m_p_l_child->m_metadata + 1 == base_type::degree(p_nd));
+
+  const bool unmarked_valid =
+    (p_nd->m_p_l_child == 0 && p_nd->m_metadata == 0)
+    || (p_nd->m_p_l_child != 0
+	 && p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 1);
+
+  const bool marked_valid =
+    (p_nd->m_p_l_child == 0 && p_nd->m_metadata == 1)
+    || (p_nd->m_p_l_child != 0
+	&& p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 2);
+
+  PB_DS_DEBUG_VERIFY(unmarked_valid || marked_valid);
+  if (root)
+    PB_DS_DEBUG_VERIFY(unmarked_valid);
+}
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp
new file mode 100644
index 0000000..fbdbbf3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp
@@ -0,0 +1,255 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/erase_fn_imps.hpp
+ * Contains an implementation for thin_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+pop()
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
+
+  node_pointer p_nd = m_p_max;
+  remove_max_node();
+  base_type::actual_erase_node(p_nd);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+remove_max_node()
+{
+  to_aux_except_max();
+  make_from_aux();
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+to_aux_except_max()
+{
+  node_pointer p_add = base_type::m_p_root;
+  while (p_add != m_p_max)
+    {
+      node_pointer p_next_add = p_add->m_p_next_sibling;
+      add_to_aux(p_add);
+      p_add = p_next_add;
+    }
+
+  p_add = m_p_max->m_p_l_child;
+  while (p_add != 0)
+    {
+      node_pointer p_next_add = p_add->m_p_next_sibling;
+      p_add->m_metadata = p_add->m_p_l_child == 0 ?
+	0 : p_add->m_p_l_child->m_metadata + 1;
+
+      add_to_aux(p_add);
+      p_add = p_next_add;
+    }
+
+  p_add = m_p_max->m_p_next_sibling;
+  while (p_add != 0)
+    {
+      node_pointer p_next_add = p_add->m_p_next_sibling;
+      add_to_aux(p_add);
+      p_add = p_next_add;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+add_to_aux(node_pointer p_nd)
+{
+  size_type r = p_nd->m_metadata;
+  while (m_a_aux[r] != 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata < rank_bound());
+      if (Cmp_Fn::operator()(m_a_aux[r]->m_value, p_nd->m_value))
+	make_child_of(m_a_aux[r], p_nd);
+      else
+	{
+	  make_child_of(p_nd, m_a_aux[r]);
+	  p_nd = m_a_aux[r];
+	}
+
+      m_a_aux[r] = 0;
+      ++r;
+    }
+
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata < rank_bound());
+
+  m_a_aux[r] = p_nd;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+make_child_of(node_pointer p_nd, node_pointer p_new_parent)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_new_parent->m_metadata);
+  _GLIBCXX_DEBUG_ASSERT(m_a_aux[p_nd->m_metadata] == p_nd ||
+		   m_a_aux[p_nd->m_metadata] == p_new_parent);
+
+  ++p_new_parent->m_metadata;
+  base_type::make_child_of(p_nd, p_new_parent);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+make_from_aux()
+{
+  base_type::m_p_root = m_p_max = 0;
+  const size_type rnk_bnd = rank_bound();
+  size_type i = 0;
+  while (i < rnk_bnd)
+    {
+      if (m_a_aux[i] != 0)
+	{
+	  make_root_and_link(m_a_aux[i]);
+	  m_a_aux[i] = 0;
+	}
+      ++i;
+    }
+
+  PB_DS_ASSERT_AUX_NULL((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+remove_node(node_pointer p_nd)
+{
+  node_pointer p_parent = p_nd;
+  while (base_type::parent(p_parent) != 0)
+    p_parent = base_type::parent(p_parent);
+
+  base_type::bubble_to_top(p_nd);
+  m_p_max = p_nd;
+
+  node_pointer p_fix = base_type::m_p_root;
+  while (p_fix != 0&&  p_fix->m_p_next_sibling != p_parent)
+    p_fix = p_fix->m_p_next_sibling;
+
+  if (p_fix != 0)
+    p_fix->m_p_next_sibling = p_nd;
+
+  remove_max_node();
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  base_type::clear();
+  m_p_max = 0;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+erase(point_iterator it)
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+
+  node_pointer p_nd = it.m_p_nd;
+  remove_node(p_nd);
+  base_type::actual_erase_node(p_nd);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+erase_if(Pred pred)
+{
+  PB_DS_ASSERT_VALID((*this))
+  if (base_type::empty())
+    {
+      PB_DS_ASSERT_VALID((*this))
+      return 0;
+    }
+
+  base_type::to_linked_list();
+  node_pointer p_out = base_type::prune(pred);
+  size_type ersd = 0;
+  while (p_out != 0)
+    {
+      ++ersd;
+      node_pointer p_next = p_out->m_p_next_sibling;
+      base_type::actual_erase_node(p_out);
+      p_out = p_next;
+    }
+
+  node_pointer p_cur = base_type::m_p_root;
+  m_p_max = base_type::m_p_root = 0;
+  while (p_cur != 0)
+    {
+      node_pointer p_next = p_cur->m_p_next_sibling;
+      make_root_and_link(p_cur);
+      p_cur = p_next;
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+  return ersd;
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+rank_bound()
+{
+  using namespace std;
+  const size_t* const p_upper =
+    std::upper_bound(g_a_rank_bounds,
+		     g_a_rank_bounds + num_distinct_rank_bounds,
+		     base_type::m_size);
+
+  if (p_upper == g_a_rank_bounds + num_distinct_rank_bounds)
+    return max_rank;
+
+  return (p_upper - g_a_rank_bounds);
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp
new file mode 100644
index 0000000..9089aef
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/find_fn_imps.hpp
+ * Contains an implementation for thin_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_reference
+PB_DS_CLASS_C_DEC::
+top() const
+{
+  PB_DS_ASSERT_VALID((*this))
+  _GLIBCXX_DEBUG_ASSERT(!base_type::empty());
+
+  _GLIBCXX_DEBUG_ASSERT(m_p_max != 0);
+  return m_p_max->m_value;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp
new file mode 100644
index 0000000..60eaffa
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp
@@ -0,0 +1,280 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/insert_fn_imps.hpp
+ * Contains an implementation for thin_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::point_iterator
+PB_DS_CLASS_C_DEC::
+push(const_reference r_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+  node_pointer p_nd = base_type::get_new_node_for_insert(r_val);
+  p_nd->m_metadata = 0;
+  p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = 0;
+  if (base_type::m_p_root == 0)
+    {
+      p_nd->m_p_next_sibling = 0;
+      m_p_max = base_type::m_p_root = p_nd;
+      PB_DS_ASSERT_VALID((*this))
+      return point_iterator(p_nd);
+    }
+
+  p_nd->m_p_next_sibling = base_type::m_p_root;
+  base_type::m_p_root->m_p_prev_or_parent = 0;
+  base_type::m_p_root = p_nd;
+  update_max(p_nd);
+  PB_DS_ASSERT_VALID((*this))
+  return point_iterator(p_nd);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+make_root(node_pointer p_nd)
+{
+  p_nd->m_metadata = p_nd->m_p_l_child == 0 
+                     ? 0 : 1 + p_nd->m_p_l_child->m_metadata;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+make_root_and_link(node_pointer p_nd)
+{
+  make_root(p_nd);
+  p_nd->m_p_prev_or_parent = 0;
+  p_nd->m_p_next_sibling = base_type::m_p_root;
+  if (base_type::m_p_root != 0)
+    base_type::m_p_root->m_p_prev_or_parent = 0;
+
+  base_type::m_p_root = p_nd;
+  update_max(p_nd);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+fix(node_pointer p_y)
+{
+  while (true)
+    {
+      if (p_y->m_p_prev_or_parent == 0)
+        {
+	  fix_root(p_y);
+	  return;
+        }
+      else if (p_y->m_metadata == 1&&  p_y->m_p_next_sibling == 0)
+        {
+	  if (p_y->m_p_l_child != 0)
+            {
+	      fix_sibling_rank_1_unmarked(p_y);
+	      return;
+            }
+
+	  fix_sibling_rank_1_marked(p_y);
+	  p_y = p_y->m_p_prev_or_parent;
+        }
+      else if (p_y->m_metadata > p_y->m_p_next_sibling->m_metadata + 1)
+        {
+	  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child != 0);
+	  if (p_y->m_metadata != p_y->m_p_l_child->m_metadata + 2)
+            {
+	      fix_sibling_general_unmarked(p_y);
+	      return;
+            }
+
+	  fix_sibling_general_marked(p_y);
+	  p_y = p_y->m_p_prev_or_parent;
+        }
+      else if ((p_y->m_p_l_child == 0&& 
+                p_y->m_metadata == 2) ||(p_y->m_p_l_child != 0&& 
+					 p_y->m_metadata == p_y->m_p_l_child->m_metadata + 3))
+        {
+	  node_pointer p_z = p_y->m_p_prev_or_parent;
+	  fix_child(p_y);
+	  p_y = p_z;
+        }
+      else
+	return;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+fix_root(node_pointer p_y)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent == 0);
+  make_root(p_y);
+  PB_DS_ASSERT_NODE_CONSISTENT(p_y, true)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+fix_sibling_rank_1_unmarked(node_pointer p_y)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
+
+  _GLIBCXX_DEBUG_ONLY(node_pointer p_w = p_y->m_p_l_child;)
+  _GLIBCXX_DEBUG_ASSERT(p_w != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling == 0);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_next_sibling == 0);
+
+  p_y->m_p_next_sibling = p_y->m_p_l_child;
+  p_y->m_p_next_sibling->m_p_prev_or_parent = p_y;
+  p_y->m_p_l_child = 0;
+  PB_DS_ASSERT_NODE_CONSISTENT(p_y, false)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+fix_sibling_rank_1_marked(node_pointer p_y)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child == 0);
+  p_y->m_metadata = 0;
+  PB_DS_ASSERT_NODE_CONSISTENT(p_y, false)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+fix_sibling_general_unmarked(node_pointer p_y)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
+
+  node_pointer p_w = p_y->m_p_l_child;
+  _GLIBCXX_DEBUG_ASSERT(p_w != 0);
+  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != 0);
+
+  p_y->m_p_l_child = p_w->m_p_next_sibling;
+  p_w->m_p_next_sibling->m_p_prev_or_parent = p_y;
+
+  p_w->m_p_next_sibling = p_y->m_p_next_sibling;
+  _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != 0);
+  p_w->m_p_next_sibling->m_p_prev_or_parent = p_w;
+
+  p_y->m_p_next_sibling = p_w;
+  p_w->m_p_prev_or_parent = p_y;
+
+  PB_DS_ASSERT_NODE_CONSISTENT(p_y, false)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+fix_sibling_general_marked(node_pointer p_y)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
+  --p_y->m_metadata;
+  PB_DS_ASSERT_NODE_CONSISTENT(p_y, false)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+fix_child(node_pointer p_y)
+{
+  _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0);
+
+  if (p_y->m_p_next_sibling != 0)
+    p_y->m_p_next_sibling->m_p_prev_or_parent = p_y->m_p_prev_or_parent;
+
+  if (p_y->m_p_prev_or_parent->m_p_l_child == p_y)
+    p_y->m_p_prev_or_parent->m_p_l_child = p_y->m_p_next_sibling;
+  else
+    p_y->m_p_prev_or_parent->m_p_next_sibling = p_y->m_p_next_sibling;
+
+  make_root_and_link(p_y);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+modify(point_iterator it, const_reference r_new_val)
+{
+  PB_DS_ASSERT_VALID((*this))
+  node_pointer p_nd = it.m_p_nd;
+  _GLIBCXX_DEBUG_ASSERT(p_nd != 0);
+
+  const bool smaller = Cmp_Fn::operator()(r_new_val, p_nd->m_value);
+  p_nd->m_value = r_new_val;
+  if (smaller)
+    {
+      remove_node(p_nd);
+      p_nd->m_p_l_child = 0;
+      make_root_and_link(p_nd);
+      PB_DS_ASSERT_VALID((*this))
+      return;
+    }
+
+  if (p_nd->m_p_prev_or_parent == 0)
+    {
+      update_max(p_nd);
+      PB_DS_ASSERT_VALID((*this))
+      return;
+    }
+
+  node_pointer p_y = p_nd->m_p_prev_or_parent;
+  _GLIBCXX_DEBUG_ASSERT(p_y != 0);
+
+  if (p_nd->m_p_next_sibling != 0)
+    p_nd->m_p_next_sibling->m_p_prev_or_parent = p_y;
+
+  if (p_y->m_p_l_child == p_nd)
+    p_y->m_p_l_child = p_nd->m_p_next_sibling;
+  else
+    p_y->m_p_next_sibling = p_nd->m_p_next_sibling;
+
+  fix(p_y);
+  make_root_and_link(p_nd);
+  PB_DS_ASSERT_VALID((*this))
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+update_max(node_pointer p_nd)
+{
+  if (m_p_max == 0 || Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value))
+    m_p_max = p_nd;
+}
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp
new file mode 100644
index 0000000..222ecd1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp
@@ -0,0 +1,108 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/split_join_fn_imps.hpp
+ * Contains an implementation for thin_heap_.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+void
+PB_DS_CLASS_C_DEC::
+split(Pred pred, PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  other.clear();
+  if (base_type::empty())
+    {
+      PB_DS_ASSERT_VALID((*this))
+      PB_DS_ASSERT_VALID(other)
+      return;
+    }
+
+  base_type::to_linked_list();
+  node_pointer p_out = base_type::prune(pred);
+
+  while (p_out != 0)
+    {
+      _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0);
+      --base_type::m_size;
+      ++other.m_size;
+      node_pointer p_next = p_out->m_p_next_sibling;
+      other.make_root_and_link(p_out);
+      p_out = p_next;
+    }
+
+  PB_DS_ASSERT_VALID(other)
+  node_pointer p_cur = base_type::m_p_root;
+  m_p_max = 0;
+  base_type::m_p_root = 0;
+  while (p_cur != 0)
+    {
+      node_pointer p_next = p_cur->m_p_next_sibling;
+      make_root_and_link(p_cur);
+      p_cur = p_next;
+    }
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+
+  node_pointer p_other = other.m_p_root;
+  while (p_other != 0)
+    {
+      node_pointer p_next = p_other->m_p_next_sibling;
+      make_root_and_link(p_other);
+      p_other = p_next;
+    }
+  base_type::m_size += other.m_size;
+  other.m_p_root = 0;
+  other.m_size = 0;
+  other.m_p_max = 0;
+
+  PB_DS_ASSERT_VALID((*this))
+  PB_DS_ASSERT_VALID(other)
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/thin_heap_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/thin_heap_.hpp
new file mode 100644
index 0000000..f37c5e4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/thin_heap_.hpp
@@ -0,0 +1,324 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/thin_heap_.hpp
+ * Contains an implementation class for a thin heap.
+ */
+
+#ifndef PB_DS_THIN_HEAP_HPP
+#define PB_DS_THIN_HEAP_HPP
+
+#include <algorithm>
+#include <ext/pb_ds/detail/cond_dealtor.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp>
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#define PB_DS_CLASS_T_DEC \
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    thin_heap<Value_Type, Cmp_Fn, _Alloc>
+
+#ifdef _GLIBCXX_DEBUG
+#define PB_DS_BASE_T_P \
+    <Value_Type, Cmp_Fn, typename _Alloc::size_type, _Alloc, true>
+#else
+#define PB_DS_BASE_T_P \
+    <Value_Type, Cmp_Fn, typename _Alloc::size_type, _Alloc>
+#endif
+
+
+    /**
+     *  Thin heap.
+     *
+     *  @ingroup heap-detail
+     *
+     *  See Tarjan and Kaplan.
+     */
+    template<typename Value_Type, typename Cmp_Fn, typename _Alloc>
+    class thin_heap
+    : public left_child_next_sibling_heap PB_DS_BASE_T_P
+    {
+    private:
+      typedef typename _Alloc::template rebind<Value_Type>::other __rebind_a;
+      typedef left_child_next_sibling_heap PB_DS_BASE_T_P base_type;
+
+    protected:
+      typedef typename base_type::node 			node;
+      typedef typename base_type::node_pointer 		node_pointer;
+      typedef typename base_type::node_const_pointer 	node_const_pointer;
+
+    public:
+      typedef Value_Type 				value_type;
+      typedef Cmp_Fn 					cmp_fn;
+      typedef _Alloc 					allocator_type;
+      typedef typename _Alloc::size_type 		size_type;
+      typedef typename _Alloc::difference_type 		difference_type;
+
+      typedef typename __rebind_a::pointer		pointer;
+      typedef typename __rebind_a::const_pointer	const_pointer;
+      typedef typename __rebind_a::reference		reference;
+      typedef typename __rebind_a::const_reference     	const_reference;
+
+      typedef typename base_type::point_iterator 	point_iterator;
+      typedef typename base_type::point_const_iterator 	point_const_iterator;
+      typedef typename base_type::iterator 		iterator;
+      typedef typename base_type::const_iterator 	const_iterator;
+
+
+      inline point_iterator
+      push(const_reference);
+
+      void
+      modify(point_iterator, const_reference);
+
+      inline const_reference
+      top() const;
+
+      void
+      pop();
+
+      void
+      erase(point_iterator);
+
+      inline void
+      clear();
+
+      template<typename Pred>
+      size_type
+      erase_if(Pred);
+
+      template<typename Pred>
+      void
+      split(Pred, PB_DS_CLASS_C_DEC&);
+
+      void
+      join(PB_DS_CLASS_C_DEC&);
+
+    protected:
+      thin_heap();
+
+      thin_heap(const Cmp_Fn&);
+
+      thin_heap(const PB_DS_CLASS_C_DEC&);
+
+      void
+      swap(PB_DS_CLASS_C_DEC&);
+
+      ~thin_heap();
+
+      template<typename It>
+      void
+      copy_from_range(It, It);
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid(const char*, int) const;
+
+      void
+      assert_max(const char*, int) const;
+#endif
+
+#ifdef PB_DS_THIN_HEAP_TRACE_
+      void
+      trace() const;
+#endif
+
+    private:
+      enum
+	{
+	  max_rank = (sizeof(size_type) << 4) + 2
+	};
+
+      void
+      initialize();
+
+      inline void
+      update_max(node_pointer);
+
+      inline void
+      fix(node_pointer);
+
+      inline void
+      fix_root(node_pointer);
+
+      inline void
+      fix_sibling_rank_1_unmarked(node_pointer);
+
+      inline void
+      fix_sibling_rank_1_marked(node_pointer);
+
+      inline void
+      fix_sibling_general_unmarked(node_pointer);
+
+      inline void
+      fix_sibling_general_marked(node_pointer);
+
+      inline void
+      fix_child(node_pointer);
+
+      inline static void
+      make_root(node_pointer);
+
+      inline void
+      make_root_and_link(node_pointer);
+
+      inline void
+      remove_max_node();
+
+      void
+      to_aux_except_max();
+
+      inline void
+      add_to_aux(node_pointer);
+
+      inline void
+      make_from_aux();
+
+      inline size_type
+      rank_bound();
+
+      inline void
+      make_child_of(node_pointer, node_pointer);
+
+      inline void
+      remove_node(node_pointer);
+
+      inline node_pointer
+      join(node_pointer, node_pointer) const;
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_node_consistent(node_const_pointer, bool, const char*, int) const;
+
+      void
+      assert_aux_null(const char*, int) const;
+#endif
+
+      node_pointer 	m_p_max;
+      node_pointer 	m_a_aux[max_rank];
+    };
+
+    enum
+      {
+	num_distinct_rank_bounds = 48
+      };
+
+    // Taken from the SGI implementation; acknowledged in the docs.
+    static const std::size_t g_a_rank_bounds[num_distinct_rank_bounds] =
+      {
+	/* Dealing cards... */
+	/* 0     */ 0ul,
+	/* 1     */ 1ul,
+	/* 2     */ 1ul,
+	/* 3     */ 2ul,
+	/* 4     */ 4ul,
+	/* 5     */ 6ul,
+	/* 6     */ 11ul,
+	/* 7     */ 17ul,
+	/* 8     */ 29ul,
+	/* 9     */ 46ul,
+	/* 10    */ 76ul,
+	/* 11    */ 122ul,
+	/* 12    */ 199ul,
+	/* 13    */ 321ul,
+	/* 14    */ 521ul,
+	/* 15    */ 842ul,
+	/* 16    */ 1364ul,
+	/* 17    */ 2206ul,
+	/* 18    */ 3571ul,
+	/* 19    */ 5777ul,
+	/* 20    */ 9349ul,
+	/* 21    */ 15126ul,
+	/* 22    */ 24476ul,
+	/* 23    */ 39602ul,
+	/* 24    */ 64079ul,
+	/* 25    */ 103681ul,
+	/* 26    */ 167761ul,
+	/* 27    */ 271442ul,
+	/* 28    */ 439204ul,
+	/* 29    */ 710646ul,
+	/* 30    */ 1149851ul,
+	/* 31    */ 1860497ul,
+	/* 32    */ 3010349ul,
+	/* 33    */ 4870846ul,
+	/* 34    */ 7881196ul,
+	/* 35    */ 12752042ul,
+	/* 36    */ 20633239ul,
+	/* 37    */ 33385282ul,
+	/* 38    */ 54018521ul,
+	/* 39    */ 87403803ul,
+	/* 40    */ 141422324ul,
+	/* 41    */ 228826127ul,
+	/* 42    */ 370248451ul,
+	/* 43    */ 599074578ul,
+	/* 44    */ 969323029ul,
+	/* 45    */ 1568397607ul,
+	/* 46    */ 2537720636ul,
+	/* 47    */ 4106118243ul
+	/* Pot's good, let's play */
+      };
+
+#define PB_DS_ASSERT_NODE_CONSISTENT(_Node, _Bool)			\
+  _GLIBCXX_DEBUG_ONLY(assert_node_consistent(_Node, _Bool,		\
+					     __FILE__, __LINE__);)
+
+#define PB_DS_ASSERT_AUX_NULL(X)					\
+  _GLIBCXX_DEBUG_ONLY(X.assert_aux_null(__FILE__, __LINE__);)
+
+#include <ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp>
+#include <ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp>
+#include <ext/pb_ds/detail/thin_heap_/trace_fn_imps.hpp>
+#include <ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp>
+#include <ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp>
+#include <ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp>
+#include <ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp>
+
+#undef PB_DS_ASSERT_AUX_NULL
+#undef PB_DS_ASSERT_NODE_CONSISTENT
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_BASE_T_P
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/trace_fn_imps.hpp
new file mode 100644
index 0000000..cb6a623
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/trace_fn_imps.hpp
@@ -0,0 +1,53 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file thin_heap_/trace_fn_imps.hpp
+ * Contains an implementation class for left_child_next_sibling_heap_.
+ */
+
+#ifdef PB_DS_THIN_HEAP_TRACE_
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+trace() const
+{
+  std::cerr << std::endl;
+  std::cerr << "m_p_max " << m_p_max << std::endl;
+  base_type::trace();
+}
+
+#endif // #ifdef PB_DS_THIN_HEAP_TRACE_
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/node_metadata_selector.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/node_metadata_selector.hpp
new file mode 100644
index 0000000..6be96f6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/node_metadata_selector.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file tree_policy/node_metadata_selector.hpp
+ * Contains an implementation class for trees.
+ */
+
+#ifndef PB_DS_TREE_NODE_METADATA_DISPATCH_HPP
+#define PB_DS_TREE_NODE_METADATA_DISPATCH_HPP
+
+#include <ext/pb_ds/detail/branch_policy/null_node_metadata.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /**
+     *  @addtogroup traits Traits
+     *  @{
+     */
+
+    /// Tree metadata helper.
+    template<typename Node_Update, bool _BTp>
+      struct tree_metadata_helper;
+
+    /// Specialization, false.
+    template<typename Node_Update>
+      struct tree_metadata_helper<Node_Update, false>
+      {
+	typedef typename Node_Update::metadata_type 	type;
+      };
+
+    /// Specialization, true.
+    template<typename Node_Update>
+      struct tree_metadata_helper<Node_Update, true>
+      {
+	typedef null_type 				type;
+      };
+
+    /// Tree node metadata dispatch.
+    template<typename Key,
+	     typename Data,
+	     typename Cmp_Fn,
+	     template<typename Node_CItr,
+		      typename Const_Iterator,
+		      typename Cmp_Fn_,
+		      typename _Alloc_>
+	     class Node_Update,
+	     typename _Alloc>
+    struct tree_node_metadata_dispatch
+    {
+    private:
+      typedef dumnode_const_iterator<Key, Data, _Alloc>		__it_type;
+      typedef Node_Update<__it_type, __it_type, Cmp_Fn, _Alloc>	__node_u;
+      typedef null_node_update<__it_type, __it_type, Cmp_Fn, _Alloc> __nnode_u;
+
+      enum
+	{
+	  null_update = is_same<__node_u, __nnode_u>::value
+	};
+
+    public:
+      typedef typename tree_metadata_helper<__node_u, null_update>::type type;
+    };
+    //@}
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TREE_NODE_METADATA_DISPATCH_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/order_statistics_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/order_statistics_imp.hpp
new file mode 100644
index 0000000..7a4966e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/order_statistics_imp.hpp
@@ -0,0 +1,121 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file tree_policy/order_statistics_imp.hpp
+ * Contains forward declarations for order_statistics_key
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+find_by_order(size_type order)
+{
+  node_iterator it = node_begin();
+  node_iterator end_it = node_end();
+
+  while (it != end_it)
+    {
+      node_iterator l_it = it.get_l_child();
+      const size_type o = (l_it == end_it)? 0 : l_it.get_metadata();
+
+      if (order == o)
+	return *it;
+      else if (order < o)
+	it = l_it;
+      else
+        {
+	  order -= o + 1;
+	  it = it.get_r_child();
+        }
+    }
+
+  return base_type::end_iterator();
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+find_by_order(size_type order) const
+{ return const_cast<PB_DS_CLASS_C_DEC*>(this)->find_by_order(order); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+order_of_key(key_const_reference r_key) const
+{
+  node_const_iterator it = node_begin();
+  node_const_iterator end_it = node_end();
+
+  const cmp_fn& r_cmp_fn = const_cast<PB_DS_CLASS_C_DEC*>(this)->get_cmp_fn();
+  size_type ord = 0;
+  while (it != end_it)
+    {
+      node_const_iterator l_it = it.get_l_child();
+
+      if (r_cmp_fn(r_key, this->extract_key(*(*it))))
+	it = l_it;
+      else if (r_cmp_fn(this->extract_key(*(*it)), r_key))
+        {
+	  ord += (l_it == end_it)? 1 : 1 + l_it.get_metadata();
+	  it = it.get_r_child();
+        }
+      else
+        {
+	  ord += (l_it == end_it)? 0 : l_it.get_metadata();
+	  it = end_it;
+        }
+    }
+  return ord;
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+operator()(node_iterator node_it, node_const_iterator end_nd_it) const
+{
+  node_iterator l_it = node_it.get_l_child();
+  const size_type l_rank = (l_it == end_nd_it) ? 0 : l_it.get_metadata();
+
+  node_iterator r_it = node_it.get_r_child();
+  const size_type r_rank = (r_it == end_nd_it) ? 0 : r_it.get_metadata();
+
+  const_cast<metadata_reference>(node_it.get_metadata())= 1 + l_rank + r_rank;
+}
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~tree_order_statistics_node_update()
+{ }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp
new file mode 100644
index 0000000..dcafdf1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp
@@ -0,0 +1,62 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file tree_policy/sample_tree_node_update.hpp
+ * Contains a samle node update functor.
+ */
+
+#ifndef PB_DS_SAMPLE_TREE_NODE_UPDATOR_HPP
+#define PB_DS_SAMPLE_TREE_NODE_UPDATOR_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample node updator.
+  template<typename Const_Node_Iter, typename Node_Iter, typename Cmp_Fn,
+	   typename _Alloc>
+  class sample_tree_node_update
+  {
+    typedef std::size_t metadata_type;
+
+    /// Default constructor.
+    sample_tree_node_update();
+
+    /// Updates the rank of a node through a node_iterator node_it;
+    /// end_nd_it is the end node iterator.
+    inline void
+    operator()(node_iterator node_it, node_const_iterator end_nd_it) const;
+  };
+}
+#endif // #ifndef PB_DS_SAMPLE_TREE_NODE_UPDATOR_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_trace_base.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_trace_base.hpp
new file mode 100644
index 0000000..223bb20
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/tree_trace_base.hpp
@@ -0,0 +1,179 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/tree_trace_base.hpp
+ * Contains tree-related policies.
+ */
+
+#ifndef PB_DS_TREE_TRACE_BASE_HPP
+#define PB_DS_TREE_TRACE_BASE_HPP
+
+#ifdef PB_DS_TREE_TRACE
+
+#include <ext/pb_ds/detail/branch_policy/branch_policy.hpp>
+#include <ext/pb_ds/detail/branch_policy/null_node_metadata.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+#ifdef PB_DS_TREE_TRACE
+
+#define PB_DS_CLASS_T_DEC						\
+    template<typename Node_CItr, typename Node_Itr,	\
+	     typename Cmp_Fn, bool Node_Based, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC						\
+    tree_trace_base<Node_CItr, Node_Itr, Cmp_Fn,         \
+		    Node_Based, _Alloc>
+
+#define PB_DS_TRACE_BASE \
+    branch_policy<Node_CItr, Node_Itr, _Alloc>
+
+    /// Tracing base class.
+    template<typename Node_CItr, typename Node_Itr,
+	     typename Cmp_Fn, bool Node_Based, typename _Alloc>
+    class tree_trace_base : private PB_DS_TRACE_BASE
+    {
+    public:
+      void
+      trace() const;
+
+    private:
+      typedef PB_DS_TRACE_BASE 			base_type;
+      typedef Node_CItr 		node_const_iterator;
+      typedef typename _Alloc::size_type 	size_type;
+
+      void
+      trace_node(node_const_iterator, size_type) const;
+
+      virtual bool
+      empty() const = 0;
+
+      virtual node_const_iterator
+      node_begin() const = 0;
+
+      virtual node_const_iterator
+      node_end() const = 0;
+
+      static void
+      print_node_pointer(Node_CItr, integral_constant<int,true>);
+
+      static void
+      print_node_pointer(Node_CItr, integral_constant<int,false>);
+
+      template<typename Metadata_>
+      static void
+      trace_it_metadata(Node_CItr, type_to_type<Metadata_>);
+
+      static void
+      trace_it_metadata(Node_CItr, type_to_type<null_type>);
+    };
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    trace() const
+    {
+      if (empty())
+	return;
+      trace_node(node_begin(), 0);
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    trace_node(node_const_iterator nd_it, size_type level) const
+    {
+      if (nd_it.get_r_child() != node_end())
+	trace_node(nd_it.get_r_child(), level + 1);
+
+      for (size_type i = 0; i < level; ++i)
+	std::cerr << ' ';
+
+      print_node_pointer(nd_it, integral_constant<int,Node_Based>());
+      std::cerr << base_type::extract_key(*(*nd_it));
+
+      typedef type_to_type<typename node_const_iterator::metadata_type>
+	m_type_ind_t;
+
+      trace_it_metadata(nd_it, m_type_ind_t());
+
+      std::cerr << std::endl;
+
+      if (nd_it.get_l_child() != node_end())
+	trace_node(nd_it.get_l_child(), level + 1);
+    }
+
+    PB_DS_CLASS_T_DEC
+    template<typename Metadata_>
+    void
+    PB_DS_CLASS_C_DEC::
+    trace_it_metadata(Node_CItr nd_it, type_to_type<Metadata_>)
+    {
+      const unsigned long ul = static_cast<unsigned long>(nd_it.get_metadata());
+      std::cerr << " (" << ul << ") ";
+    }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    trace_it_metadata(Node_CItr, type_to_type<null_type>)
+    { }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    print_node_pointer(Node_CItr nd_it, integral_constant<int,true>)
+    { std::cerr << nd_it.m_p_nd << " "; }
+
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    print_node_pointer(Node_CItr nd_it, integral_constant<int,false>)
+    { std::cerr << *nd_it << " "; }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_TRACE_BASE
+#endif // #ifdef    PB_DS_TREE_TRACE
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifdef PB_DS_TREE_TRACE
+
+#endif // #ifndef PB_DS_TREE_TRACE_BASE_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/node_metadata_selector.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/node_metadata_selector.hpp
new file mode 100644
index 0000000..c022107
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/node_metadata_selector.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy/node_metadata_selector.hpp
+ * Contains an implementation class for tries.
+ */
+
+#ifndef PB_DS_TRIE_NODE_METADATA_DISPATCH_HPP
+#define PB_DS_TRIE_NODE_METADATA_DISPATCH_HPP
+
+#include <ext/pb_ds/detail/branch_policy/null_node_metadata.hpp>
+#include <ext/pb_ds/detail/types_traits.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /**
+     *  @addtogroup traits Traits
+     *  @{
+     */
+
+    /// Trie metadata helper.
+    template<typename Node_Update, bool _BTp>
+      struct trie_metadata_helper;
+
+    /// Specialization, false.
+    template<typename Node_Update>
+      struct trie_metadata_helper<Node_Update, false>
+      {
+	typedef typename Node_Update::metadata_type 	type;
+      };
+
+    /// Specialization, true.
+    template<typename Node_Update>
+      struct trie_metadata_helper<Node_Update, true>
+      {
+	typedef null_type 				type;
+      };
+
+    /// Trie node metadata dispatch.
+    template<typename Key,
+	     typename Data,
+	     typename Cmp_Fn,
+	     template<typename Node_CItr,
+		      typename Const_Iterator,
+		      typename Cmp_Fn_,
+		      typename _Alloc_>
+	     class Node_Update,
+	     typename _Alloc>
+    struct trie_node_metadata_dispatch
+    {
+    private:
+      typedef dumnode_const_iterator<Key, Data, _Alloc>		__it_type;
+      typedef Node_Update<__it_type, __it_type, Cmp_Fn, _Alloc>	__node_u;
+      typedef null_node_update<__it_type, __it_type, Cmp_Fn, _Alloc> __nnode_u;
+
+      enum
+	{
+	  null_update = is_same<__node_u, __nnode_u>::value
+	};
+
+    public:
+      typedef typename trie_metadata_helper<__node_u, null_update>::type type;
+    };
+    //@}
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TRIE_NODE_METADATA_DISPATCH_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp
new file mode 100644
index 0000000..d2f5d64
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp
@@ -0,0 +1,160 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy/order_statistics_imp.hpp
+ * Contains forward declarations for order_statistics_key
+ */
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::iterator
+PB_DS_CLASS_C_DEC::
+find_by_order(size_type order)
+{
+  if (empty())
+    return end();
+
+  ++order;
+  node_iterator nd_it = node_begin();
+
+  while (true)
+    {
+      if (order > nd_it.get_metadata())
+	return ++base_type::rightmost_it(nd_it);
+
+      const size_type num_children = nd_it.num_children();
+      if (num_children == 0)
+	return *nd_it;
+
+      for (size_type i = 0; i < num_children; ++i)
+	{
+	  node_iterator child_nd_it = nd_it.get_child(i);
+	  if (order <= child_nd_it.get_metadata())
+	    {
+	      i = num_children;
+	      nd_it = child_nd_it;
+	    }
+	  else
+	    order -= child_nd_it.get_metadata();
+	}
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+find_by_order(size_type order) const
+{ return const_cast<PB_DS_CLASS_C_DEC*>(this)->find_by_order(order); }
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+order_of_key(key_const_reference r_key) const
+{
+  const _ATraits& r_traits =
+    const_cast<PB_DS_CLASS_C_DEC* >(this)->get_access_traits();
+
+  return order_of_prefix(r_traits.begin(r_key), r_traits.end(r_key));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+order_of_prefix(typename access_traits::const_iterator b,
+		typename access_traits::const_iterator e) const
+{
+  if (empty())
+    return 0;
+
+  const _ATraits& r_traits =
+    const_cast<PB_DS_CLASS_C_DEC*>(this)->get_access_traits();
+
+  node_const_iterator nd_it = node_begin();
+  node_const_iterator end_nd_it = node_end();
+  size_type ord = 0;
+
+  while (true)
+    {
+      const size_type num_children = nd_it.num_children();
+      if (num_children == 0)
+	{
+	  key_const_reference r_key = base_type::extract_key(*(*nd_it));
+	  typename access_traits::const_iterator key_b =
+	    r_traits.begin(r_key);
+
+	  typename access_traits::const_iterator key_e =
+	    r_traits.end(r_key);
+
+	  return (base_type::less(key_b, key_e,  b, e,  r_traits)) ?
+		  ord + 1 : ord;
+	}
+
+      node_const_iterator next_nd_it = end_nd_it;
+      size_type i = num_children - 1;
+
+      do
+	{
+	  node_const_iterator child_nd_it = nd_it.get_child(i);
+
+	  if (next_nd_it != end_nd_it)
+	    ord += child_nd_it.get_metadata();
+	  else if (!base_type::less(b, e,
+				    child_nd_it.valid_prefix().first,
+				    child_nd_it.valid_prefix().second,
+				    r_traits))
+	    next_nd_it = child_nd_it;
+	}
+      while (i-- > 0);
+
+      if (next_nd_it == end_nd_it)
+	return ord;
+
+      nd_it = next_nd_it;
+    }
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+operator()(node_iterator nd_it, node_const_iterator /*end_nd_it*/) const
+{
+  const size_type num_children = nd_it.num_children();
+  size_type children_rank = 0;
+  for (size_type i = 0; i < num_children; ++i)
+    children_rank += nd_it.get_child(i).get_metadata();
+
+  const size_type res = (num_children == 0) ? 1 : children_rank;
+  const_cast<size_type&>(nd_it.get_metadata()) = res;
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/prefix_search_node_update_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/prefix_search_node_update_imp.hpp
new file mode 100644
index 0000000..5be1183
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/prefix_search_node_update_imp.hpp
@@ -0,0 +1,139 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy/prefix_search_node_update_imp.hpp
+ * Contains an implementation of prefix_search_node_update.
+ */
+
+PB_DS_CLASS_T_DEC
+std::pair<
+  typename PB_DS_CLASS_C_DEC::const_iterator,
+  typename PB_DS_CLASS_C_DEC::const_iterator>
+PB_DS_CLASS_C_DEC::
+prefix_range(key_const_reference r_key) const
+{
+  const access_traits& r_traits = get_access_traits();
+  return (prefix_range(r_traits.begin(r_key), r_traits.end(r_key)));
+}
+
+PB_DS_CLASS_T_DEC
+std::pair<
+  typename PB_DS_CLASS_C_DEC::iterator,
+  typename PB_DS_CLASS_C_DEC::iterator>
+PB_DS_CLASS_C_DEC::
+prefix_range(key_const_reference r_key)
+{
+  return (prefix_range(get_access_traits().begin(r_key),
+		       get_access_traits().end(r_key)));
+}
+
+PB_DS_CLASS_T_DEC
+std::pair<
+  typename PB_DS_CLASS_C_DEC::const_iterator,
+  typename PB_DS_CLASS_C_DEC::const_iterator>
+PB_DS_CLASS_C_DEC::
+prefix_range(typename access_traits::const_iterator b,
+	     typename access_traits::const_iterator e) const
+{
+  const std::pair<iterator, iterator> non_const_ret =
+    const_cast<PB_DS_CLASS_C_DEC* >(this)->prefix_range(b, e);
+
+  return (std::make_pair(const_iterator(non_const_ret.first),
+			 const_iterator(non_const_ret.second)));
+}
+
+PB_DS_CLASS_T_DEC
+std::pair<
+  typename PB_DS_CLASS_C_DEC::iterator,
+  typename PB_DS_CLASS_C_DEC::iterator>
+PB_DS_CLASS_C_DEC::
+prefix_range(typename access_traits::const_iterator b,
+	     typename access_traits::const_iterator e)
+{
+  Node_Itr nd_it = node_begin();
+  Node_Itr end_nd_it = node_end();
+
+  const access_traits& r_traits = get_access_traits();
+  const size_type given_range_length = std::distance(b, e);
+
+  while (true)
+    {
+      if (nd_it == end_nd_it)
+	return (std::make_pair(end(), end()));
+
+      const size_type common_range_length =
+	base_type::common_prefix_len(nd_it, b, e, r_traits);
+
+      if (common_range_length >= given_range_length)
+	{
+	  iterator ret_b = this->leftmost_it(nd_it);
+	  iterator ret_e = this->rightmost_it(nd_it);
+	  return (std::make_pair(ret_b, ++ret_e));
+	}
+      nd_it = next_child(nd_it, b, e, end_nd_it, r_traits);
+    }
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::node_iterator
+PB_DS_CLASS_C_DEC::
+next_child(node_iterator nd_it, typename access_traits::const_iterator b,
+	   typename access_traits::const_iterator e, node_iterator end_nd_it,
+	   const access_traits& r_traits)
+{
+  const size_type num_children = nd_it.num_children();
+  node_iterator ret = end_nd_it;
+  size_type max_length = 0;
+  for (size_type i = 0; i < num_children; ++i)
+    {
+      node_iterator pot = nd_it.get_child(i);
+      const size_type common_range_length =
+	base_type::common_prefix_len(pot, b, e, r_traits);
+
+      if (common_range_length > max_length)
+	{
+	  ret = pot;
+	  max_length = common_range_length;
+	}
+    }
+  return (ret);
+}
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+operator()(node_iterator /*nd_it*/, node_const_iterator /*end_nd_it*/) const
+{ }
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_access_traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_access_traits.hpp
new file mode 100644
index 0000000..0590774
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_access_traits.hpp
@@ -0,0 +1,77 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy/sample_trie_access_traits.hpp
+ * Contains a sample probe policy.
+ */
+
+#ifndef PB_DS_SAMPLE_TRIE_E_ACCESS_TRAITS_HPP
+#define PB_DS_SAMPLE_TRIE_E_ACCESS_TRAITS_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample trie element access traits.
+  struct sample_trie_access_traits
+  {
+    typedef std::size_t 		       		size_type;
+    typedef std::string 			       	key_type;
+
+    typedef typename _Alloc::template rebind<key_type>	__rebind_k;
+    typedef typename __rebind_k::other::const_reference	key_const_reference;
+    typedef std::string::const_iterator 		const_iterator;
+
+    /// Element type.
+    typedef char 				       	e_type;
+
+    enum
+      {
+	max_size = 4
+      };
+
+    /// Returns a const_iterator to the first element of r_key.
+    inline static const_iterator
+    begin(key_const_reference);
+
+    /// Returns a const_iterator to the after-last element of r_key.
+    inline static const_iterator
+    end(key_const_reference);
+
+    /// Maps an element to a position.
+    inline static size_type
+    e_pos(e_type);
+  };
+}
+#endif // #ifndef PB_DS_SAMPLE_TRIE_E_ACCESS_TRAITS_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp
new file mode 100644
index 0000000..ea9ed1b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy/sample_trie_node_update.hpp
+ * Contains a samle node update functor.
+ */
+
+#ifndef PB_DS_SAMPLE_TRIE_NODE_UPDATOR_HPP
+#define PB_DS_SAMPLE_TRIE_NODE_UPDATOR_HPP
+
+namespace __gnu_pbds
+{
+  /// A sample node updator.
+  template<typename Node_CItr, typename Node_Itr,
+	   typename _ATraits, typename _Alloc>
+  class sample_trie_node_update
+  {
+  public:
+    typedef std::size_t 		metadata_type;
+
+  protected:
+    /// Default constructor.
+    sample_trie_node_update();
+
+    /// Updates the rank of a node through a node_iterator node_it;
+    /// end_nd_it is the end node iterator.
+    inline void
+    operator()(node_iterator, node_const_iterator) const;
+  };
+}
+#endif // #ifndef PB_DS_SAMPLE_TRIE_NODE_UPDATOR_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/trie_policy_base.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/trie_policy_base.hpp
new file mode 100644
index 0000000..3914684
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/trie_policy_base.hpp
@@ -0,0 +1,207 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy/trie_policy_base.hpp
+ * Contains an implementation of trie_policy_base.
+ */
+
+#ifndef PB_DS_TRIE_POLICY_BASE_HPP
+#define PB_DS_TRIE_POLICY_BASE_HPP
+
+#include <ext/pb_ds/detail/branch_policy/branch_policy.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /// Base class for trie policies.
+    template<typename Node_CItr, typename Node_Itr,
+	     typename _ATraits, typename _Alloc>
+    class trie_policy_base
+    : public branch_policy<Node_CItr, Node_Itr, _Alloc>
+    {
+      typedef branch_policy<Node_CItr, Node_Itr, _Alloc> base_type;
+
+    public:
+      typedef _ATraits 				access_traits;
+      typedef _Alloc 					allocator_type;
+      typedef typename allocator_type::size_type 	size_type;
+      typedef null_type 				metadata_type;
+      typedef Node_CItr 				node_const_iterator;
+      typedef Node_Itr 					node_iterator;
+      typedef typename node_const_iterator::value_type 	const_iterator;
+      typedef typename node_iterator::value_type 	iterator;
+      typedef typename base_type::key_type 		key_type;
+      typedef typename base_type::key_const_reference 	key_const_reference;
+
+    protected:
+      virtual const_iterator
+      end() const = 0;
+
+      virtual iterator
+      end() = 0;
+
+      virtual node_const_iterator
+      node_begin() const = 0;
+
+      virtual node_iterator
+      node_begin() = 0;
+
+      virtual node_const_iterator
+      node_end() const = 0;
+
+      virtual node_iterator
+      node_end() = 0;
+
+      virtual const access_traits&
+      get_access_traits() const = 0;
+
+    private:
+      typedef typename access_traits::const_iterator 	e_const_iterator;
+      typedef std::pair<e_const_iterator, e_const_iterator> prefix_range_t;
+
+    protected:
+      static size_type
+      common_prefix_len(node_iterator, e_const_iterator,
+			e_const_iterator, const access_traits&);
+
+      static iterator
+      leftmost_it(node_iterator);
+
+      static iterator
+      rightmost_it(node_iterator);
+
+      static bool
+      less(e_const_iterator, e_const_iterator, e_const_iterator,
+	   e_const_iterator, const access_traits&);
+    };
+
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Node_CItr, typename Node_Itr, \
+	     typename _ATraits, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+    trie_policy_base<Node_CItr, Node_Itr, _ATraits, _Alloc>
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    common_prefix_len(node_iterator nd_it, e_const_iterator b_r,
+		      e_const_iterator e_r, const access_traits& r_traits)
+    {
+      prefix_range_t pref_range = nd_it.valid_prefix();
+
+      e_const_iterator b_l = pref_range.first;
+      e_const_iterator e_l = pref_range.second;
+
+      const size_type range_length_l = std::distance(b_l, e_l);
+      const size_type range_length_r = std::distance(b_r, e_r);
+
+      if (range_length_r < range_length_l)
+	{
+	  std::swap(b_l, b_r);
+	  std::swap(e_l, e_r);
+	}
+
+      size_type ret = 0;
+      while (b_l != e_l)
+	{
+	  if (r_traits.e_pos(*b_l) != r_traits.e_pos(*b_r))
+	    return ret;
+
+	  ++ret;
+	  ++b_l;
+	  ++b_r;
+	}
+
+      return ret;
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::iterator
+    PB_DS_CLASS_C_DEC::
+    leftmost_it(node_iterator nd_it)
+    {
+      if (nd_it.num_children() == 0)
+	return *nd_it;
+
+      return leftmost_it(nd_it.get_child(0));
+    }
+
+    PB_DS_CLASS_T_DEC
+    typename PB_DS_CLASS_C_DEC::iterator
+    PB_DS_CLASS_C_DEC::
+    rightmost_it(node_iterator nd_it)
+    {
+      const size_type num_children = nd_it.num_children();
+
+      if (num_children == 0)
+	return *nd_it;
+
+      return rightmost_it(nd_it.get_child(num_children - 1));
+    }
+
+    PB_DS_CLASS_T_DEC
+    bool
+    PB_DS_CLASS_C_DEC::
+    less(e_const_iterator b_l, e_const_iterator e_l,
+	 e_const_iterator b_r, e_const_iterator e_r,
+	 const access_traits& r_traits)
+    {
+      while (b_l != e_l)
+	{
+	  if (b_r == e_r)
+	    return false;
+
+	  size_type l_pos = r_traits.e_pos(*b_l);
+	  size_type r_pos = r_traits.e_pos(*b_r);
+	  if (l_pos != r_pos)
+	    return (l_pos < r_pos);
+
+	  ++b_l;
+	  ++b_r;
+	}
+      return b_r != e_r;
+    }
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TRIE_POLICY_BASE_HPP
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/trie_string_access_traits_imp.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/trie_string_access_traits_imp.hpp
new file mode 100644
index 0000000..3a57634
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/trie_string_access_traits_imp.hpp
@@ -0,0 +1,99 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy/trie_string_access_traits_imp.hpp
+ * Contains a policy for extracting character positions from
+ *    a string for a vector-based PATRICIA tree
+ */
+
+PB_DS_CLASS_T_DEC
+detail::integral_constant<int, Reverse> PB_DS_CLASS_C_DEC::s_rev_ind;
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::size_type
+PB_DS_CLASS_C_DEC::
+e_pos(e_type e)
+{
+  return (static_cast<size_type>(e - min_e_val));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin(key_const_reference r_key)
+{
+  return (begin_imp(r_key, s_rev_ind));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end(key_const_reference r_key)
+{
+  return (end_imp(r_key, s_rev_ind));
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin_imp(key_const_reference r_key, detail::false_type)
+{
+  return (r_key.begin());
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+begin_imp(key_const_reference r_key, detail::true_type)
+{
+  return (r_key.rbegin());
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end_imp(key_const_reference r_key, detail::false_type)
+{
+  return (r_key.end());
+}
+
+PB_DS_CLASS_T_DEC
+inline typename PB_DS_CLASS_C_DEC::const_iterator
+PB_DS_CLASS_C_DEC::
+end_imp(key_const_reference r_key, detail::true_type)
+{
+  return (r_key.rend());
+}
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/type_utils.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/type_utils.hpp
new file mode 100644
index 0000000..033703c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/type_utils.hpp
@@ -0,0 +1,167 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/type_utils.hpp
+ * Contains utilities for handnling types. All of these classes are based on
+ * Modern C++ by Andrei Alxandrescu.
+ */
+
+#ifndef PB_DS_TYPE_UTILS_HPP
+#define PB_DS_TYPE_UTILS_HPP
+
+#include <cstddef>
+#include <utility>
+#include <tr1/type_traits>
+#include <ext/type_traits.h>
+#include <ext/numeric_traits.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    using std::tr1::is_same;
+    using std::tr1::is_const;
+    using std::tr1::is_pointer;
+    using std::tr1::is_reference;
+    using std::tr1::is_fundamental;
+    using std::tr1::is_member_object_pointer;
+    using std::tr1::is_member_pointer;
+    using std::tr1::is_base_of;
+    using std::tr1::remove_const;
+    using std::tr1::remove_reference;
+
+    // Need integral_const<bool, true> <-> integral_const<int, 1>, so
+    // because of this use the following typedefs instead of importing
+    // std::tr1's.
+    using std::tr1::integral_constant;
+    typedef std::tr1::integral_constant<int, 1> true_type;
+    typedef std::tr1::integral_constant<int, 0> false_type;
+
+    using __gnu_cxx::__conditional_type;
+    using __gnu_cxx::__numeric_traits;
+
+    template<typename T>
+    struct is_const_pointer
+    {
+      enum
+	{
+	  value = is_const<T>::value && is_pointer<T>::value
+	};
+    };
+
+    template<typename T>
+    struct is_const_reference
+    {
+      enum
+	{
+	  value = is_const<T>::value && is_reference<T>::value
+	};
+    };
+
+    template<typename T>
+    struct is_simple
+    {
+      enum
+	{
+	  value = is_fundamental<typename remove_const<T>::type>::value 
+	  || is_pointer<typename remove_const<T>::type>::value 
+	  || is_member_pointer<T>::value 
+	};
+    };
+
+    template<typename T>
+    class is_pair
+    {
+    private:
+      template<typename U>
+      struct is_pair_imp
+      {
+	enum
+	  {
+	    value = 0
+	  };
+      };
+
+      template<typename U, typename V>
+      struct is_pair_imp<std::pair<U,V> >
+      {
+	enum
+	  {
+	    value = 1
+	  };
+      };
+
+    public:
+      enum
+	{
+	  value = is_pair_imp<T>::value
+	};
+    };
+
+    // Use C++0x's static_assert if possible.
+#if __cplusplus >= 201103L
+#define PB_DS_STATIC_ASSERT(UNIQUE, E)  static_assert(E, #UNIQUE)
+#else
+    template<bool>
+    struct __static_assert;
+
+    template<>
+    struct __static_assert<true>
+    { };
+
+    template<int>
+    struct __static_assert_dumclass
+    {
+      enum
+	{
+	  v = 1
+	};
+    };
+
+#define PB_DS_STATIC_ASSERT(UNIQUE, E)  \
+    typedef __gnu_pbds::detail::__static_assert_dumclass<sizeof(__gnu_pbds::detail::__static_assert<bool(E)>)> UNIQUE##__static_assert_type
+
+#endif
+
+    template<typename Type>
+    struct type_to_type
+    {
+      typedef Type type;
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
new file mode 100644
index 0000000..6666d91
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
@@ -0,0 +1,288 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file detail/types_traits.hpp
+ * Contains a traits class of types used by containers.
+ */
+
+#ifndef PB_DS_TYPES_TRAITS_HPP
+#define PB_DS_TYPES_TRAITS_HPP
+
+#include <algorithm>
+#include <utility>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <utility>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    /**
+     *  @addtogroup traits Traits
+     *  @{
+     */
+
+    /// Primary template.
+    template<typename Key, typename Mapped>
+      struct no_throw_copies
+      {
+	static const bool __simple = is_simple<Key>::value
+			   	 && is_simple<Mapped>::value;
+	typedef integral_constant<int, __simple> 	       	indicator;
+      };
+
+    /// Specialization.
+    template<typename Key>
+      struct no_throw_copies<Key, null_type>
+      {
+	typedef integral_constant<int, is_simple<Key>::value> 	indicator;
+      };
+
+
+    /// Stored value.
+    template<typename _Tv>
+      struct stored_value
+      {
+	typedef _Tv 	value_type;
+	value_type 	m_value;
+      };
+
+    /// Stored hash.
+    template<typename _Th>
+      struct stored_hash
+      {
+	typedef _Th 	hash_type;
+	hash_type 	m_hash;
+      };
+
+    /// Primary template for representation of stored data.
+    /// Two types of data can be stored: value and hash.
+    template<typename _Tv, typename _Th>
+      struct stored_data
+      : public stored_value<_Tv>, public stored_hash<_Th>
+      { };
+
+    /// Specialization for representation of stored data of just value type.
+    template<typename _Tv>
+      struct stored_data<_Tv, null_type>
+      : public stored_value<_Tv>
+      { };
+
+    /// Primary template.
+    template<typename Key, typename Mapped, typename _Alloc, bool Store_Hash>
+      struct type_base;
+
+    /**
+     * Specialization of type_base for the case where the hash value
+     * is not stored alongside each value.
+     */
+    template<typename Key, typename Mapped, typename _Alloc>
+      struct type_base<Key, Mapped, _Alloc, false>
+      {
+      public:
+	typedef typename _Alloc::size_type 		size_type;
+
+      private:
+	typedef typename _Alloc::template rebind<Mapped>	__rebind_m;
+	typedef typename __rebind_m::other			__rebind_ma;
+	typedef std::pair<const Key, Mapped>			__value_type;
+	typedef typename _Alloc::template rebind<__value_type>	__rebind_v;
+       	typedef typename __rebind_v::other			__rebind_va;
+
+      public:
+	typedef typename __rebind_ma::value_type       	mapped_type;
+	typedef typename __rebind_ma::pointer 		mapped_pointer;
+	typedef typename __rebind_ma::const_pointer 	mapped_const_pointer;
+	typedef typename __rebind_ma::reference	       	mapped_reference;
+	typedef typename __rebind_ma::const_reference 	mapped_const_reference;
+
+	typedef typename __rebind_va::value_type 	value_type;
+	typedef typename __rebind_va::pointer 		pointer;
+	typedef typename __rebind_va::const_pointer 	const_pointer;
+	typedef typename __rebind_va::reference 	reference;
+	typedef typename __rebind_va::const_reference 	const_reference;
+
+	typedef stored_data<value_type, null_type>	stored_data_type;
+      };
+
+    /**
+     * Specialization of type_base for the case where the hash value
+     * is stored alongside each value.
+     */
+    template<typename Key, typename Mapped, typename _Alloc>
+      struct type_base<Key, Mapped, _Alloc, true>
+      {
+      public:
+	typedef typename _Alloc::size_type 		size_type;
+
+      private:
+	typedef typename _Alloc::template rebind<Mapped>	__rebind_m;
+	typedef typename __rebind_m::other			__rebind_ma;
+	typedef std::pair<const Key, Mapped>			__value_type;
+	typedef typename _Alloc::template rebind<__value_type>	__rebind_v;
+       	typedef typename __rebind_v::other			__rebind_va;
+
+      public:
+	typedef typename __rebind_ma::value_type       	mapped_type;
+	typedef typename __rebind_ma::pointer 		mapped_pointer;
+	typedef typename __rebind_ma::const_pointer 	mapped_const_pointer;
+	typedef typename __rebind_ma::reference	       	mapped_reference;
+	typedef typename __rebind_ma::const_reference 	mapped_const_reference;
+
+	typedef typename __rebind_va::value_type 	value_type;
+	typedef typename __rebind_va::pointer 		pointer;
+	typedef typename __rebind_va::const_pointer 	const_pointer;
+	typedef typename __rebind_va::reference 	reference;
+	typedef typename __rebind_va::const_reference 	const_reference;
+
+	typedef stored_data<value_type, size_type>	stored_data_type;
+      };
+
+
+    /**
+     * Specialization of type_base for the case where the hash value
+     * is not stored alongside each value.
+     */
+    template<typename Key, typename _Alloc>
+      struct type_base<Key, null_type, _Alloc, false>
+      {
+      public:
+	typedef typename _Alloc::size_type 		size_type;
+	typedef Key 					value_type;
+
+      private:
+	typedef typename _Alloc::template rebind<null_type>  	__rebind_m;
+	typedef typename __rebind_m::other			__rebind_ma;
+	typedef typename _Alloc::template rebind<value_type>	__rebind_v;
+       	typedef typename __rebind_v::other			__rebind_va;
+
+      public:
+	typedef typename __rebind_ma::value_type       	mapped_type;
+	typedef typename __rebind_ma::pointer 		mapped_pointer;
+	typedef typename __rebind_ma::const_pointer 	mapped_const_pointer;
+	typedef typename __rebind_ma::reference	       	mapped_reference;
+	typedef typename __rebind_ma::const_reference 	mapped_const_reference;
+
+	typedef typename __rebind_va::pointer 		pointer;
+	typedef typename __rebind_va::const_pointer 	const_pointer;
+	typedef typename __rebind_va::reference 	reference;
+	typedef typename __rebind_va::const_reference 	const_reference;
+
+	typedef stored_data<value_type, null_type>	stored_data_type;
+
+	static null_type 			s_null_type;
+      };
+
+    template<typename Key, typename _Alloc>
+      null_type
+      type_base<Key, null_type, _Alloc, false>::s_null_type;
+
+
+    /**
+     * Specialization of type_base for the case where the hash value
+     * is stored alongside each value.
+     */
+    template<typename Key, typename _Alloc>
+      struct type_base<Key, null_type, _Alloc, true>
+      {
+      public:
+	typedef typename _Alloc::size_type 		size_type;
+	typedef Key 					value_type;
+
+      private:
+	typedef typename _Alloc::template rebind<null_type>  	__rebind_m;
+	typedef typename __rebind_m::other			__rebind_ma;
+	typedef typename _Alloc::template rebind<value_type>	__rebind_v;
+       	typedef typename __rebind_v::other			__rebind_va;
+
+      public:
+	typedef typename __rebind_ma::value_type       	mapped_type;
+	typedef typename __rebind_ma::pointer 		mapped_pointer;
+	typedef typename __rebind_ma::const_pointer 	mapped_const_pointer;
+	typedef typename __rebind_ma::reference	       	mapped_reference;
+	typedef typename __rebind_ma::const_reference 	mapped_const_reference;
+
+	typedef typename __rebind_va::pointer 		pointer;
+	typedef typename __rebind_va::const_pointer 	const_pointer;
+	typedef typename __rebind_va::reference 	reference;
+	typedef typename __rebind_va::const_reference 	const_reference;
+
+	typedef stored_data<value_type, size_type>	stored_data_type;
+
+	static null_type 		      	s_null_type;
+      };
+
+    template<typename Key, typename _Alloc>
+      null_type
+      type_base<Key, null_type, _Alloc, true>::s_null_type;
+
+
+    /// Type base dispatch.
+    template<typename Key, typename Mapped, typename _Alloc, bool Store_Hash>
+      struct type_dispatch
+      {
+	typedef type_base<Key, Mapped, _Alloc, Store_Hash> type;
+      };
+
+    /// Traits for abstract types.
+    template<typename Key, typename Mapped, typename _Alloc, bool Store_Hash>
+      struct types_traits
+      : public type_dispatch<Key, Mapped, _Alloc, Store_Hash>::type
+      {
+      private:
+	typedef no_throw_copies<Key, Mapped>		__nothrowcopy;
+	typedef typename _Alloc::template rebind<Key>::other __rebind_a;
+
+      public:
+	typedef typename _Alloc::size_type 		size_type;
+	typedef typename __rebind_a::value_type 	key_type;
+	typedef typename __rebind_a::pointer 		key_pointer;
+	typedef typename __rebind_a::const_pointer 	key_const_pointer;
+	typedef typename __rebind_a::reference 		key_reference;
+	typedef typename __rebind_a::const_reference 	key_const_reference;
+	typedef std::pair<size_type, size_type> 	comp_hash;
+	typedef integral_constant<int, Store_Hash> 	store_extra;
+	typedef typename __nothrowcopy::indicator 	no_throw_indicator;
+
+	store_extra			       	m_store_extra_indicator;
+	no_throw_indicator 		 	m_no_throw_copies_indicator;
+    };
+    //@}
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp
new file mode 100644
index 0000000..8c02e88
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file unordered_iterator/const_iterator.hpp
+ * Contains an iterator class used for const ranging over the elements of the
+ * table.
+ */
+
+/// Const range-type iterator.
+class const_iterator_
+: public point_const_iterator_
+{
+public:
+  /// Category.
+  typedef std::forward_iterator_tag iterator_category;
+
+  /// Difference type.
+  typedef typename _Alloc::difference_type difference_type;
+
+  /// Iterator's value type.
+  typedef value_type_ value_type;
+
+  /// Iterator's pointer type.
+  typedef pointer_ pointer;
+
+  /// Iterator's const pointer type.
+  typedef const_pointer_ const_pointer;
+
+  /// Iterator's reference type.
+  typedef reference_ reference;
+
+  /// Iterator's const reference type.
+  typedef const_reference_ const_reference;
+
+  /// Default constructor.
+  const_iterator_() : m_p_tbl(0)
+  { }
+
+  /// Increments.
+  const_iterator_&
+  operator++()
+  {
+    m_p_tbl->inc_it_state(base_type::m_p_value, m_pos);
+    return *this;
+  }
+
+  /// Increments.
+  const_iterator_
+  operator++(int)
+  {
+    const_iterator_ ret =* this;
+    m_p_tbl->inc_it_state(base_type::m_p_value, m_pos);
+    return ret;
+  }
+
+protected:
+  typedef point_const_iterator_ base_type;
+
+  /**
+   *  Constructor used by the table to initiate the generalized
+   *      pointer and position (e.g., this is called from within a find()
+   *      of a table.
+   * */
+  const_iterator_(const_pointer_ p_value,  PB_DS_GEN_POS pos,
+		  const PB_DS_CLASS_C_DEC* p_tbl)
+  : point_const_iterator_(p_value), m_p_tbl(p_tbl), m_pos(pos)
+  { }
+
+  /**
+   *  Pointer to the table object which created the iterator (used for
+   *      incrementing its position.
+   * */
+  const PB_DS_CLASS_C_DEC* m_p_tbl;
+
+  PB_DS_GEN_POS m_pos;
+
+  friend class PB_DS_CLASS_C_DEC;
+};
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp
new file mode 100644
index 0000000..464fbb5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp
@@ -0,0 +1,130 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file iterator.hpp
+ * Contains an iterator_ class used for ranging over the elements of the
+ *    table.
+ */
+
+/// Range-type iterator.
+class iterator_
+: public const_iterator_
+{
+public:
+  /// Category.
+  typedef std::forward_iterator_tag iterator_category;
+
+  /// Difference type.
+  typedef typename _Alloc::difference_type difference_type;
+
+  /// Iterator's value type.
+  typedef value_type_ value_type;
+
+  /// Iterator's pointer type.
+  typedef pointer_ pointer;
+
+  /// Iterator's const pointer type.
+  typedef const_pointer_ const_pointer;
+
+  /// Iterator's reference type.
+  typedef reference_ reference;
+
+  /// Iterator's const reference type.
+  typedef const_reference_ const_reference;
+
+  /// Default constructor.
+  inline
+  iterator_()
+  : const_iterator_(0, PB_DS_GEN_POS(), 0) { }
+
+  /// Conversion to a point-type iterator.
+  inline
+  operator point_iterator_()
+  { return point_iterator_(const_cast<pointer>(const_iterator_::m_p_value)); }
+
+  /// Conversion to a point-type iterator.
+  inline
+  operator const point_iterator_() const
+  { return point_iterator_(const_cast<pointer>(const_iterator_::m_p_value)); }
+
+  /// Access.
+  pointer
+  operator->() const
+  {
+    _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != 0);
+    return (const_cast<pointer>(base_type::m_p_value));
+  }
+
+  /// Access.
+  reference
+  operator*() const
+  {
+    _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != 0);
+    return (const_cast<reference>(*base_type::m_p_value));
+  }
+
+  /// Increments.
+  iterator_&
+  operator++()
+  {
+    base_type::m_p_tbl->inc_it_state(base_type::m_p_value, base_type::m_pos);
+    return *this;
+  }
+
+  /// Increments.
+  iterator_
+  operator++(int)
+  {
+    iterator_ ret =* this;
+    base_type::m_p_tbl->inc_it_state(base_type::m_p_value, base_type::m_pos);
+    return ret;
+  }
+
+protected:
+  typedef const_iterator_ base_type;
+
+  /**
+   *  Constructor used by the table to initiate the generalized
+   *      pointer and position (e.g., this is called from within a find()
+   *      of a table.
+   * */
+  inline
+  iterator_(pointer p_value, PB_DS_GEN_POS pos, PB_DS_CLASS_C_DEC* p_tbl)
+  : const_iterator_(p_value, pos, p_tbl)
+  { }
+
+  friend class PB_DS_CLASS_C_DEC;
+};
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp
new file mode 100644
index 0000000..4ea6bc1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_const_iterator.hpp
@@ -0,0 +1,133 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file unordered_iterator/point_const_iterator.hpp
+ * Contains an iterator class returned by the tables' const find and insert
+ *     methods.
+ */
+
+class point_iterator_;
+
+/// Const point-type iterator.
+class point_const_iterator_
+{
+public:
+  /// Category.
+  typedef trivial_iterator_tag iterator_category;
+
+  /// Difference type.
+  typedef trivial_iterator_difference_type difference_type;
+
+  /// Iterator's value type.
+  typedef value_type_ value_type;
+
+  /// Iterator's pointer type.
+  typedef pointer_ pointer;
+
+  /// Iterator's const pointer type.
+  typedef const_pointer_ const_pointer;
+
+  /// Iterator's reference type.
+  typedef reference_ reference;
+
+  /// Iterator's const reference type.
+  typedef const_reference_ const_reference;
+
+  inline
+  point_const_iterator_(const_pointer p_value) : m_p_value(p_value)
+  { }
+
+  /// Default constructor.
+  inline
+  point_const_iterator_() : m_p_value(0)
+  { }
+
+  /// Copy constructor.
+  inline
+  point_const_iterator_(const point_const_iterator_& other)
+  : m_p_value(other.m_p_value)
+  { }
+
+  /// Copy constructor.
+  inline
+  point_const_iterator_(const point_iterator_& other)
+  : m_p_value(other.m_p_value)
+  { }
+
+  /// Access.
+  const_pointer
+  operator->() const
+  {
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
+    return m_p_value;
+  }
+
+  /// Access.
+  const_reference
+  operator*() const
+  {
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
+    return *m_p_value;
+  }
+
+  /// Compares content to a different iterator object.
+  bool
+  operator==(const point_iterator_& other) const
+  { return m_p_value == other.m_p_value; }
+
+  /// Compares content to a different iterator object.
+  bool
+  operator==(const point_const_iterator_& other) const
+  { return m_p_value == other.m_p_value; }
+
+  /// Compares content (negatively) to a different iterator object.
+  bool
+  operator!=(const point_iterator_& other) const
+  { return m_p_value != other.m_p_value; }
+
+  /// Compares content (negatively) to a different iterator object.
+  bool
+  operator!=(const point_const_iterator_& other) const
+  { return m_p_value != other.m_p_value; }
+
+protected:
+  const_pointer m_p_value;
+
+  friend class point_iterator_;
+
+  friend class PB_DS_CLASS_C_DEC;
+};
+
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp
new file mode 100644
index 0000000..c4d915b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp
@@ -0,0 +1,126 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file point_iterator.hpp
+ * Contains an iterator class returned by the tables' find and insert
+ *     methods.
+ */
+
+/// Find type iterator.
+class point_iterator_
+{
+public:
+  /// Category.
+  typedef trivial_iterator_tag iterator_category;
+
+  /// Difference type.
+  typedef trivial_iterator_difference_type difference_type;
+
+  /// Iterator's value type.
+  typedef value_type_ value_type;
+
+  /// Iterator's pointer type.
+  typedef pointer_ pointer;
+
+  /// Iterator's const pointer type.
+  typedef const_pointer_ const_pointer;
+
+  /// Iterator's reference type.
+  typedef reference_ reference;
+
+  /// Iterator's const reference type.
+  typedef const_reference_ const_reference;
+
+  /// Default constructor.
+  inline
+  point_iterator_()
+  : m_p_value(0)
+  { }
+
+  /// Copy constructor.
+  inline
+  point_iterator_(const point_iterator_& other)
+  : m_p_value(other.m_p_value)
+  { }
+
+  /// Access.
+  pointer
+  operator->() const
+  {
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
+    return (m_p_value);
+  }
+
+  /// Access.
+  reference
+  operator*() const
+  {
+    _GLIBCXX_DEBUG_ASSERT(m_p_value != 0);
+    return (*m_p_value);
+  }
+
+  /// Compares content to a different iterator object.
+  bool
+  operator==(const point_iterator_& other) const
+  { return m_p_value == other.m_p_value; }
+
+  /// Compares content to a different iterator object.
+  bool
+  operator==(const point_const_iterator_& other) const
+  { return m_p_value == other.m_p_value; }
+
+  /// Compares content to a different iterator object.
+  bool
+  operator!=(const point_iterator_& other) const
+  { return m_p_value != other.m_p_value; }
+
+  /// Compares content (negatively) to a different iterator object.
+  bool
+  operator!=(const point_const_iterator_& other) const
+  { return m_p_value != other.m_p_value; }
+
+  inline
+  point_iterator_(pointer p_value) : m_p_value(p_value)
+  { }
+
+protected:
+  friend class point_const_iterator_;
+
+  friend class PB_DS_CLASS_C_DEC;
+
+protected:
+  pointer m_p_value;
+};
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/exception.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/exception.hpp
new file mode 100644
index 0000000..a42b735
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/exception.hpp
@@ -0,0 +1,93 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file exception.hpp
+ * Contains exception classes.
+ */
+
+#ifndef PB_DS_EXCEPTION_HPP
+#define PB_DS_EXCEPTION_HPP
+
+#include <bits/c++config.h>
+#include <stdexcept>
+#include <cstdlib>
+
+namespace __gnu_pbds
+{
+  /**
+   *  @defgroup exceptions-pbds Exceptions
+   *  @ingroup pbds
+   *  @{
+   */
+
+  /// Base class for exceptions.
+  struct container_error : public std::logic_error
+  {
+    container_error()
+    : std::logic_error(__N("__gnu_pbds::container_error")) { }
+  };
+
+  /// An entry cannot be inserted into a container object for logical
+  /// reasons (not, e.g., if memory is unabvailable, in which case
+  /// the allocator_type's exception will be thrown).
+  struct insert_error : public container_error { };
+
+  /// A join cannot be performed logical reasons (i.e., the ranges of
+  /// the two container objects being joined overlaps.
+  struct join_error : public container_error { };
+
+  /// A container cannot be resized.
+  struct resize_error : public container_error { };
+
+  inline void
+  __throw_container_error()
+  { _GLIBCXX_THROW_OR_ABORT(container_error()); }
+
+  inline void
+  __throw_insert_error()
+  { _GLIBCXX_THROW_OR_ABORT(insert_error()); }
+
+  inline void
+  __throw_join_error()
+  { _GLIBCXX_THROW_OR_ABORT(join_error()); }
+
+  inline void
+  __throw_resize_error()
+  { _GLIBCXX_THROW_OR_ABORT(resize_error()); }
+  //@}
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/hash_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/hash_policy.hpp
new file mode 100644
index 0000000..c8f9af6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/hash_policy.hpp
@@ -0,0 +1,617 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_policy.hpp
+ * Contains hash-related policies.
+ */
+
+#ifndef PB_DS_HASH_POLICY_HPP
+#define PB_DS_HASH_POLICY_HPP
+
+#include <bits/c++config.h>
+#include <algorithm>
+#include <vector>
+#include <cmath>
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp>
+#include <ext/pb_ds/detail/hash_fn/mod_based_range_hashing.hpp>
+#include <ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp>
+
+namespace __gnu_pbds
+{
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC linear_probe_fn<Size_Type>
+
+  /// A probe sequence policy using fixed increments.
+  template<typename Size_Type = std::size_t>
+  class linear_probe_fn
+  {
+  public:
+    typedef Size_Type size_type;
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    /// Returns the i-th offset from the hash value.
+    inline size_type
+    operator()(size_type i) const;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/linear_probe_fn_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC quadratic_probe_fn<Size_Type>
+
+  /// A probe sequence policy using square increments.
+  template<typename Size_Type = std::size_t>
+  class quadratic_probe_fn
+  {
+  public:
+    typedef Size_Type size_type;
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    /// Returns the i-th offset from the hash value.
+    inline size_type
+    operator()(size_type i) const;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/quadratic_probe_fn_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC direct_mask_range_hashing<Size_Type>
+
+  /// A mask range-hashing class (uses a bitmask).
+  template<typename Size_Type = std::size_t>
+  class direct_mask_range_hashing
+  : public detail::mask_based_range_hashing<Size_Type>
+  {
+  private:
+    typedef detail::mask_based_range_hashing<Size_Type> mask_based_base;
+
+  public:
+    typedef Size_Type size_type;
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    void
+    notify_resized(size_type size);
+
+    /// Transforms the __hash value hash into a ranged-hash value
+    /// (using a bit-mask).
+    inline size_type
+    operator()(size_type hash) const;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC direct_mod_range_hashing<Size_Type>
+
+  /// A mod range-hashing class (uses the modulo function).
+  template<typename Size_Type = std::size_t>
+  class direct_mod_range_hashing
+  : public detail::mod_based_range_hashing<Size_Type>
+  {
+  public:
+    typedef Size_Type size_type;
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    void
+    notify_resized(size_type size);
+
+    /// Transforms the __hash value hash into a ranged-hash value
+    /// (using a modulo operation).
+    inline size_type
+    operator()(size_type hash) const;
+
+  private:
+    typedef detail::mod_based_range_hashing<size_type> mod_based_base;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<bool External_Load_Access, typename Size_Type>
+#define PB_DS_CLASS_C_DEC hash_load_check_resize_trigger<External_Load_Access, Size_Type>
+#define PB_DS_SIZE_BASE_C_DEC detail::hash_load_check_resize_trigger_size_base<Size_Type, External_Load_Access>
+
+  /// A resize trigger policy based on a load check. It keeps the
+  /// load factor between some load factors load_min and load_max.
+  template<bool External_Load_Access = false, typename Size_Type = std::size_t>
+  class hash_load_check_resize_trigger : private PB_DS_SIZE_BASE_C_DEC
+  {
+  public:
+    typedef Size_Type size_type;
+
+    enum
+      {
+	/// Specifies whether the load factor can be accessed
+	/// externally. The two options have different trade-offs in
+	/// terms of flexibility, genericity, and encapsulation.
+	external_load_access = External_Load_Access
+      };
+
+    /// Default constructor, or constructor taking load_min and
+    /// load_max load factors between which this policy will keep the
+    /// actual load.
+    hash_load_check_resize_trigger(float load_min = 0.125,
+				   float load_max = 0.5);
+
+    void
+    swap(hash_load_check_resize_trigger& other);
+
+    virtual
+    ~hash_load_check_resize_trigger();
+
+    /// Returns a pair of the minimal and maximal loads, respectively.
+    inline std::pair<float, float>
+    get_loads() const;
+
+    /// Sets the loads through a pair of the minimal and maximal
+    /// loads, respectively.
+    void
+    set_loads(std::pair<float, float> load_pair);
+
+  protected:
+    inline void
+    notify_insert_search_start();
+
+    inline void
+    notify_insert_search_collision();
+
+    inline void
+    notify_insert_search_end();
+
+    inline void
+    notify_find_search_start();
+
+    inline void
+    notify_find_search_collision();
+
+    inline void
+    notify_find_search_end();
+
+    inline void
+    notify_erase_search_start();
+
+    inline void
+    notify_erase_search_collision();
+
+    inline void
+    notify_erase_search_end();
+
+    /// Notifies an element was inserted. The total number of entries
+    /// in the table is num_entries.
+    inline void
+    notify_inserted(size_type num_entries);
+
+    inline void
+    notify_erased(size_type num_entries);
+
+    /// Notifies the table was cleared.
+    void
+    notify_cleared();
+
+    /// Notifies the table was resized as a result of this object's
+    /// signifying that a resize is needed.
+    void
+    notify_resized(size_type new_size);
+
+    void
+    notify_externally_resized(size_type new_size);
+
+    inline bool
+    is_resize_needed() const;
+
+    inline bool
+    is_grow_needed(size_type size, size_type num_entries) const;
+
+  private:
+    virtual void
+    do_resize(size_type new_size);
+
+    typedef PB_DS_SIZE_BASE_C_DEC size_base;
+
+#ifdef _GLIBCXX_DEBUG
+    void
+    assert_valid(const char* file, int line) const;
+#endif
+
+    float 	m_load_min;
+    float 	m_load_max;
+    size_type 	m_next_shrink_size;
+    size_type 	m_next_grow_size;
+    bool 	m_resize_needed;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_SIZE_BASE_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<bool External_Load_Access, typename Size_Type>
+#define PB_DS_CLASS_C_DEC cc_hash_max_collision_check_resize_trigger<External_Load_Access, Size_Type>
+
+  /// A resize trigger policy based on collision checks. It keeps the
+  /// simulated load factor lower than some given load factor.
+  template<bool External_Load_Access = false, typename Size_Type = std::size_t>
+  class cc_hash_max_collision_check_resize_trigger
+  {
+  public:
+    typedef Size_Type 	size_type;
+
+    enum
+      {
+	/// Specifies whether the load factor can be accessed
+	/// externally. The two options have different trade-offs in
+	/// terms of flexibility, genericity, and encapsulation.
+	external_load_access = External_Load_Access
+      };
+
+    /// Default constructor, or constructor taking load, a __load
+    /// factor which it will attempt to maintain.
+    cc_hash_max_collision_check_resize_trigger(float load = 0.5);
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+    /// Returns the current load.
+    inline float
+    get_load() const;
+
+    /// Sets the load; does not resize the container.
+    void
+    set_load(float load);
+
+  protected:
+    /// Notifies an insert search started.
+    inline void
+    notify_insert_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_insert_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_insert_search_end();
+
+    /// Notifies a find search started.
+    inline void
+    notify_find_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_find_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_find_search_end();
+
+    /// Notifies an erase search started.
+    inline void
+    notify_erase_search_start();
+
+    /// Notifies a search encountered a collision.
+    inline void
+    notify_erase_search_collision();
+
+    /// Notifies a search ended.
+    inline void
+    notify_erase_search_end();
+
+    /// Notifies an element was inserted.
+    inline void
+    notify_inserted(size_type num_entries);
+
+    /// Notifies an element was erased.
+    inline void
+    notify_erased(size_type num_entries);
+
+    /// Notifies the table was cleared.
+    void
+    notify_cleared();
+
+    /// Notifies the table was resized as a result of this object's
+    /// signifying that a resize is needed.
+    void
+    notify_resized(size_type new_size);
+
+    /// Notifies the table was resized externally.
+    void
+    notify_externally_resized(size_type new_size);
+
+    /// Queries whether a resize is needed.
+    inline bool
+    is_resize_needed() const;
+
+    /// Queries whether a grow is needed. This method is called only
+    /// if this object indicated is needed.
+    inline bool
+    is_grow_needed(size_type size, size_type num_entries) const;
+
+  private:
+    void
+    calc_max_num_coll();
+
+    inline void
+    calc_resize_needed();
+
+    float 	m_load;
+    size_type 	m_size;
+    size_type 	m_num_col;
+    size_type 	m_max_col;
+    bool 	m_resize_needed;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC hash_exponential_size_policy<Size_Type>
+
+  /// A size policy whose sequence of sizes form an exponential
+  /// sequence (typically powers of 2.
+  template<typename Size_Type = std::size_t>
+  class hash_exponential_size_policy
+  {
+  public:
+    typedef Size_Type size_type;
+
+    /// Default constructor, or onstructor taking a start_size, or
+    /// constructor taking a start size and grow_factor. The policy
+    /// will use the sequence of sizes start_size, start_size*
+    /// grow_factor, start_size* grow_factor^2, ...
+    hash_exponential_size_policy(size_type start_size = 8,
+				 size_type grow_factor = 2);
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    size_type
+    get_nearest_larger_size(size_type size) const;
+
+    size_type
+    get_nearest_smaller_size(size_type size) const;
+
+  private:
+    size_type m_start_size;
+    size_type m_grow_factor;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_exponential_size_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC
+#define PB_DS_CLASS_C_DEC hash_prime_size_policy
+
+  /// A size policy whose sequence of sizes form a nearly-exponential
+  /// sequence of primes.
+  class hash_prime_size_policy
+  {
+  public:
+    /// Size type.
+    typedef std::size_t size_type;
+
+    /// Default constructor, or onstructor taking a start_size The
+    /// policy will use the sequence of sizes approximately
+    /// start_size, start_size* 2, start_size* 2^2, ...
+    hash_prime_size_policy(size_type start_size = 8);
+
+    inline void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    size_type
+    get_nearest_larger_size(size_type size) const;
+
+    size_type
+    get_nearest_smaller_size(size_type size) const;
+
+  private:
+    size_type m_start_size;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Policy, typename Trigger_Policy, bool External_Size_Access, typename Size_Type>
+
+#define PB_DS_CLASS_C_DEC hash_standard_resize_policy<Size_Policy, Trigger_Policy, External_Size_Access, Size_Type>
+
+  /// A resize policy which delegates operations to size and trigger policies.
+  template<typename Size_Policy = hash_exponential_size_policy<>,
+	   typename Trigger_Policy = hash_load_check_resize_trigger<>,
+	   bool External_Size_Access = false,
+	   typename Size_Type = std::size_t>
+  class hash_standard_resize_policy
+  : public Size_Policy, public Trigger_Policy
+  {
+  public:
+    typedef Size_Type 		size_type;
+    typedef Trigger_Policy 	trigger_policy;
+    typedef Size_Policy 	size_policy;
+
+    enum
+      {
+	external_size_access = External_Size_Access
+      };
+
+    /// Default constructor.
+    hash_standard_resize_policy();
+
+    /// constructor taking some policies r_size_policy will be copied
+    /// by the Size_Policy object of this object.
+    hash_standard_resize_policy(const Size_Policy& r_size_policy);
+
+    /// constructor taking some policies. r_size_policy will be
+    /// copied by the Size_Policy object of this
+    /// object. r_trigger_policy will be copied by the Trigger_Policy
+    /// object of this object.
+    hash_standard_resize_policy(const Size_Policy& r_size_policy,
+				const Trigger_Policy& r_trigger_policy);
+
+    virtual
+    ~hash_standard_resize_policy();
+
+    inline void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+    /// Access to the Size_Policy object used.
+    Size_Policy&
+    get_size_policy();
+
+    /// Const access to the Size_Policy object used.
+    const Size_Policy&
+    get_size_policy() const;
+
+    /// Access to the Trigger_Policy object used.
+    Trigger_Policy&
+    get_trigger_policy();
+
+    /// Access to the Trigger_Policy object used.
+    const Trigger_Policy&
+    get_trigger_policy() const;
+
+    /// Returns the actual size of the container.
+    inline size_type
+    get_actual_size() const;
+
+    /// Resizes the container to suggested_new_size, a suggested size
+    /// (the actual size will be determined by the Size_Policy
+    /// object).
+    void
+    resize(size_type suggested_new_size);
+
+  protected:
+    inline void
+    notify_insert_search_start();
+
+    inline void
+    notify_insert_search_collision();
+
+    inline void
+    notify_insert_search_end();
+
+    inline void
+    notify_find_search_start();
+
+    inline void
+    notify_find_search_collision();
+
+    inline void
+    notify_find_search_end();
+
+    inline void
+    notify_erase_search_start();
+
+    inline void
+    notify_erase_search_collision();
+
+    inline void
+    notify_erase_search_end();
+
+    inline void
+    notify_inserted(size_type num_e);
+
+    inline void
+    notify_erased(size_type num_e);
+
+    void
+    notify_cleared();
+
+    void
+    notify_resized(size_type new_size);
+
+    inline bool
+    is_resize_needed() const;
+
+    /// Queries what the new size should be, when the container is
+    /// resized naturally. The current __size of the container is
+    /// size, and the number of used entries within the container is
+    /// num_used_e.
+    size_type
+    get_new_size(size_type size, size_type num_used_e) const;
+
+  private:
+    /// Resizes to new_size.
+    virtual void
+    do_resize(size_type new_size);
+
+    typedef Trigger_Policy trigger_policy_base;
+
+    typedef Size_Policy size_policy_base;
+
+    size_type m_size;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp
new file mode 100644
index 0000000..1cc8144
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp
@@ -0,0 +1,130 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_policy.hpp
+ * Contains policies for list update containers.
+ */
+
+#ifndef PB_DS_LU_POLICY_HPP
+#define PB_DS_LU_POLICY_HPP
+
+#include <bits/c++config.h>
+#include <cstdlib>
+#include <ext/pb_ds/detail/list_update_policy/lu_counter_metadata.hpp>
+#include <ext/pb_ds/tag_and_trait.hpp>
+
+namespace __gnu_pbds
+{
+  /**
+   *  A list-update policy that unconditionally moves elements to the
+   *  front of the list. A null type means that each link in a
+   *  list-based container does not actually need metadata.
+   */
+ template<typename _Alloc = std::allocator<char> >
+   class lu_move_to_front_policy
+   {
+   public:
+     typedef _Alloc 					allocator_type;
+
+     /// Metadata on which this functor operates.
+     typedef null_type 					metadata_type;
+
+   private:
+     typedef typename _Alloc::template rebind<metadata_type> __rebind_m;
+
+   public:
+     /// Reference to metadata on which this functor operates.
+     typedef typename __rebind_m::other::reference 	metadata_reference;
+
+     /// Creates a metadata object.
+     metadata_type
+     operator()() const
+     { return s_metadata; }
+
+     /// Decides whether a metadata object should be moved to the front
+     /// of the list.
+     inline bool
+     operator()(metadata_reference r_metadata) const
+     { return true; }
+
+   private:
+     static null_type 					s_metadata;
+   };
+
+  /**
+   *  A list-update policy that moves elements to the front of the
+   *  list based on the counter algorithm.
+   */
+  template<std::size_t Max_Count = 5, typename _Alloc = std::allocator<char> >
+    class lu_counter_policy
+    : private detail::lu_counter_policy_base<typename _Alloc::size_type>
+    {
+    public:
+      typedef _Alloc 					allocator_type;
+      typedef typename allocator_type::size_type       	size_type;
+
+      enum
+	{
+	  /// When some element is accessed this number of times, it
+	  /// will be moved to the front of the list.
+	  max_count = Max_Count
+	};
+
+      /// Metadata on which this functor operates.
+      typedef detail::lu_counter_metadata<size_type> 	metadata_type;
+
+    private:
+      typedef detail::lu_counter_policy_base<size_type> 	base_type;
+      typedef typename _Alloc::template rebind<metadata_type> __rebind_m;
+
+    public:
+      /// Reference to metadata on which this functor operates.
+      typedef typename __rebind_m::other::reference 	metadata_reference;
+
+      /// Creates a metadata object.
+      metadata_type
+      operator()() const
+      { return base_type::operator()(max_count); }
+
+      /// Decides whether a metadata object should be moved to the front
+      /// of the list.
+      bool
+      operator()(metadata_reference r_data) const
+      { return base_type::operator()(r_data, max_count); }
+    };
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/priority_queue.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/priority_queue.hpp
new file mode 100644
index 0000000..83475bb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/priority_queue.hpp
@@ -0,0 +1,157 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file priority_queue.hpp
+ * Contains priority_queues.
+ */
+
+#ifndef PB_DS_PRIORITY_QUEUE_HPP
+#define PB_DS_PRIORITY_QUEUE_HPP
+
+#include <bits/c++config.h>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/priority_queue_base_dispatch.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+
+namespace __gnu_pbds
+{
+  /**
+   *  @defgroup heap-based Heap-Based
+   *  @ingroup containers-pbds
+   *  @{
+   */
+
+  /**
+   *  @defgroup heap-detail Base and Policy Classes
+   *  @ingroup heap-based
+   */
+
+  /**
+   *  A priority queue composed of one specific heap policy.
+   *
+   *  @tparam _Tv 	    	Value type.
+   *  @tparam Cmp_Fn	    	Comparison functor.
+   *  @tparam Tag 	    	Instantiating data structure type,
+   *			    	see container_tag.
+   *  @tparam _Alloc 	    	Allocator type.
+   *
+   *  Base is dispatched at compile time via Tag, from the following
+   *  choices: binary_heap_tag, binomial_heap_tag, pairing_heap_tag,
+   *           rc_binomial_heap_tag, thin_heap_tag
+   *
+   *  Base choices are: detail::binary_heap, detail::binomial_heap,
+   *                    detail::pairing_heap, detail::rc_binomial_heap,
+   *                    detail::thin_heap.
+   */
+   template<typename _Tv,
+	   typename Cmp_Fn = std::less<_Tv>,
+	   typename Tag = pairing_heap_tag,
+	   typename _Alloc = std::allocator<char> >
+  class priority_queue
+  : public detail::container_base_dispatch<_Tv, Cmp_Fn, _Alloc, Tag>::type
+  {
+  public:
+    typedef _Tv 					value_type;
+    typedef Cmp_Fn 					cmp_fn;
+    typedef Tag 					container_category;
+    typedef _Alloc 					allocator_type;
+    typedef typename allocator_type::size_type 		size_type;
+    typedef typename allocator_type::difference_type 	difference_type;
+
+  private:
+    typedef typename detail::container_base_dispatch<_Tv, Cmp_Fn, _Alloc,
+						     Tag>::type
+ 							base_type;
+    typedef typename _Alloc::template rebind<_Tv>   	__rebind_v;
+    typedef typename __rebind_v::other			__rebind_va;
+
+ public:
+    typedef typename __rebind_va::reference 		reference;
+    typedef typename __rebind_va::const_reference 	const_reference;
+    typedef typename __rebind_va::pointer 	   	pointer;
+    typedef typename __rebind_va::const_pointer 	const_pointer;
+
+    typedef typename base_type::point_iterator 		point_iterator;
+    typedef typename base_type::point_const_iterator 	point_const_iterator;
+    typedef typename base_type::iterator 		iterator;
+    typedef typename base_type::const_iterator 		const_iterator;
+
+    priority_queue() { }
+
+    /// Constructor taking some policy objects. r_cmp_fn will be
+    /// copied by the Cmp_Fn object of the container object.
+    priority_queue(const cmp_fn& r_cmp_fn) : base_type(r_cmp_fn) { }
+
+    /// Constructor taking __iterators to a range of value_types. The
+    /// value_types between first_it and last_it will be inserted into
+    /// the container object.
+    template<typename It>
+    priority_queue(It first_it, It last_it)
+    { base_type::copy_from_range(first_it, last_it); }
+
+    /// Constructor taking __iterators to a range of value_types and
+    /// some policy objects The value_types between first_it and
+    /// last_it will be inserted into the container object. r_cmp_fn
+    /// will be copied by the cmp_fn object of the container object.
+    template<typename It>
+    priority_queue(It first_it, It last_it, const cmp_fn& r_cmp_fn)
+    : base_type(r_cmp_fn)
+    { base_type::copy_from_range(first_it, last_it); }
+
+    priority_queue(const priority_queue& other)
+    : base_type((const base_type& )other) { }
+
+    virtual
+    ~priority_queue() { }
+
+    priority_queue&
+    operator=(const priority_queue& other)
+    {
+      if (this != &other)
+	{
+	  priority_queue tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(priority_queue& other)
+    { base_type::swap(other); }
+  };
+} // namespace __gnu_pbds
+ //@} heap-based
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp
new file mode 100644
index 0000000..ba2fb3d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp
@@ -0,0 +1,454 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file tag_and_trait.hpp
+ * Contains tags and traits, e.g., ones describing underlying
+ * data structures.
+ */
+
+#ifndef PB_DS_TAG_AND_TRAIT_HPP
+#define PB_DS_TAG_AND_TRAIT_HPP
+
+#include <bits/c++config.h>
+#include <ext/pb_ds/detail/type_utils.hpp>
+
+/**
+ * @namespace __gnu_pbds
+ * @brief GNU extensions for policy-based data structures for public use.
+ */
+namespace __gnu_pbds
+{
+  /** @defgroup pbds Policy-Based Data Structures
+   *  @ingroup extensions
+   *
+   *  This is a library of policy-based elementary data structures:
+   *  associative containers and priority queues. It is designed for
+   *  high-performance, flexibility, semantic safety, and conformance
+   *  to the corresponding containers in std (except for some points
+   *  where it differs by design).
+   *
+   *  For details, see:
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/index.html
+   *
+   *  @{
+   */
+
+  /**
+   *  @defgroup tags Tags
+   *  @{   
+   */
+  /// A trivial iterator tag. Signifies that the iterators has none of
+  /// std::iterators's movement abilities.
+  struct trivial_iterator_tag
+  { };
+
+  /// Prohibit moving trivial iterators.
+  typedef void trivial_iterator_difference_type;
+
+
+  /**
+   *  @defgroup invalidation_tags  Invalidation Guarantees
+   *  @ingroup tags
+   *  @{
+   */
+
+  /**
+   *  Signifies a basic invalidation guarantee that any iterator,
+   *  pointer, or reference to a container object's mapped value type
+   *  is valid as long as the container is not modified.
+   */
+  struct basic_invalidation_guarantee
+  { };
+
+  /**
+   *  Signifies an invalidation guarantee that includes all those of
+   *  its base, and additionally, that any point-type iterator,
+   *  pointer, or reference to a container object's mapped value type
+   *  is valid as long as its corresponding entry has not be erased,
+   *  regardless of modifications to the container object.
+   */
+  struct point_invalidation_guarantee : public basic_invalidation_guarantee
+  { };
+
+  /**
+   *  Signifies an invalidation guarantee that includes all those of
+   *  its base, and additionally, that any range-type iterator
+   *  (including the returns of begin() and end()) is in the correct
+   *  relative positions to other range-type iterators as long as its
+   *  corresponding entry has not be erased, regardless of
+   *  modifications to the container object.
+   */
+  struct range_invalidation_guarantee : public point_invalidation_guarantee
+  { };
+  //@}
+
+
+  /**
+   *  @defgroup ds_tags Data Structure Type
+   *  @ingroup tags
+   *  @{
+   */
+  /// Base data structure tag.
+  struct container_tag
+  { };
+
+  /// Basic sequence.
+  struct sequence_tag : public container_tag { };
+
+  /// Basic string container, inclusive of strings, ropes, etc.
+  struct string_tag : public sequence_tag { };
+
+  /// Basic associative-container.
+  struct associative_tag : public container_tag { };
+
+  /// Basic hash structure.
+  struct basic_hash_tag : public associative_tag { };
+
+  /// Collision-chaining hash.
+  struct cc_hash_tag : public basic_hash_tag { };
+
+  /// General-probing hash.
+  struct gp_hash_tag : public basic_hash_tag { };
+
+  /// Basic branch structure.
+  struct basic_branch_tag : public associative_tag { };
+
+  /// Basic tree structure.
+  struct tree_tag : public basic_branch_tag { };
+
+  /// Red-black tree.
+  struct rb_tree_tag : public tree_tag { };
+
+  /// Splay tree.
+  struct splay_tree_tag : public tree_tag { };
+
+  /// Ordered-vector tree.
+  struct ov_tree_tag : public tree_tag { };
+
+  /// Basic trie structure.
+  struct trie_tag : public basic_branch_tag { };
+
+  /// PATRICIA trie.
+  struct pat_trie_tag : public trie_tag { };
+
+  /// List-update.
+  struct list_update_tag : public associative_tag { };
+
+  /// Basic priority-queue.
+  struct priority_queue_tag : public container_tag { };
+
+  /// Pairing-heap.
+  struct pairing_heap_tag : public priority_queue_tag { };
+
+  /// Binomial-heap.
+  struct binomial_heap_tag : public priority_queue_tag { };
+
+  /// Redundant-counter binomial-heap.
+  struct rc_binomial_heap_tag : public priority_queue_tag { };
+
+  /// Binary-heap (array-based).
+  struct binary_heap_tag : public priority_queue_tag { };
+
+  /// Thin heap.
+  struct thin_heap_tag : public priority_queue_tag { };
+  //@}
+  //@}
+
+
+  /**
+   *  @defgroup traits Traits
+   *  @{
+   */
+
+  /**
+   *  @brief Represents no type, or absence of type, for template tricks.
+   *
+   *  In a mapped-policy, indicates that an associative container is a set.
+   *
+   *  In a list-update policy, indicates that each link does not need
+   *  metadata.
+   *
+   *  In a hash policy, indicates that the combining hash function
+   *  is actually a ranged hash function.
+   *
+   *  In a probe policy, indicates that the combining probe function
+   *  is actually a ranged probe function.
+   */
+  struct null_type { };
+
+  /// A null node updator, indicating that no node updates are required.
+  template<typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
+    struct null_node_update : public null_type
+    { };
+
+
+  /// Primary template, container traits base.
+  template<typename _Tag>
+    struct container_traits_base;
+
+  /// Specialization, cc hash.
+  template<>
+  struct container_traits_base<cc_hash_tag>
+  {
+    typedef cc_hash_tag 				container_category;
+    typedef point_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, gp hash.
+  template<>
+  struct container_traits_base<gp_hash_tag>
+  {
+    typedef gp_hash_tag 				container_category;
+    typedef basic_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, rb tree.
+  template<>
+  struct container_traits_base<rb_tree_tag>
+  {
+    typedef rb_tree_tag 				container_category;
+    typedef range_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = true,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = true
+      };
+  };
+
+  /// Specialization, splay tree.
+  template<>
+  struct container_traits_base<splay_tree_tag>
+  {
+    typedef splay_tree_tag 				container_category;
+    typedef range_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = true,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = true
+      };
+  };
+
+  /// Specialization, ov tree.
+  template<>
+  struct container_traits_base<ov_tree_tag>
+  {
+    typedef ov_tree_tag 				container_category;
+    typedef basic_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = true,
+	erase_can_throw = true,
+	split_join_can_throw = true,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, pat trie.
+  template<>
+  struct container_traits_base<pat_trie_tag>
+  {
+    typedef pat_trie_tag 				container_category;
+    typedef range_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = true,
+	erase_can_throw = false,
+	split_join_can_throw = true,
+	reverse_iteration = true
+      };
+  };
+
+  /// Specialization, list update.
+  template<>
+  struct container_traits_base<list_update_tag>
+  {
+    typedef list_update_tag 				container_category;
+    typedef point_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, pairing heap.
+  template<>
+  struct container_traits_base<pairing_heap_tag>
+  {
+    typedef pairing_heap_tag 				container_category;
+    typedef point_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, thin heap.
+  template<>
+  struct container_traits_base<thin_heap_tag>
+  {
+    typedef thin_heap_tag 				container_category;
+    typedef point_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, binomial heap.
+  template<>
+  struct container_traits_base<binomial_heap_tag>
+  {
+    typedef binomial_heap_tag 				container_category;
+    typedef point_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, rc binomial heap.
+  template<>
+  struct container_traits_base<rc_binomial_heap_tag>
+  {
+    typedef rc_binomial_heap_tag 			container_category;
+    typedef point_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  /// Specialization, binary heap.
+  template<>
+  struct container_traits_base<binary_heap_tag>
+  {
+    typedef binary_heap_tag 				container_category;
+    typedef basic_invalidation_guarantee 		invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = true,
+	reverse_iteration = false
+      };
+  };
+
+
+  /// Container traits.
+  // See Matt Austern for the name, S. Meyers MEFC++ #2, others.
+  template<typename Cntnr>
+  struct container_traits
+  : public container_traits_base<typename Cntnr::container_category>
+  {
+    typedef Cntnr 				       container_type;
+    typedef typename Cntnr::container_category         container_category;
+    typedef container_traits_base<container_category>  base_type;
+    typedef typename base_type::invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+	/// True only if Cntnr objects guarantee storing  keys by order.
+	order_preserving = base_type::order_preserving,
+
+	/// True only if erasing a key can throw.
+	erase_can_throw = base_type::erase_can_throw,
+
+	/// True only if split or join operations can throw.
+	split_join_can_throw = base_type::split_join_can_throw,
+
+	/// True only reverse iterators are supported.
+	reverse_iteration = base_type::reverse_iteration
+      };
+  };
+  //@}
+
+
+  namespace detail
+  {
+    /// Dispatch mechanism, primary template for associative types.
+    template<typename Key, typename Mapped, typename _Alloc, typename Tag,
+	     typename Policy_Tl = null_type>
+      struct container_base_dispatch;
+  } // namespace detail
+  //@}
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/tree_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/tree_policy.hpp
new file mode 100644
index 0000000..ab421d0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/tree_policy.hpp
@@ -0,0 +1,157 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file tree_policy.hpp
+ * Contains tree-related policies.
+ */
+
+#ifndef PB_DS_TREE_POLICY_HPP
+#define PB_DS_TREE_POLICY_HPP
+
+#include <bits/c++config.h>
+#include <iterator>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/branch_policy/branch_policy.hpp>
+
+namespace __gnu_pbds
+{
+#define PB_DS_CLASS_T_DEC \
+  template<typename Node_CItr, typename Node_Itr, typename Cmp_Fn, \
+	   typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+  tree_order_statistics_node_update<Node_CItr, Node_Itr, Cmp_Fn, _Alloc>
+
+#define PB_DS_BRANCH_POLICY_BASE \
+  detail::branch_policy<Node_CItr, Node_Itr, _Alloc>
+
+  /// Functor updating ranks of entrees.
+  template<typename Node_CItr, typename Node_Itr, 
+	   typename Cmp_Fn, typename _Alloc>
+  class tree_order_statistics_node_update : private PB_DS_BRANCH_POLICY_BASE
+  {
+  private:
+    typedef PB_DS_BRANCH_POLICY_BASE 		       	base_type;
+
+  public:
+    typedef Cmp_Fn 					cmp_fn;
+    typedef _Alloc 					allocator_type;
+    typedef typename allocator_type::size_type 		size_type;
+    typedef typename base_type::key_type 		key_type;
+    typedef typename base_type::key_const_reference 	key_const_reference;
+
+    typedef size_type 					metadata_type;
+    typedef Node_CItr 	       			node_const_iterator;
+    typedef Node_Itr 					node_iterator;
+    typedef typename node_const_iterator::value_type 	const_iterator;
+    typedef typename node_iterator::value_type 		iterator;
+
+    /// Finds an entry by __order. Returns a const_iterator to the
+    /// entry with the __order order, or a const_iterator to the
+    /// container object's end if order is at least the size of the
+    /// container object.
+    inline const_iterator
+    find_by_order(size_type) const;
+
+    /// Finds an entry by __order. Returns an iterator to the entry
+    /// with the __order order, or an iterator to the container
+    /// object's end if order is at least the size of the container
+    /// object.
+    inline iterator
+    find_by_order(size_type);
+
+    /// Returns the order of a key within a sequence. For exapmle, if
+    /// r_key is the smallest key, this method will return 0; if r_key
+    /// is a key between the smallest and next key, this method will
+    /// return 1; if r_key is a key larger than the largest key, this
+    /// method will return the size of r_c.
+    inline size_type
+    order_of_key(key_const_reference) const;
+
+  private:
+    /// Const reference to the container's value-type.
+    typedef typename base_type::const_reference 	const_reference;
+
+    /// Const pointer to the container's value-type.
+    typedef typename base_type::const_pointer 		const_pointer;
+
+    typedef typename _Alloc::template rebind<metadata_type>::other __rebind_m;
+
+    /// Const metadata reference.
+    typedef typename __rebind_m::const_reference       metadata_const_reference;
+
+    /// Metadata reference.
+    typedef typename __rebind_m::reference 		metadata_reference;
+
+    /// Returns the node_const_iterator associated with the tree's root node.
+    virtual node_const_iterator
+    node_begin() const = 0;
+
+    /// Returns the node_iterator associated with the tree's root node.
+    virtual node_iterator
+    node_begin() = 0;
+
+    /// Returns the node_const_iterator associated with a just-after leaf node.
+    virtual node_const_iterator
+    node_end() const = 0;
+
+    /// Returns the node_iterator associated with a just-after leaf node.
+    virtual node_iterator
+    node_end() = 0;
+
+    /// Access to the cmp_fn object.
+    virtual cmp_fn& 
+    get_cmp_fn() = 0;
+
+  protected:
+    /// Updates the rank of a node through a node_iterator node_it;
+    /// end_nd_it is the end node iterator.
+    inline void
+    operator()(node_iterator, node_const_iterator) const;
+
+    virtual
+    ~tree_order_statistics_node_update();
+  };
+
+#include <ext/pb_ds/detail/tree_policy/order_statistics_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_BRANCH_POLICY_BASE
+
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/trie_policy.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/trie_policy.hpp
new file mode 100644
index 0000000..04bddfa
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/trie_policy.hpp
@@ -0,0 +1,360 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy.hpp
+ * Contains trie-related policies.
+ */
+
+#ifndef PB_DS_TRIE_POLICY_HPP
+#define PB_DS_TRIE_POLICY_HPP
+
+#include <bits/c++config.h>
+#include <string>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/trie_policy/trie_policy_base.hpp>
+
+namespace __gnu_pbds
+{
+#define PB_DS_CLASS_T_DEC \
+  template<typename String, typename String::value_type Min_E_Val, \
+	   typename String::value_type Max_E_Val, bool Reverse, \
+	   typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+  trie_string_access_traits<String, Min_E_Val,Max_E_Val,Reverse,_Alloc>
+
+  /**
+   *  Element access traits for string types.
+   *
+   *  @tparam String 	    	String type.
+   *  @tparam Min_E_Val        	Minimal element value.
+   *  @tparam Max_E_Val	    	Maximum element value.
+   *  @tparam Reverse	        Reverse iteration should be used.
+   *                            Default: false.
+   *  @tparam _Alloc 	    	Allocator type.
+   */
+  template<typename String = std::string,
+	   typename String::value_type Min_E_Val = detail::__numeric_traits<typename String::value_type>::__min,
+	   typename String::value_type Max_E_Val = detail::__numeric_traits<typename String::value_type>::__max,
+	   bool Reverse = false,
+	   typename _Alloc = std::allocator<char> >
+  struct trie_string_access_traits
+  {
+  public:
+    typedef typename _Alloc::size_type			  size_type;
+    typedef String 					  key_type;
+    typedef typename _Alloc::template rebind<key_type>	  __rebind_k;
+    typedef typename __rebind_k::other::const_reference   key_const_reference;
+
+    enum
+      {
+	reverse = Reverse
+      };
+
+    /// Element const iterator type.
+    typedef typename detail::__conditional_type<Reverse, \
+		       typename String::const_reverse_iterator, \
+		       typename String::const_iterator>::__type const_iterator;
+
+    /// Element type.
+    typedef typename std::iterator_traits<const_iterator>::value_type e_type;
+
+    enum
+      {
+	min_e_val = Min_E_Val,
+	max_e_val = Max_E_Val,
+	max_size = max_e_val - min_e_val + 1
+      };
+    PB_DS_STATIC_ASSERT(min_max_size, max_size >= 2);
+
+    /// Returns a const_iterator to the first element of
+    /// key_const_reference agumnet.
+    inline static const_iterator
+    begin(key_const_reference);
+
+    /// Returns a const_iterator to the after-last element of
+    /// key_const_reference argument.
+    inline static const_iterator
+    end(key_const_reference);
+
+    /// Maps an element to a position.
+    inline static size_type
+    e_pos(e_type e);
+
+  private:
+    inline static const_iterator
+    begin_imp(key_const_reference, detail::false_type);
+
+    inline static const_iterator
+    begin_imp(key_const_reference, detail::true_type);
+
+    inline static const_iterator
+    end_imp(key_const_reference, detail::false_type);
+
+    inline static const_iterator
+    end_imp(key_const_reference, detail::true_type);
+
+    static detail::integral_constant<int, Reverse> s_rev_ind;
+  };
+
+#include <ext/pb_ds/detail/trie_policy/trie_string_access_traits_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC \
+  template<typename Node_CItr,typename Node_Itr, \
+	   typename _ATraits, typename _Alloc>
+
+#define PB_DS_CLASS_C_DEC \
+  trie_prefix_search_node_update<Node_CItr, Node_Itr, \
+				 _ATraits,_Alloc>
+
+#define PB_DS_TRIE_POLICY_BASE \
+  detail::trie_policy_base<Node_CItr,Node_Itr,_ATraits, _Alloc>
+
+  /// A node updator that allows tries to be searched for the range of
+  /// values that match a certain prefix.
+  template<typename Node_CItr,
+	   typename Node_Itr,
+	   typename _ATraits,
+	   typename _Alloc>
+  class trie_prefix_search_node_update : private PB_DS_TRIE_POLICY_BASE
+  {
+  private:
+    typedef PB_DS_TRIE_POLICY_BASE 		       	base_type;
+
+  public:
+    typedef typename base_type::key_type 		key_type;
+    typedef typename base_type::key_const_reference 	key_const_reference;
+
+    /// Element access traits.
+    typedef _ATraits 				access_traits;
+
+    /// Const element iterator.
+    typedef typename access_traits::const_iterator 	a_const_iterator;
+
+    /// _Alloc type.
+    typedef _Alloc 	       				allocator_type;
+
+    /// Size type.
+    typedef typename allocator_type::size_type 		size_type;
+    typedef null_type 					metadata_type;
+    typedef Node_Itr 					node_iterator;
+    typedef Node_CItr 					node_const_iterator;
+    typedef typename node_iterator::value_type 		iterator;
+    typedef typename node_const_iterator::value_type 	const_iterator;
+
+    /// Finds the const iterator range corresponding to all values
+    /// whose prefixes match r_key.
+    std::pair<const_iterator, const_iterator>
+    prefix_range(key_const_reference) const;
+
+    /// Finds the iterator range corresponding to all values whose
+    /// prefixes match r_key.
+    std::pair<iterator, iterator>
+    prefix_range(key_const_reference);
+
+    /// Finds the const iterator range corresponding to all values
+    /// whose prefixes match [b, e).
+    std::pair<const_iterator, const_iterator>
+    prefix_range(a_const_iterator, a_const_iterator) const;
+
+    /// Finds the iterator range corresponding to all values whose
+    /// prefixes match [b, e).
+    std::pair<iterator, iterator>
+    prefix_range(a_const_iterator, a_const_iterator);
+
+  protected:
+    /// Called to update a node's metadata.
+    inline void
+    operator()(node_iterator node_it, node_const_iterator end_nd_it) const;
+
+  private:
+    node_iterator
+    next_child(node_iterator, a_const_iterator, a_const_iterator,
+	       node_iterator, const access_traits&);
+
+    /// Returns the const iterator associated with the just-after last element.
+    virtual const_iterator
+    end() const = 0;
+
+    /// Returns the iterator associated with the just-after last element.
+    virtual iterator
+    end() = 0;
+
+    /// Returns the node_const_iterator associated with the trie's root node.
+    virtual node_const_iterator
+    node_begin() const = 0;
+
+    /// Returns the node_iterator associated with the trie's root node.
+    virtual node_iterator
+    node_begin() = 0;
+
+    /// Returns the node_const_iterator associated with a just-after leaf node.
+    virtual node_const_iterator
+    node_end() const = 0;
+
+    /// Returns the node_iterator associated with a just-after leaf node.
+    virtual node_iterator
+    node_end() = 0;
+
+    /// Access to the cmp_fn object.
+    virtual const access_traits&
+    get_access_traits() const = 0;
+  };
+
+#include <ext/pb_ds/detail/trie_policy/prefix_search_node_update_imp.hpp>
+
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_C_DEC \
+  trie_order_statistics_node_update<Node_CItr, Node_Itr, \
+				    _ATraits, _Alloc>
+
+  /// Functor updating ranks of entrees.
+  template<typename Node_CItr,
+	   typename Node_Itr,
+	   typename _ATraits,
+	   typename _Alloc>
+  class trie_order_statistics_node_update : private PB_DS_TRIE_POLICY_BASE
+  {
+  private:
+    typedef PB_DS_TRIE_POLICY_BASE 		       	base_type;
+
+  public:
+    typedef _ATraits 				access_traits;
+    typedef typename access_traits::const_iterator 	a_const_iterator;
+    typedef _Alloc 					allocator_type;
+    typedef typename allocator_type::size_type 		size_type;
+    typedef typename base_type::key_type 		key_type;
+    typedef typename base_type::key_const_reference 	key_const_reference;
+
+    typedef size_type 					metadata_type;
+    typedef Node_CItr 					node_const_iterator;
+    typedef Node_Itr 					node_iterator;
+    typedef typename node_const_iterator::value_type 	const_iterator;
+    typedef typename node_iterator::value_type 		iterator;
+
+    /// Finds an entry by __order. Returns a const_iterator to the
+    /// entry with the __order order, or a const_iterator to the
+    /// container object's end if order is at least the size of the
+    /// container object.
+    inline const_iterator
+    find_by_order(size_type) const;
+
+    /// Finds an entry by __order. Returns an iterator to the entry
+    /// with the __order order, or an iterator to the container
+    /// object's end if order is at least the size of the container
+    /// object.
+    inline iterator
+    find_by_order(size_type);
+
+    /// Returns the order of a key within a sequence. For exapmle, if
+    /// r_key is the smallest key, this method will return 0; if r_key
+    /// is a key between the smallest and next key, this method will
+    /// return 1; if r_key is a key larger than the largest key, this
+    /// method will return the size of r_c.
+    inline size_type
+    order_of_key(key_const_reference) const;
+
+    /// Returns the order of a prefix within a sequence. For exapmle,
+    /// if [b, e] is the smallest prefix, this method will return 0; if
+    /// r_key is a key between the smallest and next key, this method
+    /// will return 1; if r_key is a key larger than the largest key,
+    /// this method will return the size of r_c.
+    inline size_type
+    order_of_prefix(a_const_iterator, a_const_iterator) const;
+
+  protected:
+    /// Updates the rank of a node through a node_iterator node_it;
+    /// end_nd_it is the end node iterator.
+    inline void
+    operator()(node_iterator, node_const_iterator) const;
+
+  private:
+    typedef typename base_type::const_reference 	const_reference;
+    typedef typename base_type::const_pointer 		const_pointer;
+
+    typedef typename _Alloc::template rebind<metadata_type> __rebind_m;
+    typedef typename __rebind_m::other 			__rebind_ma;
+    typedef typename __rebind_ma::const_reference      metadata_const_reference;
+    typedef typename __rebind_ma::reference 		metadata_reference;
+
+    /// Returns true if the container is empty.
+    virtual bool
+    empty() const = 0;
+
+    /// Returns the iterator associated with the trie's first element.
+    virtual iterator
+    begin() = 0;
+
+    /// Returns the iterator associated with the trie's
+    /// just-after-last element.
+    virtual iterator
+    end() = 0;
+
+    /// Returns the node_const_iterator associated with the trie's root node.
+    virtual node_const_iterator
+    node_begin() const = 0;
+
+    /// Returns the node_iterator associated with the trie's root node.
+    virtual node_iterator
+    node_begin() = 0;
+
+    /// Returns the node_const_iterator associated with a just-after
+    /// leaf node.
+    virtual node_const_iterator
+    node_end() const = 0;
+
+    /// Returns the node_iterator associated with a just-after leaf node.
+    virtual node_iterator
+    node_end() = 0;
+
+    /// Access to the cmp_fn object.
+    virtual access_traits&
+    get_access_traits() = 0;
+  };
+
+#include <ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_TRIE_POLICY_BASE
+
+} // namespace __gnu_pbds
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pod_char_traits.h b/gcc-4.9/libstdc++-v3/include/ext/pod_char_traits.h
new file mode 100644
index 0000000..e027585
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pod_char_traits.h
@@ -0,0 +1,192 @@
+// POD character, std::char_traits specialization -*- C++ -*-
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/pod_char_traits.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+// Gabriel Dos Reis <gdr@integrable-solutions.net>
+// Benjamin Kosnik <bkoz@redhat.com>
+
+#ifndef _POD_CHAR_TRAITS_H
+#define _POD_CHAR_TRAITS_H 1
+
+#pragma GCC system_header
+
+#include <string>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // POD character abstraction.
+  // NB: The char_type parameter is a subset of int_type, as to allow
+  // int_type to properly hold the full range of char_type values as
+  // well as EOF.
+  /// @brief A POD class that serves as a character abstraction class.
+  template<typename _Value, typename _Int, typename _St = std::mbstate_t>
+    struct character
+    {
+      typedef _Value				value_type;
+      typedef _Int				int_type;
+      typedef _St				state_type;
+      typedef character<_Value, _Int, _St>	char_type;
+
+      value_type	value;
+
+      template<typename V2>
+        static char_type
+        from(const V2& v)
+        {
+	  char_type ret = { static_cast<value_type>(v) };
+	  return ret;
+	}
+
+      template<typename V2>
+        static V2
+        to(const char_type& c)
+        {
+	  V2 ret = { static_cast<V2>(c.value) };
+	  return ret;
+	}
+
+    };
+
+  template<typename _Value, typename _Int, typename _St>
+    inline bool
+    operator==(const character<_Value, _Int, _St>& lhs,
+	       const character<_Value, _Int, _St>& rhs)
+    { return lhs.value == rhs.value; }
+
+  template<typename _Value, typename _Int, typename _St>
+    inline bool
+    operator<(const character<_Value, _Int, _St>& lhs,
+	      const character<_Value, _Int, _St>& rhs)
+    { return lhs.value < rhs.value; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// char_traits<__gnu_cxx::character> specialization.
+  template<typename _Value, typename _Int, typename _St>
+    struct char_traits<__gnu_cxx::character<_Value, _Int, _St> >
+    {
+      typedef __gnu_cxx::character<_Value, _Int, _St>	char_type;
+      typedef typename char_type::int_type		int_type;
+      typedef typename char_type::state_type		state_type;
+      typedef fpos<state_type>				pos_type;
+      typedef streamoff					off_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+	for (size_t __i = 0; __i < __n; ++__i)
+	  if (!eq(__s1[__i], __s2[__i]))
+	    return lt(__s1[__i], __s2[__i]) ? -1 : 1;
+	return 0;
+      }
+
+      static size_t
+      length(const char_type* __s)
+      {
+	const char_type* __p = __s;
+	while (__p->value)
+	  ++__p;
+	return (__p - __s);
+      }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+	for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
+	  if (*__p == __a)
+	    return __p;
+	return 0;
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      { 
+	return static_cast<char_type*>
+	  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+	std::copy(__s2, __s2 + __n, __s1);
+	return __s1;
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+	std::fill_n(__s, __n, __a);
+        return __s;
+      }
+
+      static char_type
+      to_char_type(const int_type& __i)
+      { return char_type::template from(__i); }
+
+      static int_type
+      to_int_type(const char_type& __c)
+      { return char_type::template to<int_type>(__c); }
+
+      static bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static int_type
+      eof() 
+      {
+	int_type __r = { -1 };
+	return __r;
+      }
+
+      static int_type
+      not_eof(const int_type& __c)
+      { return eq_int_type(__c, eof()) ? int_type() : __c; }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pointer.h b/gcc-4.9/libstdc++-v3/include/ext/pointer.h
new file mode 100644
index 0000000..cfc6b7c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pointer.h
@@ -0,0 +1,593 @@
+// Custom pointer adapter and sample storage policies
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ *  @file ext/pointer.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ *
+ *  @author Bob Walters
+ *
+ * Provides reusable _Pointer_adapter for assisting in the development of
+ * custom pointer types that can be used with the standard containers via
+ * the allocator::pointer and allocator::const_pointer typedefs.
+ */
+
+#ifndef _POINTER_H
+#define _POINTER_H 1
+
+#pragma GCC system_header
+
+#include <iosfwd>
+#include <bits/stl_iterator_base_types.h>
+#include <ext/cast.h>
+#include <ext/type_traits.h>
+#if __cplusplus >= 201103L
+# include <bits/move.h>
+# include <bits/ptr_traits.h>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /** 
+   * @brief A storage policy for use with _Pointer_adapter<> which yields a
+   *        standard pointer.
+   * 
+   *  A _Storage_policy is required to provide 4 things:
+   *    1) A get() API for returning the stored pointer value.
+   *    2) An set() API for storing a pointer value.
+   *    3) An element_type typedef to define the type this points to.
+   *    4) An operator<() to support pointer comparison.
+   *    5) An operator==() to support pointer comparison.
+   */
+  template<typename _Tp> 
+    class _Std_pointer_impl 
+    {
+    public:
+      // the type this pointer points to.
+      typedef _Tp element_type;
+  
+      // A method to fetch the pointer value as a standard T* value;
+      inline _Tp* 
+      get() const 
+      { return _M_value; }
+  
+      // A method to set the pointer value, from a standard T* value;
+      inline void 
+      set(element_type* __arg) 
+      { _M_value = __arg; }
+  
+      // Comparison of pointers
+      inline bool
+      operator<(const _Std_pointer_impl& __rarg) const
+      { return (_M_value < __rarg._M_value); }
+  
+      inline bool
+      operator==(const _Std_pointer_impl& __rarg) const
+      { return (_M_value == __rarg._M_value); }
+
+    private:
+      element_type* _M_value;
+    };
+
+  /**
+   * @brief A storage policy for use with _Pointer_adapter<> which stores
+   *        the pointer's address as an offset value which is relative to
+   *        its own address.
+   * 
+   * This is intended for pointers within shared memory regions which
+   * might be mapped at different addresses by different processes.
+   * For null pointers, a value of 1 is used.  (0 is legitimate
+   * sometimes for nodes in circularly linked lists) This value was
+   * chosen as the least likely to generate an incorrect null, As
+   * there is no reason why any normal pointer would point 1 byte into
+   * its own pointer address.
+   */
+  template<typename _Tp> 
+    class _Relative_pointer_impl 
+    {
+    public:
+      typedef _Tp element_type;
+  
+      _Tp*
+      get() const 
+      {
+        if (_M_diff == 1)
+          return 0;
+        else
+          return reinterpret_cast<_Tp*>(reinterpret_cast<_UIntPtrType>(this)
+					+ _M_diff);
+      }
+  
+      void 
+      set(_Tp* __arg)
+      {
+        if (!__arg)
+          _M_diff = 1;
+        else
+          _M_diff = reinterpret_cast<_UIntPtrType>(__arg) 
+                    - reinterpret_cast<_UIntPtrType>(this);
+      }
+  
+      // Comparison of pointers
+      inline bool
+      operator<(const _Relative_pointer_impl& __rarg) const
+      { return (reinterpret_cast<_UIntPtrType>(this->get())
+		< reinterpret_cast<_UIntPtrType>(__rarg.get())); }
+
+      inline bool
+      operator==(const _Relative_pointer_impl& __rarg) const
+      { return (reinterpret_cast<_UIntPtrType>(this->get())
+		== reinterpret_cast<_UIntPtrType>(__rarg.get())); }
+
+    private:
+#ifdef _GLIBCXX_USE_LONG_LONG
+      typedef __gnu_cxx::__conditional_type<
+	 (sizeof(unsigned long) >= sizeof(void*)),
+	 unsigned long, unsigned long long>::__type _UIntPtrType;
+#else
+      typedef unsigned long _UIntPtrType;
+#endif
+      _UIntPtrType _M_diff;
+    };
+  
+  /**
+   * Relative_pointer_impl needs a specialization for const T because of
+   * the casting done during pointer arithmetic.
+   */
+  template<typename _Tp> 
+    class _Relative_pointer_impl<const _Tp> 
+    {
+    public:
+      typedef const _Tp element_type;
+  
+      const _Tp*
+      get() const
+      {
+        if (_M_diff == 1)
+          return 0;
+        else
+          return reinterpret_cast<const _Tp*>
+	      (reinterpret_cast<_UIntPtrType>(this) + _M_diff);
+      }
+  
+      void 
+      set(const _Tp* __arg)
+      {
+        if (!__arg)
+          _M_diff = 1;
+        else
+          _M_diff = reinterpret_cast<_UIntPtrType>(__arg) 
+                    - reinterpret_cast<_UIntPtrType>(this);
+      }
+  
+      // Comparison of pointers
+      inline bool
+      operator<(const _Relative_pointer_impl& __rarg) const
+      { return (reinterpret_cast<_UIntPtrType>(this->get())
+		< reinterpret_cast<_UIntPtrType>(__rarg.get())); }
+
+      inline bool
+      operator==(const _Relative_pointer_impl& __rarg) const
+      { return (reinterpret_cast<_UIntPtrType>(this->get())
+		== reinterpret_cast<_UIntPtrType>(__rarg.get())); }
+  
+    private:
+#ifdef _GLIBCXX_USE_LONG_LONG
+      typedef __gnu_cxx::__conditional_type<
+	 (sizeof(unsigned long) >= sizeof(void*)),
+	 unsigned long, unsigned long long>::__type _UIntPtrType;
+#else
+      typedef unsigned long _UIntPtrType;
+#endif
+       _UIntPtrType _M_diff;
+    };
+
+  /**
+   * The specialization on this type helps resolve the problem of
+   * reference to void, and eliminates the need to specialize
+   * _Pointer_adapter for cases of void*, const void*, and so on.
+   */
+  struct _Invalid_type { };
+  
+  template<typename _Tp>
+    struct _Reference_type 
+    { typedef _Tp& reference; };
+
+  template<> 
+    struct _Reference_type<void> 
+    { typedef _Invalid_type& reference; };
+
+  template<> 
+    struct _Reference_type<const void> 
+    { typedef const _Invalid_type& reference; };
+
+  template<> 
+    struct _Reference_type<volatile void> 
+    { typedef volatile _Invalid_type&  reference; };
+
+  template<> 
+    struct _Reference_type<volatile const void> 
+    { typedef const volatile _Invalid_type&  reference; };
+
+  /**
+   * This structure accommodates the way in which
+   * std::iterator_traits<> is normally specialized for const T*, so
+   * that value_type is still T.
+   */
+  template<typename _Tp> 
+    struct _Unqualified_type 
+    { typedef _Tp type; };
+    
+  template<typename _Tp> 
+    struct _Unqualified_type<const _Tp> 
+    { typedef _Tp type; };
+    
+  /**
+   * The following provides an 'alternative pointer' that works with
+   * the containers when specified as the pointer typedef of the
+   * allocator.
+   *
+   * The pointer type used with the containers doesn't have to be this
+   * class, but it must support the implicit conversions, pointer
+   * arithmetic, comparison operators, etc. that are supported by this
+   * class, and avoid raising compile-time ambiguities.  Because
+   * creating a working pointer can be challenging, this pointer
+   * template was designed to wrapper an easier storage policy type,
+   * so that it becomes reusable for creating other pointer types.
+   *
+   * A key point of this class is also that it allows container
+   * writers to 'assume' Allocator::pointer is a typedef for a normal
+   * pointer.  This class supports most of the conventions of a true
+   * pointer, and can, for instance handle implicit conversion to
+   * const and base class pointer types.  The only impositions on
+   * container writers to support extended pointers are: 1) use the
+   * Allocator::pointer typedef appropriately for pointer types.  2)
+   * if you need pointer casting, use the __pointer_cast<> functions
+   * from ext/cast.h.  This allows pointer cast operations to be
+   * overloaded as necessary by custom pointers.
+   *
+   * Note: The const qualifier works with this pointer adapter as
+   * follows:
+   *
+   * _Tp*             == _Pointer_adapter<_Std_pointer_impl<_Tp> >;
+   * const _Tp*       == _Pointer_adapter<_Std_pointer_impl<const _Tp> >;
+   * _Tp* const       == const _Pointer_adapter<_Std_pointer_impl<_Tp> >;
+   * const _Tp* const == const _Pointer_adapter<_Std_pointer_impl<const _Tp> >;
+   */
+  template<typename _Storage_policy>
+    class _Pointer_adapter : public _Storage_policy 
+    {
+    public:
+      typedef typename _Storage_policy::element_type element_type;
+
+      // These are needed for iterator_traits
+      typedef std::random_access_iterator_tag                iterator_category;
+      typedef typename _Unqualified_type<element_type>::type value_type;
+      typedef std::ptrdiff_t                                 difference_type;
+      typedef _Pointer_adapter                               pointer;
+      typedef typename _Reference_type<element_type>::reference  reference;
+
+      // Reminder: 'const' methods mean that the method is valid when the 
+      // pointer is immutable, and has nothing to do with whether the 
+      // 'pointee' is const.
+
+      // Default Constructor (Convert from element_type*)
+      _Pointer_adapter(element_type* __arg = 0)
+      { _Storage_policy::set(__arg); }
+
+      // Copy constructor from _Pointer_adapter of same type.
+      _Pointer_adapter(const _Pointer_adapter& __arg) 
+      { _Storage_policy::set(__arg.get()); }
+
+      // Convert from _Up* if conversion to element_type* is valid.
+      template<typename _Up>
+        _Pointer_adapter(_Up* __arg)
+        { _Storage_policy::set(__arg); }
+
+      // Conversion from another _Pointer_adapter if _Up if static cast is
+      // valid.
+      template<typename _Up>
+        _Pointer_adapter(const _Pointer_adapter<_Up>& __arg)
+        { _Storage_policy::set(__arg.get()); }
+
+      // Destructor
+      ~_Pointer_adapter() { }
+  
+      // Assignment operator
+      _Pointer_adapter&
+      operator=(const _Pointer_adapter& __arg) 
+      {
+        _Storage_policy::set(__arg.get()); 
+        return *this; 
+      }
+
+      template<typename _Up>
+        _Pointer_adapter&
+        operator=(const _Pointer_adapter<_Up>& __arg)
+        {
+          _Storage_policy::set(__arg.get()); 
+          return *this; 
+        }
+
+      template<typename _Up>
+        _Pointer_adapter&
+        operator=(_Up* __arg)
+        {
+          _Storage_policy::set(__arg); 
+          return *this; 
+        }
+
+      // Operator*, returns element_type&
+      inline reference 
+      operator*() const 
+      { return *(_Storage_policy::get()); }
+
+      // Operator->, returns element_type*
+      inline element_type* 
+      operator->() const 
+      { return _Storage_policy::get(); }
+
+      // Operator[], returns a element_type& to the item at that loc.
+      inline reference
+      operator[](std::ptrdiff_t __index) const
+      { return _Storage_policy::get()[__index]; }
+
+      // To allow implicit conversion to "bool", for "if (ptr)..."
+    private:
+      typedef element_type*(_Pointer_adapter::*__unspecified_bool_type)() const;
+
+    public:
+      operator __unspecified_bool_type() const
+      {
+        return _Storage_policy::get() == 0 ? 0 : 
+                         &_Pointer_adapter::operator->; 
+      }
+
+      // ! operator (for: if (!ptr)...)
+      inline bool
+      operator!() const 
+      { return (_Storage_policy::get() == 0); }
+  
+      // Pointer differences
+      inline friend std::ptrdiff_t 
+      operator-(const _Pointer_adapter& __lhs, element_type* __rhs) 
+      { return (__lhs.get() - __rhs); }
+  
+      inline friend std::ptrdiff_t 
+      operator-(element_type* __lhs, const _Pointer_adapter& __rhs) 
+      { return (__lhs - __rhs.get()); }
+  
+      template<typename _Up>
+        inline friend std::ptrdiff_t 
+        operator-(const _Pointer_adapter& __lhs, _Up* __rhs) 
+        { return (__lhs.get() - __rhs); }
+    
+      template<typename _Up>
+        inline friend std::ptrdiff_t 
+        operator-(_Up* __lhs, const _Pointer_adapter& __rhs)
+        { return (__lhs - __rhs.get()); }
+
+      template<typename _Up>
+        inline std::ptrdiff_t 
+        operator-(const _Pointer_adapter<_Up>& __rhs) const 
+        { return (_Storage_policy::get() - __rhs.get()); }
+  
+      // Pointer math
+      // Note: There is a reason for all this overloading based on different
+      // integer types.  In some libstdc++-v3 test cases, a templated
+      // operator+ is declared which can match any types.  This operator
+      // tends to "steal" the recognition of _Pointer_adapter's own operator+ 
+      // unless the integer type matches perfectly.
+
+#define _CXX_POINTER_ARITH_OPERATOR_SET(INT_TYPE) \
+      inline friend _Pointer_adapter \
+      operator+(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
+      { return _Pointer_adapter(__lhs.get() + __offset); } \
+\
+      inline friend _Pointer_adapter \
+      operator+(INT_TYPE __offset, const _Pointer_adapter& __rhs) \
+      { return _Pointer_adapter(__rhs.get() + __offset); } \
+\
+      inline friend _Pointer_adapter \
+      operator-(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
+      { return _Pointer_adapter(__lhs.get() - __offset); } \
+\
+      inline _Pointer_adapter& \
+      operator+=(INT_TYPE __offset) \
+      { \
+        _Storage_policy::set(_Storage_policy::get() + __offset); \
+        return *this; \
+      } \
+\
+      inline _Pointer_adapter& \
+      operator-=(INT_TYPE __offset) \
+      { \
+        _Storage_policy::set(_Storage_policy::get() - __offset); \
+        return *this; \
+      } \
+// END of _CXX_POINTER_ARITH_OPERATOR_SET macro
+  
+      // Expand into the various pointer arithmetic operators needed.
+      _CXX_POINTER_ARITH_OPERATOR_SET(short);
+      _CXX_POINTER_ARITH_OPERATOR_SET(unsigned short);
+      _CXX_POINTER_ARITH_OPERATOR_SET(int);
+      _CXX_POINTER_ARITH_OPERATOR_SET(unsigned int);
+      _CXX_POINTER_ARITH_OPERATOR_SET(long);
+      _CXX_POINTER_ARITH_OPERATOR_SET(unsigned long);
+
+      // Mathematical Manipulators
+      inline _Pointer_adapter& 
+      operator++()
+      {
+        _Storage_policy::set(_Storage_policy::get() + 1); 
+        return *this;
+      }
+  
+      inline _Pointer_adapter 
+      operator++(int)
+      {
+        _Pointer_adapter tmp(*this);
+        _Storage_policy::set(_Storage_policy::get() + 1);
+        return tmp;
+      }
+  
+      inline _Pointer_adapter& 
+      operator--() 
+      {
+        _Storage_policy::set(_Storage_policy::get() - 1); 
+        return *this;
+      }
+  
+      inline _Pointer_adapter
+      operator--(int) 
+      {
+        _Pointer_adapter tmp(*this);
+        _Storage_policy::set(_Storage_policy::get() - 1);
+        return tmp;
+      }
+  
+    }; // class _Pointer_adapter
+
+
+#define _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(OPERATOR) \
+  template<typename _Tp1, typename _Tp2> \
+    inline bool \
+    operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, _Tp2 __rhs) \
+    { return __lhs.get() OPERATOR __rhs; } \
+\
+  template<typename _Tp1, typename _Tp2> \
+    inline bool \
+    operator OPERATOR(_Tp1 __lhs, const _Pointer_adapter<_Tp2>& __rhs) \
+    { return __lhs OPERATOR __rhs.get(); } \
+\
+  template<typename _Tp1, typename _Tp2> \
+    inline bool \
+    operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, \
+                              const _Pointer_adapter<_Tp2>& __rhs) \
+    { return __lhs.get() OPERATOR __rhs.get(); } \
+\
+// End GCC_CXX_POINTER_COMPARISON_OPERATION_SET Macro
+  
+  // Expand into the various comparison operators needed.
+  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(==)
+  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(!=)
+  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<)
+  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<=)
+  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>)
+  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>=)
+
+  // These are here for expressions like "ptr == 0", "ptr != 0"
+  template<typename _Tp>
+    inline bool
+    operator==(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
+    { return __lhs.get() == reinterpret_cast<void*>(__rhs); } 
+
+  template<typename _Tp>
+    inline bool
+    operator==(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
+    { return __rhs.get() == reinterpret_cast<void*>(__lhs); } 
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
+    { return __lhs.get() != reinterpret_cast<void*>(__rhs); } 
+
+  template<typename _Tp>
+    inline bool
+    operator!=(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
+    { return __rhs.get() != reinterpret_cast<void*>(__lhs); } 
+
+  /**
+   * Comparison operators for _Pointer_adapter defer to the base class'
+   * comparison operators, when possible.
+   */
+  template<typename _Tp>
+    inline bool
+    operator==(const _Pointer_adapter<_Tp>& __lhs, 
+               const _Pointer_adapter<_Tp>& __rhs)
+    { return __lhs._Tp::operator==(__rhs); }
+
+  template<typename _Tp>
+    inline bool
+    operator<=(const _Pointer_adapter<_Tp>& __lhs, 
+               const _Pointer_adapter<_Tp>& __rhs)
+    { return __lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs); }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const _Pointer_adapter<_Tp>& __lhs, 
+               const _Pointer_adapter<_Tp>& __rhs)
+    { return !(__lhs._Tp::operator==(__rhs)); }
+
+  template<typename _Tp>
+    inline bool
+    operator>(const _Pointer_adapter<_Tp>& __lhs, 
+              const _Pointer_adapter<_Tp>& __rhs)
+    { return !(__lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs)); }
+
+  template<typename _Tp>
+    inline bool
+    operator>=(const _Pointer_adapter<_Tp>& __lhs, 
+               const _Pointer_adapter<_Tp>& __rhs)
+    { return !(__lhs._Tp::operator<(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _StoreT>
+    inline std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os, 
+               const _Pointer_adapter<_StoreT>& __p)
+    { return (__os << __p.get()); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if __cplusplus >= 201103L
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _Storage_policy>
+    struct pointer_traits<__gnu_cxx::_Pointer_adapter<_Storage_policy>>
+    {
+      /// The pointer type
+      typedef __gnu_cxx::_Pointer_adapter<_Storage_policy>         pointer;
+      /// The type pointed to
+      typedef typename pointer::element_type            element_type;
+      /// Type used to represent the difference between two pointers
+      typedef typename pointer::difference_type         difference_type;
+
+      template<typename _Up>
+        using rebind = typename __gnu_cxx::_Pointer_adapter<
+	typename pointer_traits<_Storage_policy>::template rebind<_Up>>;
+
+      static pointer pointer_to(typename pointer::reference __r) noexcept
+      { return pointer(std::addressof(__r)); }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+#endif
+
+#endif // _POINTER_H
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pool_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/pool_allocator.h
new file mode 100644
index 0000000..07bb41e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/pool_allocator.h
@@ -0,0 +1,280 @@
+// Allocators -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/pool_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _POOL_ALLOCATOR_H
+#define _POOL_ALLOCATOR_H 1
+
+#include <bits/c++config.h>
+#include <cstdlib>
+#include <new>
+#include <bits/functexcept.h>
+#include <ext/atomicity.h>
+#include <ext/concurrence.h>
+#include <bits/move.h>
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::ptrdiff_t;
+
+  /**
+   *  @brief  Base class for __pool_alloc.
+   *
+   *  Uses various allocators to fulfill underlying requests (and makes as
+   *  few requests as possible when in default high-speed pool mode).
+   *
+   *  Important implementation properties:
+   *  0. If globally mandated, then allocate objects from new
+   *  1. If the clients request an object of size > _S_max_bytes, the resulting
+   *     object will be obtained directly from new
+   *  2. In all other cases, we allocate an object of size exactly
+   *     _S_round_up(requested_size).  Thus the client has enough size
+   *     information that we can return the object to the proper free list
+   *     without permanently losing part of the object.
+   */
+    class __pool_alloc_base
+    {
+    protected:
+
+      enum { _S_align = 8 };
+      enum { _S_max_bytes = 128 };
+      enum { _S_free_list_size = (size_t)_S_max_bytes / (size_t)_S_align };
+      
+      union _Obj
+      {
+	union _Obj* _M_free_list_link;
+	char        _M_client_data[1];    // The client sees this.
+      };
+      
+      static _Obj* volatile         _S_free_list[_S_free_list_size];
+
+      // Chunk allocation state.
+      static char*                  _S_start_free;
+      static char*                  _S_end_free;
+      static size_t                 _S_heap_size;     
+      
+      size_t
+      _M_round_up(size_t __bytes)
+      { return ((__bytes + (size_t)_S_align - 1) & ~((size_t)_S_align - 1)); }
+      
+      _GLIBCXX_CONST _Obj* volatile*
+      _M_get_free_list(size_t __bytes) throw ();
+    
+      __mutex&
+      _M_get_mutex() throw ();
+
+      // Returns an object of size __n, and optionally adds to size __n
+      // free list.
+      void*
+      _M_refill(size_t __n);
+      
+      // Allocates a chunk for nobjs of size size.  nobjs may be reduced
+      // if it is inconvenient to allocate the requested number.
+      char*
+      _M_allocate_chunk(size_t __n, int& __nobjs);
+    };
+
+
+  /**
+   * @brief  Allocator using a memory pool with a single lock.
+   * @ingroup allocators
+   */
+  template<typename _Tp>
+    class __pool_alloc : private __pool_alloc_base
+    {
+    private:
+      static _Atomic_word	    _S_force_new;
+
+    public:
+      typedef size_t     size_type;
+      typedef ptrdiff_t  difference_type;
+      typedef _Tp*       pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp&       reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp        value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef __pool_alloc<_Tp1> other; };
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. propagate_on_container_move_assignment
+      typedef std::true_type propagate_on_container_move_assignment;
+#endif
+
+      __pool_alloc() _GLIBCXX_USE_NOEXCEPT { }
+
+      __pool_alloc(const __pool_alloc&) _GLIBCXX_USE_NOEXCEPT { }
+
+      template<typename _Tp1>
+        __pool_alloc(const __pool_alloc<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
+
+      ~__pool_alloc() _GLIBCXX_USE_NOEXCEPT { }
+
+      pointer
+      address(reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      const_pointer
+      address(const_reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      size_type
+      max_size() const _GLIBCXX_USE_NOEXCEPT 
+      { return size_t(-1) / sizeof(_Tp); }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p) { __p->~_Up(); }
+#else
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 402. wrong new expression in [some_] allocator::construct
+      void 
+      construct(pointer __p, const _Tp& __val) 
+      { ::new((void *)__p) _Tp(__val); }
+
+      void 
+      destroy(pointer __p) { __p->~_Tp(); }
+#endif
+
+      pointer
+      allocate(size_type __n, const void* = 0);
+
+      void
+      deallocate(pointer __p, size_type __n);      
+    };
+
+  template<typename _Tp>
+    inline bool
+    operator==(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
+    { return true; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
+    { return false; }
+
+  template<typename _Tp>
+    _Atomic_word
+    __pool_alloc<_Tp>::_S_force_new;
+
+  template<typename _Tp>
+    _Tp*
+    __pool_alloc<_Tp>::allocate(size_type __n, const void*)
+    {
+      pointer __ret = 0;
+      if (__builtin_expect(__n != 0, true))
+	{
+	  if (__n > this->max_size())
+	    std::__throw_bad_alloc();
+
+	  // If there is a race through here, assume answer from getenv
+	  // will resolve in same direction.  Inspired by techniques
+	  // to efficiently support threading found in basic_string.h.
+	  if (_S_force_new == 0)
+	    {
+	      if (std::getenv("GLIBCXX_FORCE_NEW"))
+		__atomic_add_dispatch(&_S_force_new, 1);
+	      else
+		__atomic_add_dispatch(&_S_force_new, -1);
+	    }
+
+	  const size_t __bytes = __n * sizeof(_Tp);	      
+	  if (__bytes > size_t(_S_max_bytes) || _S_force_new > 0)
+	    __ret = static_cast<_Tp*>(::operator new(__bytes));
+	  else
+	    {
+	      _Obj* volatile* __free_list = _M_get_free_list(__bytes);
+	      
+	      __scoped_lock sentry(_M_get_mutex());
+	      _Obj* __restrict__ __result = *__free_list;
+	      if (__builtin_expect(__result == 0, 0))
+		__ret = static_cast<_Tp*>(_M_refill(_M_round_up(__bytes)));
+	      else
+		{
+		  *__free_list = __result->_M_free_list_link;
+		  __ret = reinterpret_cast<_Tp*>(__result);
+		}
+	      if (__ret == 0)
+		std::__throw_bad_alloc();
+	    }
+	}
+      return __ret;
+    }
+
+  template<typename _Tp>
+    void
+    __pool_alloc<_Tp>::deallocate(pointer __p, size_type __n)
+    {
+      if (__builtin_expect(__n != 0 && __p != 0, true))
+	{
+	  const size_t __bytes = __n * sizeof(_Tp);
+	  if (__bytes > static_cast<size_t>(_S_max_bytes) || _S_force_new > 0)
+	    ::operator delete(__p);
+	  else
+	    {
+	      _Obj* volatile* __free_list = _M_get_free_list(__bytes);
+	      _Obj* __q = reinterpret_cast<_Obj*>(__p);
+
+	      __scoped_lock sentry(_M_get_mutex());
+	      __q ->_M_free_list_link = *__free_list;
+	      *__free_list = __q;
+	    }
+	}
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/random b/gcc-4.9/libstdc++-v3/include/ext/random
new file mode 100644
index 0000000..2c9462f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/random
@@ -0,0 +1,3119 @@
+// Random number extensions -*- C++ -*-
+
+// Copyright (C) 2012-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/random
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _EXT_RANDOM
+#define _EXT_RANDOM 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <random>
+#include <array>
+#include <ext/cmath>
+#ifdef __SSE2__
+# include <x86intrin.h>
+#endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+  /* Mersenne twister implementation optimized for vector operations.
+   *
+   * Reference: http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/
+   */
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    class simd_fast_mersenne_twister_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+		    "substituting _UIntType not an unsigned integral type");
+      static_assert(__sr1 < 32, "first right shift too large");
+      static_assert(__sr2 < 16, "second right shift too large");
+      static_assert(__sl1 < 32, "first left shift too large");
+      static_assert(__sl2 < 16, "second left shift too large");
+
+    public:
+      typedef _UIntType result_type;
+
+    private:
+      static constexpr size_t m_w = sizeof(result_type) * 8;
+      static constexpr size_t _M_nstate = __m / 128 + 1;
+      static constexpr size_t _M_nstate32 = _M_nstate * 4;
+
+      static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+		    "substituting _UIntType not an unsigned integral type");
+      static_assert(__pos1 < _M_nstate, "POS1 not smaller than state size");
+      static_assert(16 % sizeof(_UIntType) == 0,
+		    "UIntType size must divide 16");
+
+    public:
+      static constexpr size_t state_size = _M_nstate * (16
+							/ sizeof(result_type));
+      static constexpr result_type default_seed = 5489u;
+
+      // constructors and member function
+      explicit
+      simd_fast_mersenne_twister_engine(result_type __sd = default_seed)
+      { seed(__sd); }
+
+      template<typename _Sseq, typename = typename
+	std::enable_if<!std::is_same<_Sseq,
+				     simd_fast_mersenne_twister_engine>::value>
+	       ::type>
+	explicit
+	simd_fast_mersenne_twister_engine(_Sseq& __q)
+	{ seed(__q); }
+
+      void
+      seed(result_type __sd = default_seed);
+
+      template<typename _Sseq>
+	typename std::enable_if<std::is_class<_Sseq>::value>::type
+	seed(_Sseq& __q);
+
+      static constexpr result_type
+      min()
+      { return 0; };
+
+      static constexpr result_type
+      max()
+      { return std::numeric_limits<result_type>::max(); }
+
+      void
+      discard(unsigned long long __z);
+
+      result_type
+      operator()()
+      {
+	if (__builtin_expect(_M_pos >= state_size, 0))
+	  _M_gen_rand();
+
+	return _M_stateT[_M_pos++];
+      }
+
+      template<typename _UIntType_2, size_t __m_2,
+	       size_t __pos1_2, size_t __sl1_2, size_t __sl2_2,
+	       size_t __sr1_2, size_t __sr2_2,
+	       uint32_t __msk1_2, uint32_t __msk2_2,
+	       uint32_t __msk3_2, uint32_t __msk4_2,
+	       uint32_t __parity1_2, uint32_t __parity2_2,
+	       uint32_t __parity3_2, uint32_t __parity4_2>
+	friend bool
+	operator==(const simd_fast_mersenne_twister_engine<_UIntType_2,
+		   __m_2, __pos1_2, __sl1_2, __sl2_2, __sr1_2, __sr2_2,
+		   __msk1_2, __msk2_2, __msk3_2, __msk4_2,
+		   __parity1_2, __parity2_2, __parity3_2, __parity4_2>& __lhs,
+		   const simd_fast_mersenne_twister_engine<_UIntType_2,
+		   __m_2, __pos1_2, __sl1_2, __sl2_2, __sr1_2, __sr2_2,
+		   __msk1_2, __msk2_2, __msk3_2, __msk4_2,
+		   __parity1_2, __parity2_2, __parity3_2, __parity4_2>& __rhs);
+
+      template<typename _UIntType_2, size_t __m_2,
+	       size_t __pos1_2, size_t __sl1_2, size_t __sl2_2,
+	       size_t __sr1_2, size_t __sr2_2,
+	       uint32_t __msk1_2, uint32_t __msk2_2,
+	       uint32_t __msk3_2, uint32_t __msk4_2,
+	       uint32_t __parity1_2, uint32_t __parity2_2,
+	       uint32_t __parity3_2, uint32_t __parity4_2,
+	       typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const __gnu_cxx::simd_fast_mersenne_twister_engine
+		   <_UIntType_2,
+		   __m_2, __pos1_2, __sl1_2, __sl2_2, __sr1_2, __sr2_2,
+		   __msk1_2, __msk2_2, __msk3_2, __msk4_2,
+		   __parity1_2, __parity2_2, __parity3_2, __parity4_2>& __x);
+
+      template<typename _UIntType_2, size_t __m_2,
+	       size_t __pos1_2, size_t __sl1_2, size_t __sl2_2,
+	       size_t __sr1_2, size_t __sr2_2,
+	       uint32_t __msk1_2, uint32_t __msk2_2,
+	       uint32_t __msk3_2, uint32_t __msk4_2,
+	       uint32_t __parity1_2, uint32_t __parity2_2,
+	       uint32_t __parity3_2, uint32_t __parity4_2,
+	       typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType_2,
+		   __m_2, __pos1_2, __sl1_2, __sl2_2, __sr1_2, __sr2_2,
+		   __msk1_2, __msk2_2, __msk3_2, __msk4_2,
+		   __parity1_2, __parity2_2, __parity3_2, __parity4_2>& __x);
+
+    private:
+      union
+      {
+#ifdef __SSE2__
+	__m128i _M_state[_M_nstate];
+#endif
+	uint32_t _M_state32[_M_nstate32];
+	result_type _M_stateT[state_size];
+      } __attribute__ ((__aligned__ (16)));
+      size_t _M_pos;
+
+      void _M_gen_rand(void);
+      void _M_period_certification();
+  };
+
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    inline bool
+    operator!=(const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+	       __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3,
+	       __msk4, __parity1, __parity2, __parity3, __parity4>& __lhs,
+	       const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+	       __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3,
+	       __msk4, __parity1, __parity2, __parity3, __parity4>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+  /* Definitions for the SIMD-oriented Fast Mersenne Twister as defined
+   * in the C implementation by Daito and Matsumoto, as both a 32-bit
+   * and 64-bit version.
+   */
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 607, 2,
+					    15, 3, 13, 3,
+					    0xfdff37ffU, 0xef7f3f7dU,
+					    0xff777b7dU, 0x7ff7fb2fU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x5986f054U>
+    sfmt607;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 607, 2,
+					    15, 3, 13, 3,
+					    0xfdff37ffU, 0xef7f3f7dU,
+					    0xff777b7dU, 0x7ff7fb2fU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x5986f054U>
+    sfmt607_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 1279, 7,
+					    14, 3, 5, 1,
+					    0xf7fefffdU, 0x7fefcfffU,
+					    0xaff3ef3fU, 0xb5ffff7fU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x20000000U>
+    sfmt1279;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 1279, 7,
+					    14, 3, 5, 1,
+					    0xf7fefffdU, 0x7fefcfffU,
+					    0xaff3ef3fU, 0xb5ffff7fU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x20000000U>
+    sfmt1279_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 2281, 12,
+					    19, 1, 5, 1,
+					    0xbff7ffbfU, 0xfdfffffeU,
+					    0xf7ffef7fU, 0xf2f7cbbfU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x41dfa600U>
+    sfmt2281;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 2281, 12,
+					    19, 1, 5, 1,
+					    0xbff7ffbfU, 0xfdfffffeU,
+					    0xf7ffef7fU, 0xf2f7cbbfU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x41dfa600U>
+    sfmt2281_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 4253, 17,
+					    20, 1, 7, 1,
+					    0x9f7bffffU, 0x9fffff5fU,
+					    0x3efffffbU, 0xfffff7bbU,
+					    0xa8000001U, 0xaf5390a3U,
+					    0xb740b3f8U, 0x6c11486dU>
+    sfmt4253;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 4253, 17,
+					    20, 1, 7, 1,
+					    0x9f7bffffU, 0x9fffff5fU,
+					    0x3efffffbU, 0xfffff7bbU,
+					    0xa8000001U, 0xaf5390a3U,
+					    0xb740b3f8U, 0x6c11486dU>
+    sfmt4253_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 11213, 68,
+					    14, 3, 7, 3,
+					    0xeffff7fbU, 0xffffffefU,
+					    0xdfdfbfffU, 0x7fffdbfdU,
+					    0x00000001U, 0x00000000U,
+					    0xe8148000U, 0xd0c7afa3U>
+    sfmt11213;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 11213, 68,
+					    14, 3, 7, 3,
+					    0xeffff7fbU, 0xffffffefU,
+					    0xdfdfbfffU, 0x7fffdbfdU,
+					    0x00000001U, 0x00000000U,
+					    0xe8148000U, 0xd0c7afa3U>
+    sfmt11213_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 19937, 122,
+					    18, 1, 11, 1,
+					    0xdfffffefU, 0xddfecb7fU,
+					    0xbffaffffU, 0xbffffff6U,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x13c9e684U>
+    sfmt19937;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 19937, 122,
+					    18, 1, 11, 1,
+					    0xdfffffefU, 0xddfecb7fU,
+					    0xbffaffffU, 0xbffffff6U,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0x13c9e684U>
+    sfmt19937_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 44497, 330,
+					    5, 3, 9, 3,
+					    0xeffffffbU, 0xdfbebfffU,
+					    0xbfbf7befU, 0x9ffd7bffU,
+					    0x00000001U, 0x00000000U,
+					    0xa3ac4000U, 0xecc1327aU>
+    sfmt44497;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 44497, 330,
+					    5, 3, 9, 3,
+					    0xeffffffbU, 0xdfbebfffU,
+					    0xbfbf7befU, 0x9ffd7bffU,
+					    0x00000001U, 0x00000000U,
+					    0xa3ac4000U, 0xecc1327aU>
+    sfmt44497_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 86243, 366,
+					    6, 7, 19, 1,
+					    0xfdbffbffU, 0xbff7ff3fU,
+					    0xfd77efffU, 0xbf9ff3ffU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0xe9528d85U>
+    sfmt86243;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 86243, 366,
+					    6, 7, 19, 1,
+					    0xfdbffbffU, 0xbff7ff3fU,
+					    0xfd77efffU, 0xbf9ff3ffU,
+					    0x00000001U, 0x00000000U,
+					    0x00000000U, 0xe9528d85U>
+    sfmt86243_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 132049, 110,
+					    19, 1, 21, 1,
+					    0xffffbb5fU, 0xfb6ebf95U,
+					    0xfffefffaU, 0xcff77fffU,
+					    0x00000001U, 0x00000000U,
+					    0xcb520000U, 0xc7e91c7dU>
+    sfmt132049;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 132049, 110,
+					    19, 1, 21, 1,
+					    0xffffbb5fU, 0xfb6ebf95U,
+					    0xfffefffaU, 0xcff77fffU,
+					    0x00000001U, 0x00000000U,
+					    0xcb520000U, 0xc7e91c7dU>
+    sfmt132049_64;
+
+
+  typedef simd_fast_mersenne_twister_engine<uint32_t, 216091, 627,
+					    11, 3, 10, 1,
+					    0xbff7bff7U, 0xbfffffffU,
+					    0xbffffa7fU, 0xffddfbfbU,
+					    0xf8000001U, 0x89e80709U,
+					    0x3bd2b64bU, 0x0c64b1e4U>
+    sfmt216091;
+
+  typedef simd_fast_mersenne_twister_engine<uint64_t, 216091, 627,
+					    11, 3, 10, 1,
+					    0xbff7bff7U, 0xbfffffffU,
+					    0xbffffa7fU, 0xffddfbfbU,
+					    0xf8000001U, 0x89e80709U,
+					    0x3bd2b64bU, 0x0c64b1e4U>
+    sfmt216091_64;
+
+#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+  /**
+   * @brief A beta continuous distribution for random numbers.
+   *
+   * The formula for the beta probability density function is:
+   * @f[
+   *     p(x|\alpha,\beta) = \frac{1}{B(\alpha,\beta)}
+   *                         x^{\alpha - 1} (1 - x)^{\beta - 1}
+   * @f]
+   */
+  template<typename _RealType = double>
+    class beta_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef beta_distribution<_RealType> distribution_type;
+	friend class beta_distribution<_RealType>;
+
+	explicit
+	param_type(_RealType __alpha_val = _RealType(1),
+		   _RealType __beta_val = _RealType(1))
+	: _M_alpha(__alpha_val), _M_beta(__beta_val)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
+	  _GLIBCXX_DEBUG_ASSERT(_M_beta > _RealType(0));
+	}
+
+	_RealType
+	alpha() const
+	{ return _M_alpha; }
+
+	_RealType
+	beta() const
+	{ return _M_beta; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return (__p1._M_alpha == __p2._M_alpha
+		  && __p1._M_beta == __p2._M_beta); }
+
+      private:
+	void
+	_M_initialize();
+
+	_RealType _M_alpha;
+	_RealType _M_beta;
+      };
+
+    public:
+      /**
+       * @brief Constructs a beta distribution with parameters
+       * @f$\alpha@f$ and @f$\beta@f$.
+       */
+      explicit
+      beta_distribution(_RealType __alpha_val = _RealType(1),
+			_RealType __beta_val = _RealType(1))
+      : _M_param(__alpha_val, __beta_val)
+      { }
+
+      explicit
+      beta_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Returns the @f$\alpha@f$ of the distribution.
+       */
+      _RealType
+      alpha() const
+      { return _M_param.alpha(); }
+
+      /**
+       * @brief Returns the @f$\beta@f$ of the distribution.
+       */
+      _RealType
+      beta() const
+      { return _M_param.beta(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return result_type(1); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two beta distributions have the same
+       *        parameters and the sequences that would be generated
+       *        are equal.
+       */
+      friend bool
+      operator==(const beta_distribution& __d1,
+		 const beta_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
+       * @brief Inserts a %beta_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %beta_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const __gnu_cxx::beta_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %beta_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %beta_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   __gnu_cxx::beta_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two beta distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const __gnu_cxx::beta_distribution<_RealType>& __d1,
+	       const __gnu_cxx::beta_distribution<_RealType>& __d2)
+   { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A multi-variate normal continuous distribution for random numbers.
+   *
+   * The formula for the normal probability density function is
+   * @f[
+   *     p(\overrightarrow{x}|\overrightarrow{\mu },\Sigma) =
+   *       \frac{1}{\sqrt{(2\pi )^k\det(\Sigma))}}
+   *       e^{-\frac{1}{2}(\overrightarrow{x}-\overrightarrow{\mu})^\text{T}
+   *          \Sigma ^{-1}(\overrightarrow{x}-\overrightarrow{\mu})}
+   * @f]
+   *
+   * where @f$\overrightarrow{x}@f$ and @f$\overrightarrow{\mu}@f$ are
+   * vectors of dimension @f$k@f$ and @f$\Sigma@f$ is the covariance
+   * matrix (which must be positive-definite).
+   */
+  template<std::size_t _Dimen, typename _RealType = double>
+    class normal_mv_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+      static_assert(_Dimen != 0, "dimension is zero");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef std::array<_RealType, _Dimen> result_type;
+      /** Parameter type. */
+      class param_type
+      {
+	static constexpr size_t _M_t_size = _Dimen * (_Dimen + 1) / 2;
+
+      public:
+	typedef normal_mv_distribution<_Dimen, _RealType> distribution_type;
+	friend class normal_mv_distribution<_Dimen, _RealType>;
+
+	param_type()
+	{
+	  std::fill(_M_mean.begin(), _M_mean.end(), _RealType(0));
+	  auto __it = _M_t.begin();
+	  for (size_t __i = 0; __i < _Dimen; ++__i)
+	    {
+	      std::fill_n(__it, __i, _RealType(0));
+	      __it += __i;
+	      *__it++ = _RealType(1);
+	    }
+	}
+
+	template<typename _ForwardIterator1, typename _ForwardIterator2>
+	  param_type(_ForwardIterator1 __meanbegin,
+		     _ForwardIterator1 __meanend,
+		     _ForwardIterator2 __varcovbegin,
+		     _ForwardIterator2 __varcovend)
+	{
+	  __glibcxx_function_requires(_ForwardIteratorConcept<
+				      _ForwardIterator1>)
+	  __glibcxx_function_requires(_ForwardIteratorConcept<
+				      _ForwardIterator2>)
+	  _GLIBCXX_DEBUG_ASSERT(std::distance(__meanbegin, __meanend)
+				<= _Dimen);
+	  const auto __dist = std::distance(__varcovbegin, __varcovend);
+	  _GLIBCXX_DEBUG_ASSERT(__dist == _Dimen * _Dimen
+				|| __dist == _Dimen * (_Dimen + 1) / 2
+				|| __dist == _Dimen);
+
+	  if (__dist == _Dimen * _Dimen)
+	    _M_init_full(__meanbegin, __meanend, __varcovbegin, __varcovend);
+	  else if (__dist == _Dimen * (_Dimen + 1) / 2)
+	    _M_init_lower(__meanbegin, __meanend, __varcovbegin, __varcovend);
+	  else
+	    _M_init_diagonal(__meanbegin, __meanend,
+			     __varcovbegin, __varcovend);
+	}
+
+	param_type(std::initializer_list<_RealType> __mean,
+		   std::initializer_list<_RealType> __varcov)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(__mean.size() <= _Dimen);
+	  _GLIBCXX_DEBUG_ASSERT(__varcov.size() == _Dimen * _Dimen
+				|| __varcov.size() == _Dimen * (_Dimen + 1) / 2
+				|| __varcov.size() == _Dimen);
+
+	  if (__varcov.size() == _Dimen * _Dimen)
+	    _M_init_full(__mean.begin(), __mean.end(),
+			 __varcov.begin(), __varcov.end());
+	  else if (__varcov.size() == _Dimen * (_Dimen + 1) / 2)
+	    _M_init_lower(__mean.begin(), __mean.end(),
+			  __varcov.begin(), __varcov.end());
+	  else
+	    _M_init_diagonal(__mean.begin(), __mean.end(),
+			     __varcov.begin(), __varcov.end());
+	}
+
+	std::array<_RealType, _Dimen>
+	mean() const
+	{ return _M_mean; }
+
+	std::array<_RealType, _M_t_size>
+	varcov() const
+	{ return _M_t; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_mean == __p2._M_mean && __p1._M_t == __p2._M_t; }
+
+      private:
+	template <typename _InputIterator1, typename _InputIterator2>
+	  void _M_init_full(_InputIterator1 __meanbegin,
+			    _InputIterator1 __meanend,
+			    _InputIterator2 __varcovbegin,
+			    _InputIterator2 __varcovend);
+	template <typename _InputIterator1, typename _InputIterator2>
+	  void _M_init_lower(_InputIterator1 __meanbegin,
+			     _InputIterator1 __meanend,
+			     _InputIterator2 __varcovbegin,
+			     _InputIterator2 __varcovend);
+	template <typename _InputIterator1, typename _InputIterator2>
+	  void _M_init_diagonal(_InputIterator1 __meanbegin,
+				_InputIterator1 __meanend,
+				_InputIterator2 __varbegin,
+				_InputIterator2 __varend);
+
+	std::array<_RealType, _Dimen> _M_mean;
+	std::array<_RealType, _M_t_size> _M_t;
+      };
+
+    public:
+      normal_mv_distribution()
+      : _M_param(), _M_nd()
+      { }
+
+      template<typename _ForwardIterator1, typename _ForwardIterator2>
+	normal_mv_distribution(_ForwardIterator1 __meanbegin,
+			       _ForwardIterator1 __meanend,
+			       _ForwardIterator2 __varcovbegin,
+			       _ForwardIterator2 __varcovend)
+	: _M_param(__meanbegin, __meanend, __varcovbegin, __varcovend),
+	  _M_nd()
+	{ }
+
+      normal_mv_distribution(std::initializer_list<_RealType> __mean,
+			     std::initializer_list<_RealType> __varcov)
+      : _M_param(__mean, __varcov), _M_nd()
+      { }
+
+      explicit
+      normal_mv_distribution(const param_type& __p)
+      : _M_param(__p), _M_nd()
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      /**
+       * @brief Returns the mean of the distribution.
+       */
+      result_type
+      mean() const
+      { return _M_param.mean(); }
+
+      /**
+       * @brief Returns the compact form of the variance/covariance
+       * matrix of the distribution.
+       */
+      std::array<_RealType, _Dimen * (_Dimen + 1) / 2>
+      varcov() const
+      { return _M_param.varcov(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { result_type __res;
+	__res.fill(std::numeric_limits<_RealType>::lowest());
+	return __res; }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { result_type __res;
+	__res.fill(std::numeric_limits<_RealType>::max());
+	return __res; }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ return this->__generate_impl(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ return this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two multi-variant normal distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      template<size_t _Dimen1, typename _RealType1>
+	friend bool
+	operator==(const
+		   __gnu_cxx::normal_mv_distribution<_Dimen1, _RealType1>&
+		   __d1,
+		   const
+		   __gnu_cxx::normal_mv_distribution<_Dimen1, _RealType1>&
+		   __d2);
+
+      /**
+       * @brief Inserts a %normal_mv_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %normal_mv_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<size_t _Dimen1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const
+		   __gnu_cxx::normal_mv_distribution<_Dimen1, _RealType1>&
+		   __x);
+
+      /**
+       * @brief Extracts a %normal_mv_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %normal_mv_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<size_t _Dimen1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   __gnu_cxx::normal_mv_distribution<_Dimen1, _RealType1>&
+		   __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+      std::normal_distribution<_RealType> _M_nd;
+  };
+
+  /**
+   * @brief Return true if two multi-variate normal distributions are
+   * different.
+   */
+  template<size_t _Dimen, typename _RealType>
+    inline bool
+    operator!=(const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
+	       __d1,
+	       const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
+	       __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A Rice continuous distribution for random numbers.
+   *
+   * The formula for the Rice probability density function is
+   * @f[
+   *     p(x|\nu,\sigma) = \frac{x}{\sigma^2}
+   *                       \exp\left(-\frac{x^2+\nu^2}{2\sigma^2}\right)
+   *                       I_0\left(\frac{x \nu}{\sigma^2}\right)
+   * @f]
+   * where @f$I_0(z)@f$ is the modified Bessel function of the first kind
+   * of order 0 and @f$\nu >= 0@f$ and @f$\sigma > 0@f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$\sqrt{\pi/2}L_{1/2}(-\nu^2/2\sigma^2)@f$</td></tr>
+   * <tr><td>Variance</td><td>@f$2\sigma^2 + \nu^2
+   *                   + (\pi\sigma^2/2)L^2_{1/2}(-\nu^2/2\sigma^2)@f$</td></tr>
+   * <tr><td>Range</td><td>@f$[0, \infty)@f$</td></tr>
+   * </table>
+   * where @f$L_{1/2}(x)@f$ is the Laguerre polynomial of order 1/2.
+   */
+  template<typename _RealType = double>
+    class
+    rice_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef rice_distribution<result_type> distribution_type;
+
+	param_type(result_type __nu_val = result_type(0),
+		   result_type __sigma_val = result_type(1))
+	: _M_nu(__nu_val), _M_sigma(__sigma_val)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_nu >= result_type(0));
+	  _GLIBCXX_DEBUG_ASSERT(_M_sigma > result_type(0));
+	}
+
+	result_type
+	nu() const
+	{ return _M_nu; }
+
+	result_type
+	sigma() const
+	{ return _M_sigma; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_nu == __p2._M_nu
+	      && __p1._M_sigma == __p2._M_sigma; }
+
+      private:
+	void _M_initialize();
+
+	result_type _M_nu;
+	result_type _M_sigma;
+      };
+
+      /**
+       * @brief Constructors.
+       */
+      explicit
+      rice_distribution(result_type __nu_val = result_type(0),
+			result_type __sigma_val = result_type(1))
+      : _M_param(__nu_val, __sigma_val),
+	_M_ndx(__nu_val, __sigma_val),
+	_M_ndy(result_type(0), __sigma_val)
+      { }
+
+      explicit
+      rice_distribution(const param_type& __p)
+      : _M_param(__p),
+	_M_ndx(__p.nu(), __p.sigma()),
+	_M_ndy(result_type(0), __p.sigma())
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      {
+	_M_ndx.reset();
+	_M_ndy.reset();
+      }
+
+      /**
+       * @brief Return the parameters of the distribution.
+       */
+      result_type
+      nu() const
+      { return _M_param.nu(); }
+
+      result_type
+      sigma() const
+      { return _M_param.sigma(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{
+	  result_type __x = this->_M_ndx(__urng);
+	  result_type __y = this->_M_ndy(__urng);
+#if _GLIBCXX_USE_C99_MATH_TR1
+	  return std::hypot(__x, __y);
+#else
+	  return std::sqrt(__x * __x + __y * __y);
+#endif
+	}
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  typename std::normal_distribution<result_type>::param_type
+	    __px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());
+	  result_type __x = this->_M_ndx(__px, __urng);
+	  result_type __y = this->_M_ndy(__py, __urng);
+#if _GLIBCXX_USE_C99_MATH_TR1
+	  return std::hypot(__x, __y);
+#else
+	  return std::sqrt(__x * __x + __y * __y);
+#endif
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Rice distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const rice_distribution& __d1,
+		 const rice_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_ndx == __d2._M_ndx
+		&& __d1._M_ndy == __d2._M_ndy); }
+
+      /**
+       * @brief Inserts a %rice_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %rice_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>&,
+		   const rice_distribution<_RealType1>&);
+
+      /**
+       * @brief Extracts a %rice_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %rice_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>&,
+		   rice_distribution<_RealType1>&);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::normal_distribution<result_type> _M_ndx;
+      std::normal_distribution<result_type> _M_ndy;
+    };
+
+  /**
+   * @brief Return true if two Rice distributions are not equal.
+   */
+  template<typename _RealType1>
+    inline bool
+    operator!=(const rice_distribution<_RealType1>& __d1,
+	       const rice_distribution<_RealType1>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A Nakagami continuous distribution for random numbers.
+   *
+   * The formula for the Nakagami probability density function is
+   * @f[
+   *     p(x|\mu,\omega) = \frac{2\mu^\mu}{\Gamma(\mu)\omega^\mu}
+   *                       x^{2\mu-1}e^{-\mu x / \omega}
+   * @f]
+   * where @f$\Gamma(z)@f$ is the gamma function and @f$\mu >= 0.5@f$
+   * and @f$\omega > 0@f$.
+   */
+  template<typename _RealType = double>
+    class
+    nakagami_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef nakagami_distribution<result_type> distribution_type;
+
+	param_type(result_type __mu_val = result_type(1),
+		   result_type __omega_val = result_type(1))
+	: _M_mu(__mu_val), _M_omega(__omega_val)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_mu >= result_type(0.5L));
+	  _GLIBCXX_DEBUG_ASSERT(_M_omega > result_type(0));
+	}
+
+	result_type
+	mu() const
+	{ return _M_mu; }
+
+	result_type
+	omega() const
+	{ return _M_omega; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_mu == __p2._M_mu
+	      && __p1._M_omega == __p2._M_omega; }
+
+      private:
+	void _M_initialize();
+
+	result_type _M_mu;
+	result_type _M_omega;
+      };
+
+      /**
+       * @brief Constructors.
+       */
+      explicit
+      nakagami_distribution(result_type __mu_val = result_type(1),
+			    result_type __omega_val = result_type(1))
+      : _M_param(__mu_val, __omega_val),
+	_M_gd(__mu_val, __omega_val / __mu_val)
+      { }
+
+      explicit
+      nakagami_distribution(const param_type& __p)
+      : _M_param(__p),
+	_M_gd(__p.mu(), __p.omega() / __p.mu())
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_gd.reset(); }
+
+      /**
+       * @brief Return the parameters of the distribution.
+       */
+      result_type
+      mu() const
+      { return _M_param.mu(); }
+
+      result_type
+      omega() const
+      { return _M_param.omega(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return std::sqrt(this->_M_gd(__urng)); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  typename std::gamma_distribution<result_type>::param_type
+	    __pg(__p.mu(), __p.omega() / __p.mu());
+	  return std::sqrt(this->_M_gd(__pg, __urng));
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Nakagami distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const nakagami_distribution& __d1,
+		 const nakagami_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_gd == __d2._M_gd); }
+
+      /**
+       * @brief Inserts a %nakagami_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %nakagami_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>&,
+		   const nakagami_distribution<_RealType1>&);
+
+      /**
+       * @brief Extracts a %nakagami_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %nakagami_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>&,
+		   nakagami_distribution<_RealType1>&);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::gamma_distribution<result_type> _M_gd;
+    };
+
+  /**
+   * @brief Return true if two Nakagami distributions are not equal.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const nakagami_distribution<_RealType>& __d1,
+	       const nakagami_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A Pareto continuous distribution for random numbers.
+   *
+   * The formula for the Pareto cumulative probability function is
+   * @f[
+   *     P(x|\alpha,\mu) = 1 - \left(\frac{\mu}{x}\right)^\alpha
+   * @f]
+   * The formula for the Pareto probability density function is
+   * @f[
+   *     p(x|\alpha,\mu) = \frac{\alpha + 1}{\mu}
+   *                       \left(\frac{\mu}{x}\right)^{\alpha + 1}
+   * @f]
+   * where @f$x >= \mu@f$ and @f$\mu > 0@f$, @f$\alpha > 0@f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$\alpha \mu / (\alpha - 1)@f$
+   *              for @f$\alpha > 1@f$</td></tr>
+   * <tr><td>Variance</td><td>@f$\alpha \mu^2 / [(\alpha - 1)^2(\alpha - 2)]@f$
+   *              for @f$\alpha > 2@f$</td></tr>
+   * <tr><td>Range</td><td>@f$[\mu, \infty)@f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class
+    pareto_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef pareto_distribution<result_type> distribution_type;
+
+	param_type(result_type __alpha_val = result_type(1),
+		   result_type __mu_val = result_type(1))
+	: _M_alpha(__alpha_val), _M_mu(__mu_val)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_alpha > result_type(0));
+	  _GLIBCXX_DEBUG_ASSERT(_M_mu > result_type(0));
+	}
+
+	result_type
+	alpha() const
+	{ return _M_alpha; }
+
+	result_type
+	mu() const
+	{ return _M_mu; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_alpha == __p2._M_alpha && __p1._M_mu == __p2._M_mu; }
+
+      private:
+	void _M_initialize();
+
+	result_type _M_alpha;
+	result_type _M_mu;
+      };
+
+      /**
+       * @brief Constructors.
+       */
+      explicit
+      pareto_distribution(result_type __alpha_val = result_type(1),
+			  result_type __mu_val = result_type(1))
+      : _M_param(__alpha_val, __mu_val),
+	_M_ud()
+      { }
+
+      explicit
+      pareto_distribution(const param_type& __p)
+      : _M_param(__p),
+	_M_ud()
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      {
+	_M_ud.reset();
+      }
+
+      /**
+       * @brief Return the parameters of the distribution.
+       */
+      result_type
+      alpha() const
+      { return _M_param.alpha(); }
+
+      result_type
+      mu() const
+      { return _M_param.mu(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return this->mu(); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{
+	  return this->mu() * std::pow(this->_M_ud(__urng),
+				       -result_type(1) / this->alpha());
+	}
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  return __p.mu() * std::pow(this->_M_ud(__urng),
+					   -result_type(1) / __p.alpha());
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Pareto distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const pareto_distribution& __d1,
+		 const pareto_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_ud == __d2._M_ud); }
+
+      /**
+       * @brief Inserts a %pareto_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %pareto_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>&,
+		   const pareto_distribution<_RealType1>&);
+
+      /**
+       * @brief Extracts a %pareto_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %pareto_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>&,
+		   pareto_distribution<_RealType1>&);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::uniform_real_distribution<result_type> _M_ud;
+    };
+
+  /**
+   * @brief Return true if two Pareto distributions are not equal.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const pareto_distribution<_RealType>& __d1,
+	       const pareto_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A K continuous distribution for random numbers.
+   *
+   * The formula for the K probability density function is
+   * @f[
+   *     p(x|\lambda, \mu, \nu) = \frac{2}{x}
+   *             \left(\frac{\lambda\nu x}{\mu}\right)^{\frac{\lambda + \nu}{2}}
+   *             \frac{1}{\Gamma(\lambda)\Gamma(\nu)}
+   *             K_{\nu - \lambda}\left(2\sqrt{\frac{\lambda\nu x}{\mu}}\right)
+   * @f]
+   * where @f$I_0(z)@f$ is the modified Bessel function of the second kind
+   * of order @f$\nu - \lambda@f$ and @f$\lambda > 0@f$, @f$\mu > 0@f$
+   * and @f$\nu > 0@f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$\mu@f$</td></tr>
+   * <tr><td>Variance</td><td>@f$\mu^2\frac{\lambda + \nu + 1}{\lambda\nu}@f$</td></tr>
+   * <tr><td>Range</td><td>@f$[0, \infty)@f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class
+    k_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef k_distribution<result_type> distribution_type;
+
+	param_type(result_type __lambda_val = result_type(1),
+		   result_type __mu_val = result_type(1),
+		   result_type __nu_val = result_type(1))
+	: _M_lambda(__lambda_val), _M_mu(__mu_val), _M_nu(__nu_val)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_lambda > result_type(0));
+	  _GLIBCXX_DEBUG_ASSERT(_M_mu > result_type(0));
+	  _GLIBCXX_DEBUG_ASSERT(_M_nu > result_type(0));
+	}
+
+	result_type
+	lambda() const
+	{ return _M_lambda; }
+
+	result_type
+	mu() const
+	{ return _M_mu; }
+
+	result_type
+	nu() const
+	{ return _M_nu; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_lambda == __p2._M_lambda
+	      && __p1._M_mu == __p2._M_mu
+	      && __p1._M_nu == __p2._M_nu; }
+
+      private:
+	void _M_initialize();
+
+	result_type _M_lambda;
+	result_type _M_mu;
+	result_type _M_nu;
+      };
+
+      /**
+       * @brief Constructors.
+       */
+      explicit
+      k_distribution(result_type __lambda_val = result_type(1),
+		     result_type __mu_val = result_type(1),
+		     result_type __nu_val = result_type(1))
+      : _M_param(__lambda_val, __mu_val, __nu_val),
+	_M_gd1(__lambda_val, result_type(1) / __lambda_val),
+	_M_gd2(__nu_val, __mu_val / __nu_val)
+      { }
+
+      explicit
+      k_distribution(const param_type& __p)
+      : _M_param(__p),
+	_M_gd1(__p.lambda(), result_type(1) / __p.lambda()),
+	_M_gd2(__p.nu(), __p.mu() / __p.nu())
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      {
+	_M_gd1.reset();
+	_M_gd2.reset();
+      }
+
+      /**
+       * @brief Return the parameters of the distribution.
+       */
+      result_type
+      lambda() const
+      { return _M_param.lambda(); }
+
+      result_type
+      mu() const
+      { return _M_param.mu(); }
+
+      result_type
+      nu() const
+      { return _M_param.nu(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator&);
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator&, const param_type&);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two K distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const k_distribution& __d1,
+		 const k_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_gd1 == __d2._M_gd1
+		&& __d1._M_gd2 == __d2._M_gd2); }
+
+      /**
+       * @brief Inserts a %k_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %k_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>&,
+		   const k_distribution<_RealType1>&);
+
+      /**
+       * @brief Extracts a %k_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %k_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>&,
+		   k_distribution<_RealType1>&);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::gamma_distribution<result_type> _M_gd1;
+      std::gamma_distribution<result_type> _M_gd2;
+    };
+
+  /**
+   * @brief Return true if two K distributions are not equal.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const k_distribution<_RealType>& __d1,
+	       const k_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief An arcsine continuous distribution for random numbers.
+   *
+   * The formula for the arcsine probability density function is
+   * @f[
+   *     p(x|a,b) = \frac{1}{\pi \sqrt{(x - a)(b - x)}}
+   * @f]
+   * where @f$x >= a@f$ and @f$x <= b@f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$ (a + b) / 2 @f$</td></tr>
+   * <tr><td>Variance</td><td>@f$ (b - a)^2 / 8 @f$</td></tr>
+   * <tr><td>Range</td><td>@f$[a, b]@f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class
+    arcsine_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef arcsine_distribution<result_type> distribution_type;
+
+	param_type(result_type __a = result_type(0),
+		   result_type __b = result_type(1))
+	: _M_a(__a), _M_b(__b)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
+	}
+
+	result_type
+	a() const
+	{ return _M_a; }
+
+	result_type
+	b() const
+	{ return _M_b; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+      private:
+	void _M_initialize();
+
+	result_type _M_a;
+	result_type _M_b;
+      };
+
+      /**
+       * @brief Constructors.
+       */
+      explicit
+      arcsine_distribution(result_type __a = result_type(0),
+			   result_type __b = result_type(1))
+      : _M_param(__a, __b),
+	_M_ud(-1.5707963267948966192313216916397514L,
+	      +1.5707963267948966192313216916397514L)
+      { }
+
+      explicit
+      arcsine_distribution(const param_type& __p)
+      : _M_param(__p),
+	_M_ud(-1.5707963267948966192313216916397514L,
+	      +1.5707963267948966192313216916397514L)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { _M_ud.reset(); }
+
+      /**
+       * @brief Return the parameters of the distribution.
+       */
+      result_type
+      a() const
+      { return _M_param.a(); }
+
+      result_type
+      b() const
+      { return _M_param.b(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return this->a(); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return this->b(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{
+	  result_type __x = std::sin(this->_M_ud(__urng));
+	  return (__x * (this->b() - this->a())
+		  + this->a() + this->b()) / result_type(2);
+	}
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  result_type __x = std::sin(this->_M_ud(__urng));
+	  return (__x * (__p.b() - __p.a())
+		  + __p.a() + __p.b()) / result_type(2);
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two arcsine distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const arcsine_distribution& __d1,
+		 const arcsine_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_ud == __d2._M_ud); }
+
+      /**
+       * @brief Inserts a %arcsine_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %arcsine_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>&,
+		   const arcsine_distribution<_RealType1>&);
+
+      /**
+       * @brief Extracts a %arcsine_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %arcsine_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>&,
+		   arcsine_distribution<_RealType1>&);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      std::uniform_real_distribution<result_type> _M_ud;
+    };
+
+  /**
+   * @brief Return true if two arcsine distributions are not equal.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const arcsine_distribution<_RealType>& __d1,
+	       const arcsine_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A Hoyt continuous distribution for random numbers.
+   *
+   * The formula for the Hoyt probability density function is
+   * @f[
+   *     p(x|q,\omega) = \frac{(1 + q^2)x}{q\omega}
+   *                     \exp\left(-\frac{(1 + q^2)^2 x^2}{4 q^2 \omega}\right)
+   *                       I_0\left(\frac{(1 - q^4) x^2}{4 q^2 \omega}\right)
+   * @f]
+   * where @f$I_0(z)@f$ is the modified Bessel function of the first kind
+   * of order 0 and @f$0 < q < 1@f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$ \sqrt{\frac{2}{\pi}} \sqrt{\frac{\omega}{1 + q^2}}
+   *                       E(1 - q^2) @f$</td></tr>
+   * <tr><td>Variance</td><td>@f$ \omega \left(1 - \frac{2E^2(1 - q^2)}
+   *                                      {\pi (1 + q^2)}\right) @f$</td></tr>
+   * <tr><td>Range</td><td>@f$[0, \infty)@f$</td></tr>
+   * </table>
+   * where @f$E(x)@f$ is the elliptic function of the second kind.
+   */
+  template<typename _RealType = double>
+    class
+    hoyt_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef hoyt_distribution<result_type> distribution_type;
+
+	param_type(result_type __q = result_type(0.5L),
+		   result_type __omega = result_type(1))
+	: _M_q(__q), _M_omega(__omega)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_q > result_type(0));
+	  _GLIBCXX_DEBUG_ASSERT(_M_q < result_type(1));
+	}
+
+	result_type
+	q() const
+	{ return _M_q; }
+
+	result_type
+	omega() const
+	{ return _M_omega; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return __p1._M_q == __p2._M_q
+	      && __p1._M_omega == __p2._M_omega; }
+
+      private:
+	void _M_initialize();
+
+	result_type _M_q;
+	result_type _M_omega;
+      };
+
+      /**
+       * @brief Constructors.
+       */
+      explicit
+      hoyt_distribution(result_type __q = result_type(0.5L),
+			result_type __omega = result_type(1))
+      : _M_param(__q, __omega),
+	_M_ad(result_type(0.5L) * (result_type(1) + __q * __q),
+	      result_type(0.5L) * (result_type(1) + __q * __q)
+				/ (__q * __q)),
+	_M_ed(result_type(1))
+      { }
+
+      explicit
+      hoyt_distribution(const param_type& __p)
+      : _M_param(__p),
+	_M_ad(result_type(0.5L) * (result_type(1) + __p.q() * __p.q()),
+	      result_type(0.5L) * (result_type(1) + __p.q() * __p.q())
+				/ (__p.q() * __p.q())),
+	_M_ed(result_type(1))
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      {
+	_M_ad.reset();
+	_M_ed.reset();
+      }
+
+      /**
+       * @brief Return the parameters of the distribution.
+       */
+      result_type
+      q() const
+      { return _M_param.q(); }
+
+      result_type
+      omega() const
+      { return _M_param.omega(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return result_type(0); }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng);
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two Hoyt distributions have
+       *        the same parameters and the sequences that would
+       *        be generated are equal.
+       */
+      friend bool
+      operator==(const hoyt_distribution& __d1,
+		 const hoyt_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+		&& __d1._M_ad == __d2._M_ad
+		&& __d1._M_ed == __d2._M_ed); }
+
+      /**
+       * @brief Inserts a %hoyt_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %hoyt_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>&,
+		   const hoyt_distribution<_RealType1>&);
+
+      /**
+       * @brief Extracts a %hoyt_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %hoyt_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>&,
+		   hoyt_distribution<_RealType1>&);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+
+      __gnu_cxx::arcsine_distribution<result_type> _M_ad;
+      std::exponential_distribution<result_type> _M_ed;
+    };
+
+  /**
+   * @brief Return true if two Hoyt distributions are not equal.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const hoyt_distribution<_RealType>& __d1,
+	       const hoyt_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A triangular distribution for random numbers.
+   *
+   * The formula for the triangular probability density function is
+   * @f[
+   *                  / 0                          for x < a
+   *     p(x|a,b,c) = | \frac{2(x-a)}{(c-a)(b-a)}  for a <= x <= b
+   *                  | \frac{2(c-x)}{(c-a)(c-b)}  for b < x <= c
+   *                  \ 0                          for c < x
+   * @f]
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$ \frac{a+b+c}{2} @f$</td></tr>
+   * <tr><td>Variance</td><td>@f$ \frac{a^2+b^2+c^2-ab-ac-bc}
+   *                                   {18}@f$</td></tr>
+   * <tr><td>Range</td><td>@f$[a, c]@f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class triangular_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	friend class triangular_distribution<_RealType>;
+
+	explicit
+	param_type(_RealType __a = _RealType(0),
+		   _RealType __b = _RealType(0.5),
+		   _RealType __c = _RealType(1))
+	: _M_a(__a), _M_b(__b), _M_c(__c)
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
+	  _GLIBCXX_DEBUG_ASSERT(_M_b <= _M_c);
+	  _GLIBCXX_DEBUG_ASSERT(_M_a < _M_c);
+
+	  _M_r_ab = (_M_b - _M_a) / (_M_c - _M_a);
+	  _M_f_ab_ac = (_M_b - _M_a) * (_M_c - _M_a);
+	  _M_f_bc_ac = (_M_c - _M_b) * (_M_c - _M_a);
+	}
+
+	_RealType
+	a() const
+	{ return _M_a; }
+
+	_RealType
+	b() const
+	{ return _M_b; }
+
+	_RealType
+	c() const
+	{ return _M_c; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return (__p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b
+		  && __p1._M_c == __p2._M_c); }
+
+      private:
+
+	_RealType _M_a;
+	_RealType _M_b;
+	_RealType _M_c;
+	_RealType _M_r_ab;
+	_RealType _M_f_ab_ac;
+	_RealType _M_f_bc_ac;
+      };
+
+      /**
+       * @brief Constructs a triangle distribution with parameters
+       * @f$ a @f$, @f$ b @f$ and @f$ c @f$.
+       */
+      explicit
+      triangular_distribution(result_type __a = result_type(0),
+			      result_type __b = result_type(0.5),
+			      result_type __c = result_type(1))
+      : _M_param(__a, __b, __c)
+      { }
+
+      explicit
+      triangular_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Returns the @f$ a @f$ of the distribution.
+       */
+      result_type
+      a() const
+      { return _M_param.a(); }
+
+      /**
+       * @brief Returns the @f$ b @f$ of the distribution.
+       */
+      result_type
+      b() const
+      { return _M_param.b(); }
+
+      /**
+       * @brief Returns the @f$ c @f$ of the distribution.
+       */
+      result_type
+      c() const
+      { return _M_param.c(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      { return _M_param._M_a; }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return _M_param._M_c; }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	    __aurng(__urng);
+	  result_type __rnd = __aurng();
+	  if (__rnd <= __p._M_r_ab)
+	    return __p.a() + std::sqrt(__rnd * __p._M_f_ab_ac);
+	  else
+	    return __p.c() - std::sqrt((result_type(1) - __rnd)
+				       * __p._M_f_bc_ac);
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two triangle distributions have the same
+       *        parameters and the sequences that would be generated
+       *        are equal.
+       */
+      friend bool
+      operator==(const triangular_distribution& __d1,
+		 const triangular_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
+       * @brief Inserts a %triangular_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %triangular_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const __gnu_cxx::triangular_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %triangular_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %triangular_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   __gnu_cxx::triangular_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two triangle distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const __gnu_cxx::triangular_distribution<_RealType>& __d1,
+	       const __gnu_cxx::triangular_distribution<_RealType>& __d2)
+   { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A von Mises distribution for random numbers.
+   *
+   * The formula for the von Mises probability density function is
+   * @f[
+   *     p(x|\mu,\kappa) = \frac{e^{\kappa \cos(x-\mu)}}
+   *                            {2\pi I_0(\kappa)}
+   * @f]
+   *
+   * The generating functions use the method according to:
+   *
+   * D. J. Best and N. I. Fisher, 1979. "Efficient Simulation of the
+   * von Mises Distribution", Journal of the Royal Statistical Society.
+   * Series C (Applied Statistics), Vol. 28, No. 2, pp. 152-157.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$ \mu @f$</td></tr>
+   * <tr><td>Variance</td><td>@f$ 1-I_1(\kappa)/I_0(\kappa) @f$</td></tr>
+   * <tr><td>Range</td><td>@f$[-\pi, \pi]@f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class von_mises_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+		    "template argument not a floating point type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _RealType result_type;
+      /** Parameter type. */
+      struct param_type
+      {
+	friend class von_mises_distribution<_RealType>;
+
+	explicit
+	param_type(_RealType __mu = _RealType(0),
+		   _RealType __kappa = _RealType(1))
+	: _M_mu(__mu), _M_kappa(__kappa)
+	{
+	  const _RealType __pi = __gnu_cxx::__math_constants<_RealType>::__pi;
+	  _GLIBCXX_DEBUG_ASSERT(_M_mu >= -__pi && _M_mu <= __pi);
+	  _GLIBCXX_DEBUG_ASSERT(_M_kappa >= _RealType(0));
+
+	  auto __tau = std::sqrt(_RealType(4) * _M_kappa * _M_kappa
+				 + _RealType(1)) + _RealType(1);
+	  auto __rho = ((__tau - std::sqrt(_RealType(2) * __tau))
+			/ (_RealType(2) * _M_kappa));
+	  _M_r = (_RealType(1) + __rho * __rho) / (_RealType(2) * __rho);
+	}
+
+	_RealType
+	mu() const
+	{ return _M_mu; }
+
+	_RealType
+	kappa() const
+	{ return _M_kappa; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return (__p1._M_mu == __p2._M_mu
+		  && __p1._M_kappa == __p2._M_kappa); }
+
+      private:
+	_RealType _M_mu;
+	_RealType _M_kappa;
+	_RealType _M_r;
+      };
+
+      /**
+       * @brief Constructs a von Mises distribution with parameters
+       * @f$\mu@f$ and @f$\kappa@f$.
+       */
+      explicit
+      von_mises_distribution(result_type __mu = result_type(0),
+			     result_type __kappa = result_type(1))
+	: _M_param(__mu, __kappa)
+      { }
+
+      explicit
+      von_mises_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Returns the @f$ \mu @f$ of the distribution.
+       */
+      result_type
+      mu() const
+      { return _M_param.mu(); }
+
+      /**
+       * @brief Returns the @f$ \kappa @f$ of the distribution.
+       */
+      result_type
+      kappa() const
+      { return _M_param.kappa(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return _M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      {
+	return -__gnu_cxx::__math_constants<result_type>::__pi;
+      }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      {
+	return __gnu_cxx::__math_constants<result_type>::__pi;
+      }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{
+	  const result_type __pi
+	    = __gnu_cxx::__math_constants<result_type>::__pi;
+	  std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	    __aurng(__urng);
+
+	  result_type __f;
+	  while (1)
+	    {
+	      result_type __rnd = std::cos(__pi * __aurng());
+	      __f = (result_type(1) + __p._M_r * __rnd) / (__p._M_r + __rnd);
+	      result_type __c = __p._M_kappa * (__p._M_r - __f);
+
+	      result_type __rnd2 = __aurng();
+	      if (__c * (result_type(2) - __c) > __rnd2)
+		break;
+	      if (std::log(__c / __rnd2) >= __c - result_type(1))
+		break;
+	    }
+
+	  result_type __res = std::acos(__f);
+#if _GLIBCXX_USE_C99_MATH_TR1
+	  __res = std::copysign(__res, __aurng() - result_type(0.5));
+#else
+	  if (__aurng() < result_type(0.5))
+	    __res = -__res;
+#endif
+	  __res += __p._M_mu;
+	  if (__res > __pi)
+	    __res -= result_type(2) * __pi;
+	  else if (__res < -__pi)
+	    __res += result_type(2) * __pi;
+	  return __res;
+	}
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      /**
+       * @brief Return true if two von Mises distributions have the same
+       *        parameters and the sequences that would be generated
+       *        are equal.
+       */
+      friend bool
+      operator==(const von_mises_distribution& __d1,
+		 const von_mises_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
+       * @brief Inserts a %von_mises_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %von_mises_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const __gnu_cxx::von_mises_distribution<_RealType1>& __x);
+
+      /**
+       * @brief Extracts a %von_mises_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %von_mises_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   __gnu_cxx::von_mises_distribution<_RealType1>& __x);
+
+    private:
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two von Mises distributions are different.
+   */
+  template<typename _RealType>
+    inline bool
+    operator!=(const __gnu_cxx::von_mises_distribution<_RealType>& __d1,
+	       const __gnu_cxx::von_mises_distribution<_RealType>& __d2)
+   { return !(__d1 == __d2); }
+
+
+  /**
+   * @brief A discrete hypergeometric random number distribution.
+   *
+   * The hypergeometric distribution is a discrete probability distribution
+   * that describes the probability of @p k successes in @p n draws @a without
+   * replacement from a finite population of size @p N containing exactly @p K
+   * successes.
+   *
+   * The formula for the hypergeometric probability density function is
+   * @f[
+   *   p(k|N,K,n) = \frac{\binom{K}{k} \binom{N-K}{n-k}}{\binom{N}{n}}
+   * @f]
+   * where @f$N@f$ is the total population of the distribution,
+   * @f$K@f$ is the total population of the distribution.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$ n\frac{K}{N} @f$</td></tr>
+   * <tr><td>Variance</td><td>@f$ n\frac{K}{N}\frac{N-K}{N}\frac{N-n}{N-1}
+   *   @f$</td></tr>
+   * <tr><td>Range</td><td>@f$[max(0, n+K-N), min(K, n)]@f$</td></tr>
+   * </table>
+   */
+  template<typename _UIntType = unsigned int>
+    class hypergeometric_distribution
+    {
+      static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+		    "substituting _UIntType not an unsigned integral type");
+
+    public:
+      /** The type of the range of the distribution. */
+      typedef _UIntType  result_type;
+
+      /** Parameter type. */
+      struct param_type
+      {
+	typedef hypergeometric_distribution<_UIntType> distribution_type;
+	friend class hypergeometric_distribution<_UIntType>;
+
+	explicit
+	param_type(result_type __N = 10, result_type __K = 5,
+		   result_type __n = 1)
+	: _M_N{__N}, _M_K{__K}, _M_n{__n}
+	{
+	  _GLIBCXX_DEBUG_ASSERT(_M_N >= _M_K);
+	  _GLIBCXX_DEBUG_ASSERT(_M_N >= _M_n);
+	}
+
+	result_type
+	total_size() const
+	{ return _M_N; }
+
+	result_type
+	successful_size() const
+	{ return _M_K; }
+
+	result_type
+	unsuccessful_size() const
+	{ return _M_N - _M_K; }
+
+	result_type
+	total_draws() const
+	{ return _M_n; }
+
+	friend bool
+	operator==(const param_type& __p1, const param_type& __p2)
+	{ return (__p1._M_N == __p2._M_N)
+	      && (__p1._M_K == __p2._M_K)
+	      && (__p1._M_n == __p2._M_n); }
+
+      private:
+
+	result_type _M_N;
+	result_type _M_K;
+	result_type _M_n;
+      };
+
+      // constructors and member function
+      explicit
+      hypergeometric_distribution(result_type __N = 10, result_type __K = 5,
+				  result_type __n = 1)
+      : _M_param{__N, __K, __n}
+      { }
+
+      explicit
+      hypergeometric_distribution(const param_type& __p)
+      : _M_param{__p}
+      { }
+
+      /**
+       * @brief Resets the distribution state.
+       */
+      void
+      reset()
+      { }
+
+      /**
+       * @brief Returns the distribution parameter @p N,
+       *	the total number of items.
+       */
+      result_type
+      total_size() const
+      { return this->_M_param.total_size(); }
+
+      /**
+       * @brief Returns the distribution parameter @p K,
+       *	the total number of successful items.
+       */
+      result_type
+      successful_size() const
+      { return this->_M_param.successful_size(); }
+
+      /**
+       * @brief Returns the total number of unsuccessful items @f$ N - K @f$.
+       */
+      result_type
+      unsuccessful_size() const
+      { return this->_M_param.unsuccessful_size(); }
+
+      /**
+       * @brief Returns the distribution parameter @p n,
+       *	the total number of draws.
+       */
+      result_type
+      total_draws() const
+      { return this->_M_param.total_draws(); }
+
+      /**
+       * @brief Returns the parameter set of the distribution.
+       */
+      param_type
+      param() const
+      { return this->_M_param; }
+
+      /**
+       * @brief Sets the parameter set of the distribution.
+       * @param __param The new parameter set of the distribution.
+       */
+      void
+      param(const param_type& __param)
+      { this->_M_param = __param; }
+
+      /**
+       * @brief Returns the greatest lower bound value of the distribution.
+       */
+      result_type
+      min() const
+      {
+	using _IntType = typename std::make_signed<result_type>::type;
+	return static_cast<result_type>(std::max(static_cast<_IntType>(0),
+		  		static_cast<_IntType>(this->total_draws()
+						- this->unsuccessful_size())));
+      }
+
+      /**
+       * @brief Returns the least upper bound value of the distribution.
+       */
+      result_type
+      max() const
+      { return std::min(this->successful_size(), this->total_draws()); }
+
+      /**
+       * @brief Generating functions.
+       */
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng)
+	{ return this->operator()(__urng, this->_M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+	result_type
+	operator()(_UniformRandomNumberGenerator& __urng,
+		   const param_type& __p);
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng)
+	{ this->__generate(__f, __t, __urng, this->_M_param); }
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate(_ForwardIterator __f, _ForwardIterator __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+	void
+	__generate(result_type* __f, result_type* __t,
+		   _UniformRandomNumberGenerator& __urng,
+		   const param_type& __p)
+	{ this->__generate_impl(__f, __t, __urng, __p); }
+
+       /**
+	* @brief Return true if two hypergeometric distributions have the same
+	*        parameters and the sequences that would be generated
+	*        are equal.
+	*/
+      friend bool
+      operator==(const hypergeometric_distribution& __d1,
+		 const hypergeometric_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
+       * @brief Inserts a %hypergeometric_distribution random number
+       * distribution @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %hypergeometric_distribution random number
+       *             distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _UIntType1, typename _CharT, typename _Traits>
+	friend std::basic_ostream<_CharT, _Traits>&
+	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const __gnu_cxx::hypergeometric_distribution<_UIntType1>&
+                   __x);
+
+      /**
+       * @brief Extracts a %hypergeometric_distribution random number
+       * distribution @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %hypergeometric_distribution random number generator
+       *             distribution.
+       *
+       * @returns The input stream with @p __x extracted or in an error
+       *          state.
+       */
+      template<typename _UIntType1, typename _CharT, typename _Traits>
+	friend std::basic_istream<_CharT, _Traits>&
+	operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   __gnu_cxx::hypergeometric_distribution<_UIntType1>& __x);
+
+    private:
+
+      template<typename _ForwardIterator,
+	       typename _UniformRandomNumberGenerator>
+	void
+	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+			_UniformRandomNumberGenerator& __urng,
+			const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  /**
+   * @brief Return true if two hypergeometric distributions are different.
+   */
+  template<typename _UIntType>
+    inline bool
+    operator!=(const __gnu_cxx::hypergeometric_distribution<_UIntType>& __d1,
+	       const __gnu_cxx::hypergeometric_distribution<_UIntType>& __d2)
+    { return !(__d1 == __d2); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
+
+#include "ext/opt_random.h"
+#include "random.tcc"
+
+#endif // _GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif // _EXT_RANDOM
diff --git a/gcc-4.9/libstdc++-v3/include/ext/random.tcc b/gcc-4.9/libstdc++-v3/include/ext/random.tcc
new file mode 100644
index 0000000..dd7a14a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/random.tcc
@@ -0,0 +1,1420 @@
+// Random number extensions -*- C++ -*-
+
+// Copyright (C) 2012-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/random.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/random}
+ */
+
+#ifndef _EXT_RANDOM_TCC
+#define _EXT_RANDOM_TCC 1
+
+#pragma GCC system_header
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    void simd_fast_mersenne_twister_engine<_UIntType, __m,
+					   __pos1, __sl1, __sl2, __sr1, __sr2,
+					   __msk1, __msk2, __msk3, __msk4,
+					   __parity1, __parity2, __parity3,
+					   __parity4>::
+    seed(_UIntType __seed)
+    {
+      _M_state32[0] = static_cast<uint32_t>(__seed);
+      for (size_t __i = 1; __i < _M_nstate32; ++__i)
+	_M_state32[__i] = (1812433253UL
+			   * (_M_state32[__i - 1] ^ (_M_state32[__i - 1] >> 30))
+			   + __i);
+      _M_pos = state_size;
+      _M_period_certification();
+    }
+
+
+  namespace {
+
+    inline uint32_t _Func1(uint32_t __x)
+    {
+      return (__x ^ (__x >> 27)) * UINT32_C(1664525);
+    }
+
+    inline uint32_t _Func2(uint32_t __x)
+    {
+      return (__x ^ (__x >> 27)) * UINT32_C(1566083941);
+    }
+
+  }
+
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    template<typename _Sseq>
+      typename std::enable_if<std::is_class<_Sseq>::value>::type
+      simd_fast_mersenne_twister_engine<_UIntType, __m,
+					__pos1, __sl1, __sl2, __sr1, __sr2,
+					__msk1, __msk2, __msk3, __msk4,
+					__parity1, __parity2, __parity3,
+					__parity4>::
+      seed(_Sseq& __q)
+      {
+	size_t __lag;
+
+	if (_M_nstate32 >= 623)
+	  __lag = 11;
+	else if (_M_nstate32 >= 68)
+	  __lag = 7;
+	else if (_M_nstate32 >= 39)
+	  __lag = 5;
+	else
+	  __lag = 3;
+	const size_t __mid = (_M_nstate32 - __lag) / 2;
+
+	std::fill(_M_state32, _M_state32 + _M_nstate32, UINT32_C(0x8b8b8b8b));
+	uint32_t __arr[_M_nstate32];
+	__q.generate(__arr + 0, __arr + _M_nstate32);
+
+	uint32_t __r = _Func1(_M_state32[0] ^ _M_state32[__mid]
+			      ^ _M_state32[_M_nstate32  - 1]);
+	_M_state32[__mid] += __r;
+	__r += _M_nstate32;
+	_M_state32[__mid + __lag] += __r;
+	_M_state32[0] = __r;
+
+	for (size_t __i = 1, __j = 0; __j < _M_nstate32; ++__j)
+	  {
+	    __r = _Func1(_M_state32[__i]
+			 ^ _M_state32[(__i + __mid) % _M_nstate32]
+			 ^ _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);
+	    _M_state32[(__i + __mid) % _M_nstate32] += __r;
+	    __r += __arr[__j] + __i;
+	    _M_state32[(__i + __mid + __lag) % _M_nstate32] += __r;
+	    _M_state32[__i] = __r;
+	    __i = (__i + 1) % _M_nstate32;
+	  }
+	for (size_t __j = 0; __j < _M_nstate32; ++__j)
+	  {
+	    const size_t __i = (__j + 1) % _M_nstate32;
+	    __r = _Func2(_M_state32[__i]
+			 + _M_state32[(__i + __mid) % _M_nstate32]
+			 + _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);
+	    _M_state32[(__i + __mid) % _M_nstate32] ^= __r;
+	    __r -= __i;
+	    _M_state32[(__i + __mid + __lag) % _M_nstate32] ^= __r;
+	    _M_state32[__i] = __r;
+	  }
+
+	_M_pos = state_size;
+	_M_period_certification();
+      }
+
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    void simd_fast_mersenne_twister_engine<_UIntType, __m,
+					   __pos1, __sl1, __sl2, __sr1, __sr2,
+					   __msk1, __msk2, __msk3, __msk4,
+					   __parity1, __parity2, __parity3,
+					   __parity4>::
+    _M_period_certification(void)
+    {
+      static const uint32_t __parity[4] = { __parity1, __parity2,
+					    __parity3, __parity4 };
+      uint32_t __inner = 0;
+      for (size_t __i = 0; __i < 4; ++__i)
+	if (__parity[__i] != 0)
+	  __inner ^= _M_state32[__i] & __parity[__i];
+
+      if (__builtin_parity(__inner) & 1)
+	return;
+      for (size_t __i = 0; __i < 4; ++__i)
+	if (__parity[__i] != 0)
+	  {
+	    _M_state32[__i] ^= 1 << (__builtin_ffs(__parity[__i]) - 1);
+	    return;
+	  }
+      __builtin_unreachable();
+    }
+
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    void simd_fast_mersenne_twister_engine<_UIntType, __m,
+					   __pos1, __sl1, __sl2, __sr1, __sr2,
+					   __msk1, __msk2, __msk3, __msk4,
+					   __parity1, __parity2, __parity3,
+					   __parity4>::
+    discard(unsigned long long __z)
+    {
+      while (__z > state_size - _M_pos)
+	{
+	  __z -= state_size - _M_pos;
+
+	  _M_gen_rand();
+	}
+
+      _M_pos += __z;
+    }
+
+
+#ifndef  _GLIBCXX_OPT_HAVE_RANDOM_SFMT_GEN_READ
+
+  namespace {
+
+    template<size_t __shift>
+      inline void __rshift(uint32_t *__out, const uint32_t *__in)
+      {
+	uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
+			 | static_cast<uint64_t>(__in[2]));
+	uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
+			 | static_cast<uint64_t>(__in[0]));
+
+	uint64_t __oh = __th >> (__shift * 8);
+	uint64_t __ol = __tl >> (__shift * 8);
+	__ol |= __th << (64 - __shift * 8);
+	__out[1] = static_cast<uint32_t>(__ol >> 32);
+	__out[0] = static_cast<uint32_t>(__ol);
+	__out[3] = static_cast<uint32_t>(__oh >> 32);
+	__out[2] = static_cast<uint32_t>(__oh);
+      }
+
+
+    template<size_t __shift>
+      inline void __lshift(uint32_t *__out, const uint32_t *__in)
+      {
+	uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
+			 | static_cast<uint64_t>(__in[2]));
+	uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
+			 | static_cast<uint64_t>(__in[0]));
+
+	uint64_t __oh = __th << (__shift * 8);
+	uint64_t __ol = __tl << (__shift * 8);
+	__oh |= __tl >> (64 - __shift * 8);
+	__out[1] = static_cast<uint32_t>(__ol >> 32);
+	__out[0] = static_cast<uint32_t>(__ol);
+	__out[3] = static_cast<uint32_t>(__oh >> 32);
+	__out[2] = static_cast<uint32_t>(__oh);
+      }
+
+
+    template<size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2,
+	     uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4>
+      inline void __recursion(uint32_t *__r,
+			      const uint32_t *__a, const uint32_t *__b,
+			      const uint32_t *__c, const uint32_t *__d)
+      {
+	uint32_t __x[4];
+	uint32_t __y[4];
+
+	__lshift<__sl2>(__x, __a);
+	__rshift<__sr2>(__y, __c);
+	__r[0] = (__a[0] ^ __x[0] ^ ((__b[0] >> __sr1) & __msk1)
+		  ^ __y[0] ^ (__d[0] << __sl1));
+	__r[1] = (__a[1] ^ __x[1] ^ ((__b[1] >> __sr1) & __msk2)
+		  ^ __y[1] ^ (__d[1] << __sl1));
+	__r[2] = (__a[2] ^ __x[2] ^ ((__b[2] >> __sr1) & __msk3)
+		  ^ __y[2] ^ (__d[2] << __sl1));
+	__r[3] = (__a[3] ^ __x[3] ^ ((__b[3] >> __sr1) & __msk4)
+		  ^ __y[3] ^ (__d[3] << __sl1));
+      }
+
+  }
+
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    void simd_fast_mersenne_twister_engine<_UIntType, __m,
+					   __pos1, __sl1, __sl2, __sr1, __sr2,
+					   __msk1, __msk2, __msk3, __msk4,
+					   __parity1, __parity2, __parity3,
+					   __parity4>::
+    _M_gen_rand(void)
+    {
+      const uint32_t *__r1 = &_M_state32[_M_nstate32 - 8];
+      const uint32_t *__r2 = &_M_state32[_M_nstate32 - 4];
+      static constexpr size_t __pos1_32 = __pos1 * 4;
+
+      size_t __i;
+      for (__i = 0; __i < _M_nstate32 - __pos1_32; __i += 4)
+	{
+	  __recursion<__sl1, __sl2, __sr1, __sr2,
+		      __msk1, __msk2, __msk3, __msk4>
+	    (&_M_state32[__i], &_M_state32[__i],
+	     &_M_state32[__i + __pos1_32], __r1, __r2);
+	  __r1 = __r2;
+	  __r2 = &_M_state32[__i];
+	}
+
+      for (; __i < _M_nstate32; __i += 4)
+	{
+	  __recursion<__sl1, __sl2, __sr1, __sr2,
+		      __msk1, __msk2, __msk3, __msk4>
+	    (&_M_state32[__i], &_M_state32[__i],
+	     &_M_state32[__i + __pos1_32 - _M_nstate32], __r1, __r2);
+	  __r1 = __r2;
+	  __r2 = &_M_state32[__i];
+	}
+
+      _M_pos = 0;
+    }
+
+#endif
+
+#ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_OPERATOREQUAL
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4>
+    bool
+    operator==(const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
+	       __msk1, __msk2, __msk3, __msk4,
+	       __parity1, __parity2, __parity3, __parity4>& __lhs,
+	       const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
+	       __msk1, __msk2, __msk3, __msk4,
+	       __parity1, __parity2, __parity3, __parity4>& __rhs)
+    {
+      typedef __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
+	       __msk1, __msk2, __msk3, __msk4,
+	       __parity1, __parity2, __parity3, __parity4> __engine;
+      return (std::equal(__lhs._M_stateT,
+			 __lhs._M_stateT + __engine::state_size,
+			 __rhs._M_stateT)
+	      && __lhs._M_pos == __rhs._M_pos);
+    }
+#endif
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
+	       __msk1, __msk2, __msk3, __msk4,
+	       __parity1, __parity2, __parity3, __parity4>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      for (size_t __i = 0; __i < __x._M_nstate32; ++__i)
+	__os << __x._M_state32[__i] << __space;
+      __os << __x._M_pos;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+
+  template<typename _UIntType, size_t __m,
+	   size_t __pos1, size_t __sl1, size_t __sl2,
+	   size_t __sr1, size_t __sr2,
+	   uint32_t __msk1, uint32_t __msk2,
+	   uint32_t __msk3, uint32_t __msk4,
+	   uint32_t __parity1, uint32_t __parity2,
+	   uint32_t __parity3, uint32_t __parity4,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
+	       __msk1, __msk2, __msk3, __msk4,
+	       __parity1, __parity2, __parity3, __parity4>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::ios_base __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      for (size_t __i = 0; __i < __x._M_nstate32; ++__i)
+	__is >> __x._M_state32[__i];
+      __is >> __x._M_pos;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+  /**
+   * Iteration method due to M.D. J<o:>hnk.
+   *
+   * M.D. J<o:>hnk, Erzeugung von betaverteilten und gammaverteilten
+   * Zufallszahlen, Metrika, Volume 8, 1964
+   */
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename beta_distribution<_RealType>::result_type
+      beta_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	result_type __x, __y;
+	do
+	  {
+	    __x = std::exp(std::log(__aurng()) / __param.alpha());
+	    __y = std::exp(std::log(__aurng()) / __param.beta());
+	  }
+	while (__x + __y > result_type(1));
+
+	return __x / (__x + __y);
+      }
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      beta_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	while (__f != __t)
+	  {
+	    result_type __x, __y;
+	    do
+	      {
+		__x = std::exp(std::log(__aurng()) / __param.alpha());
+		__y = std::exp(std::log(__aurng()) / __param.beta());
+	      }
+	    while (__x + __y > result_type(1));
+
+	    *__f++ = __x / (__x + __y);
+	  }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const __gnu_cxx::beta_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.alpha() << __space << __x.beta();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       __gnu_cxx::beta_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __alpha_val, __beta_val;
+      __is >> __alpha_val >> __beta_val;
+      __x.param(typename __gnu_cxx::beta_distribution<_RealType>::
+		param_type(__alpha_val, __beta_val));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<std::size_t _Dimen, typename _RealType>
+    template<typename _InputIterator1, typename _InputIterator2>
+      void
+      normal_mv_distribution<_Dimen, _RealType>::param_type::
+      _M_init_full(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
+		   _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
+      {
+	__glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+	__glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+	std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
+		  _M_mean.end(), _RealType(0));
+
+	// Perform the Cholesky decomposition
+	auto __w = _M_t.begin();
+	for (size_t __j = 0; __j < _Dimen; ++__j)
+	  {
+	    _RealType __sum = _RealType(0);
+
+	    auto __slitbegin = __w;
+	    auto __cit = _M_t.begin();
+	    for (size_t __i = 0; __i < __j; ++__i)
+	      {
+		auto __slit = __slitbegin;
+		_RealType __s = *__varcovbegin++;
+		for (size_t __k = 0; __k < __i; ++__k)
+		  __s -= *__slit++ * *__cit++;
+
+		*__w++ = __s /= *__cit++;
+		__sum += __s * __s;
+	      }
+
+	    __sum = *__varcovbegin - __sum;
+	    if (__builtin_expect(__sum <= _RealType(0), 0))
+	      std::__throw_runtime_error(__N("normal_mv_distribution::"
+					     "param_type::_M_init_full"));
+	    *__w++ = std::sqrt(__sum);
+
+	    std::advance(__varcovbegin, _Dimen - __j);
+	  }
+      }
+
+  template<std::size_t _Dimen, typename _RealType>
+    template<typename _InputIterator1, typename _InputIterator2>
+      void
+      normal_mv_distribution<_Dimen, _RealType>::param_type::
+      _M_init_lower(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
+		    _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
+      {
+	__glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+	__glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+	std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
+		  _M_mean.end(), _RealType(0));
+
+	// Perform the Cholesky decomposition
+	auto __w = _M_t.begin();
+	for (size_t __j = 0; __j < _Dimen; ++__j)
+	  {
+	    _RealType __sum = _RealType(0);
+
+	    auto __slitbegin = __w;
+	    auto __cit = _M_t.begin();
+	    for (size_t __i = 0; __i < __j; ++__i)
+	      {
+		auto __slit = __slitbegin;
+		_RealType __s = *__varcovbegin++;
+		for (size_t __k = 0; __k < __i; ++__k)
+		  __s -= *__slit++ * *__cit++;
+
+		*__w++ = __s /= *__cit++;
+		__sum += __s * __s;
+	      }
+
+	    __sum = *__varcovbegin++ - __sum;
+	    if (__builtin_expect(__sum <= _RealType(0), 0))
+	      std::__throw_runtime_error(__N("normal_mv_distribution::"
+					     "param_type::_M_init_full"));
+	    *__w++ = std::sqrt(__sum);
+	  }
+      }
+
+  template<std::size_t _Dimen, typename _RealType>
+    template<typename _InputIterator1, typename _InputIterator2>
+      void
+      normal_mv_distribution<_Dimen, _RealType>::param_type::
+      _M_init_diagonal(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
+		       _InputIterator2 __varbegin, _InputIterator2 __varend)
+      {
+	__glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
+	__glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
+	std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
+		  _M_mean.end(), _RealType(0));
+
+	auto __w = _M_t.begin();
+	size_t __step = 0;
+	while (__varbegin != __varend)
+	  {
+	    std::fill_n(__w, __step, _RealType(0));
+	    __w += __step++;
+	    if (__builtin_expect(*__varbegin < _RealType(0), 0))
+	      std::__throw_runtime_error(__N("normal_mv_distribution::"
+					     "param_type::_M_init_diagonal"));
+	    *__w++ = std::sqrt(*__varbegin++);
+	  }
+      }
+
+  template<std::size_t _Dimen, typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename normal_mv_distribution<_Dimen, _RealType>::result_type
+      normal_mv_distribution<_Dimen, _RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	result_type __ret;
+
+	_M_nd.__generate(__ret.begin(), __ret.end(), __urng);
+
+	auto __t_it = __param._M_t.crbegin();
+	for (size_t __i = _Dimen; __i > 0; --__i)
+	  {
+	    _RealType __sum = _RealType(0);
+	    for (size_t __j = __i; __j > 0; --__j)
+	      __sum += __ret[__j - 1] * *__t_it++;
+	    __ret[__i - 1] = __sum;
+	  }
+
+	return __ret;
+      }
+
+  template<std::size_t _Dimen, typename _RealType>
+    template<typename _ForwardIterator, typename _UniformRandomNumberGenerator>
+      void
+      normal_mv_distribution<_Dimen, _RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				    _ForwardIterator>)
+	while (__f != __t)
+	  *__f++ = this->operator()(__urng, __param);
+      }
+
+  template<size_t _Dimen, typename _RealType>
+    bool
+    operator==(const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
+	       __d1,
+	       const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
+	       __d2)
+    {
+      return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd;
+    }
+
+  template<size_t _Dimen, typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      auto __mean = __x._M_param.mean();
+      for (auto __it : __mean)
+	__os << __it << __space;
+      auto __t = __x._M_param.varcov();
+      for (auto __it : __t)
+	__os << __it << __space;
+
+      __os << __x._M_nd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<size_t _Dimen, typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      std::array<_RealType, _Dimen> __mean;
+      for (auto& __it : __mean)
+	__is >> __it;
+      std::array<_RealType, _Dimen * (_Dimen + 1) / 2> __varcov;
+      for (auto& __it : __varcov)
+	__is >> __it;
+
+      __is >> __x._M_nd;
+
+      __x.param(typename normal_mv_distribution<_Dimen, _RealType>::
+		param_type(__mean.begin(), __mean.end(),
+			   __varcov.begin(), __varcov.end()));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      rice_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	while (__f != __t)
+	  {
+	    typename std::normal_distribution<result_type>::param_type
+	      __px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());
+	    result_type __x = this->_M_ndx(__px, __urng);
+	    result_type __y = this->_M_ndy(__py, __urng);
+#if _GLIBCXX_USE_C99_MATH_TR1
+	    *__f++ = std::hypot(__x, __y);
+#else
+	    *__f++ = std::sqrt(__x * __x + __y * __y);
+#endif
+	  }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const rice_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.nu() << __space << __x.sigma();
+      __os << __space << __x._M_ndx;
+      __os << __space << __x._M_ndy;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       rice_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __nu_val, __sigma_val;
+      __is >> __nu_val >> __sigma_val;
+      __is >> __x._M_ndx;
+      __is >> __x._M_ndy;
+      __x.param(typename rice_distribution<_RealType>::
+		param_type(__nu_val, __sigma_val));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      nakagami_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	typename std::gamma_distribution<result_type>::param_type
+	  __pg(__p.mu(), __p.omega() / __p.mu());
+	while (__f != __t)
+	  *__f++ = std::sqrt(this->_M_gd(__pg, __urng));
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const nakagami_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.mu() << __space << __x.omega();
+      __os << __space << __x._M_gd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       nakagami_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __mu_val, __omega_val;
+      __is >> __mu_val >> __omega_val;
+      __is >> __x._M_gd;
+      __x.param(typename nakagami_distribution<_RealType>::
+		param_type(__mu_val, __omega_val));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      pareto_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	result_type __mu_val = __p.mu();
+	result_type __malphinv = -result_type(1) / __p.alpha();
+	while (__f != __t)
+	  *__f++ = __mu_val * std::pow(this->_M_ud(__urng), __malphinv);
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const pareto_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.alpha() << __space << __x.mu();
+      __os << __space << __x._M_ud;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       pareto_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __alpha_val, __mu_val;
+      __is >> __alpha_val >> __mu_val;
+      __is >> __x._M_ud;
+      __x.param(typename pareto_distribution<_RealType>::
+		param_type(__alpha_val, __mu_val));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename k_distribution<_RealType>::result_type
+      k_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	result_type __x = this->_M_gd1(__urng);
+	result_type __y = this->_M_gd2(__urng);
+	return std::sqrt(__x * __y);
+      }
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename k_distribution<_RealType>::result_type
+      k_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      {
+	typename std::gamma_distribution<result_type>::param_type
+	  __p1(__p.lambda(), result_type(1) / __p.lambda()),
+	  __p2(__p.nu(), __p.mu() / __p.nu());
+	result_type __x = this->_M_gd1(__p1, __urng);
+	result_type __y = this->_M_gd2(__p2, __urng);
+	return std::sqrt(__x * __y);
+      }
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      k_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	typename std::gamma_distribution<result_type>::param_type
+	  __p1(__p.lambda(), result_type(1) / __p.lambda()),
+	  __p2(__p.nu(), __p.mu() / __p.nu());
+	while (__f != __t)
+	  {
+	    result_type __x = this->_M_gd1(__p1, __urng);
+	    result_type __y = this->_M_gd2(__p2, __urng);
+	    *__f++ = std::sqrt(__x * __y);
+	  }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const k_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.lambda() << __space << __x.mu() << __space << __x.nu();
+      __os << __space << __x._M_gd1;
+      __os << __space << __x._M_gd2;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       k_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __lambda_val, __mu_val, __nu_val;
+      __is >> __lambda_val >> __mu_val >> __nu_val;
+      __is >> __x._M_gd1;
+      __is >> __x._M_gd2;
+      __x.param(typename k_distribution<_RealType>::
+		param_type(__lambda_val, __mu_val, __nu_val));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      arcsine_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	result_type __dif = __p.b() - __p.a();
+	result_type __sum = __p.a() + __p.b();
+	while (__f != __t)
+	  {
+	    result_type __x = std::sin(this->_M_ud(__urng));
+	    *__f++ = (__x * __dif + __sum) / result_type(2);
+	  }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const arcsine_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.a() << __space << __x.b();
+      __os << __space << __x._M_ud;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       arcsine_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b;
+      __is >> __a >> __b;
+      __is >> __x._M_ud;
+      __x.param(typename arcsine_distribution<_RealType>::
+		param_type(__a, __b));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename hoyt_distribution<_RealType>::result_type
+      hoyt_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	result_type __x = this->_M_ad(__urng);
+	result_type __y = this->_M_ed(__urng);
+	return (result_type(2) * this->q()
+		  / (result_type(1) + this->q() * this->q()))
+	       * std::sqrt(this->omega() * __x * __y);
+      }
+
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename hoyt_distribution<_RealType>::result_type
+      hoyt_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __p)
+      {
+	result_type __q2 = __p.q() * __p.q();
+	result_type __num = result_type(0.5L) * (result_type(1) + __q2);
+	typename __gnu_cxx::arcsine_distribution<result_type>::param_type
+	  __pa(__num, __num / __q2);
+	result_type __x = this->_M_ad(__pa, __urng);
+	result_type __y = this->_M_ed(__urng);
+	return (result_type(2) * __p.q() / (result_type(1) + __q2))
+	       * std::sqrt(__p.omega() * __x * __y);
+      }
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      hoyt_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __p)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	result_type __2q = result_type(2) * __p.q();
+	result_type __q2 = __p.q() * __p.q();
+	result_type __q2p1 = result_type(1) + __q2;
+	result_type __num = result_type(0.5L) * __q2p1;
+	result_type __omega = __p.omega();
+	typename __gnu_cxx::arcsine_distribution<result_type>::param_type
+	  __pa(__num, __num / __q2);
+	while (__f != __t)
+	  {
+	    result_type __x = this->_M_ad(__pa, __urng);
+	    result_type __y = this->_M_ed(__urng);
+	    *__f++ = (__2q / __q2p1) * std::sqrt(__omega * __x * __y);
+	  }
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const hoyt_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.q() << __space << __x.omega();
+      __os << __space << __x._M_ad;
+      __os << __space << __x._M_ed;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       hoyt_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __q, __omega;
+      __is >> __q >> __omega;
+      __is >> __x._M_ad;
+      __is >> __x._M_ed;
+      __x.param(typename hoyt_distribution<_RealType>::
+		param_type(__q, __omega));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      triangular_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	while (__f != __t)
+	  *__f++ = this->operator()(__urng, __param);
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const __gnu_cxx::triangular_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.a() << __space << __x.b() << __space << __x.c();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       __gnu_cxx::triangular_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b, __c;
+      __is >> __a >> __b >> __c;
+      __x.param(typename __gnu_cxx::triangular_distribution<_RealType>::
+		param_type(__a, __b, __c));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      von_mises_distribution<_RealType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	while (__f != __t)
+	  *__f++ = this->operator()(__urng, __param);
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const __gnu_cxx::von_mises_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_RealType>::max_digits10);
+
+      __os << __x.mu() << __space << __x.kappa();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       __gnu_cxx::von_mises_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __mu, __kappa;
+      __is >> __mu >> __kappa;
+      __x.param(typename __gnu_cxx::von_mises_distribution<_RealType>::
+		param_type(__mu, __kappa));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _UIntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename hypergeometric_distribution<_UIntType>::result_type
+      hypergeometric_distribution<_UIntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+		 const param_type& __param)
+      {
+	std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+	  __aurng(__urng);
+
+	result_type __a = __param.successful_size();
+	result_type __b = __param.total_size();
+	result_type __k = 0;
+
+	if (__param.total_draws() < __param.total_size() / 2) 
+	  {
+	    for (result_type __i = 0; __i < __param.total_draws(); ++__i)
+	      {
+		if (__b * __aurng() < __a)
+		  {
+		    ++__k;
+		    if (__k == __param.successful_size())
+		      return __k;
+		   --__a;
+		  }
+		--__b;
+	      }
+	    return __k;
+	  }
+	else
+	  {
+	    for (result_type __i = 0; __i < __param.unsuccessful_size(); ++__i)
+	      {
+		if (__b * __aurng() < __a)
+		  {
+		    ++__k;
+		    if (__k == __param.successful_size())
+		      return __param.successful_size() - __k;
+		    --__a;
+		  }
+		--__b;
+	      }
+	    return __param.successful_size() - __k;
+	  }
+      }
+
+  template<typename _UIntType>
+    template<typename _OutputIterator,
+	     typename _UniformRandomNumberGenerator>
+      void
+      hypergeometric_distribution<_UIntType>::
+      __generate_impl(_OutputIterator __f, _OutputIterator __t,
+		      _UniformRandomNumberGenerator& __urng,
+		      const param_type& __param)
+      {
+	__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
+
+	while (__f != __t)
+	  *__f++ = this->operator()(__urng);
+      }
+
+  template<typename _UIntType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const __gnu_cxx::hypergeometric_distribution<_UIntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(std::numeric_limits<_UIntType>::max_digits10);
+
+      __os << __x.total_size() << __space << __x.successful_size() << __space
+	   << __x.total_draws();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _UIntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       __gnu_cxx::hypergeometric_distribution<_UIntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _UIntType __total_size, __successful_size, __total_draws;
+      __is >> __total_size >> __successful_size >> __total_draws;
+      __x.param(typename __gnu_cxx::hypergeometric_distribution<_UIntType>::
+		param_type(__total_size, __successful_size, __total_draws));
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+
+#endif // _EXT_RANDOM_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/ext/rb_tree b/gcc-4.9/libstdc++-v3/include/ext/rb_tree
new file mode 100644
index 0000000..e6d4f61
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/rb_tree
@@ -0,0 +1,96 @@
+// rb_tree extension -*- C++ -*-
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/rb_tree
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset). 
+ */
+
+#ifndef _RB_TREE
+#define _RB_TREE 1
+
+#pragma GCC system_header
+
+#include <bits/stl_tree.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::_Rb_tree;
+  using std::allocator;
+
+  // Class rb_tree is not part of the C++ standard.  It is provided for
+  // compatibility with the HP STL.
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+   */
+  template <class _Key, class _Value, class _KeyOfValue, class _Compare,
+	    class _Alloc = allocator<_Value> >
+    struct rb_tree
+    : public _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc>
+    {
+      typedef _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base;
+      typedef typename _Base::allocator_type allocator_type;
+
+      rb_tree(const _Compare& __comp = _Compare(),
+	      const allocator_type& __a = allocator_type())
+      : _Base(__comp, __a) { }
+
+      ~rb_tree() { }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/rc_string_base.h b/gcc-4.9/libstdc++-v3/include/ext/rc_string_base.h
new file mode 100644
index 0000000..4c72407
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/rc_string_base.h
@@ -0,0 +1,732 @@
+// Reference-counted versatile string base -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/rc_string_base.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/vstring.h}
+ */
+
+#ifndef _RC_STRING_BASE_H
+#define _RC_STRING_BASE_H 1
+
+#include <ext/atomicity.h>
+#include <bits/stl_iterator_base_funcs.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  Documentation?  What's that?
+   *  Nathan Myers <ncm@cantrip.org>.
+   *
+   *  A string looks like this:
+   *
+   *  @code
+   *                                        [_Rep]
+   *                                        _M_length
+   *   [__rc_string_base<char_type>]        _M_capacity
+   *   _M_dataplus                          _M_refcount
+   *   _M_p ---------------->               unnamed array of char_type
+   *  @endcode
+   *
+   *  Where the _M_p points to the first character in the string, and
+   *  you cast it to a pointer-to-_Rep and subtract 1 to get a
+   *  pointer to the header.
+   *
+   *  This approach has the enormous advantage that a string object
+   *  requires only one allocation.  All the ugliness is confined
+   *  within a single pair of inline functions, which each compile to
+   *  a single @a add instruction: _Rep::_M_refdata(), and
+   *  __rc_string_base::_M_rep(); and the allocation function which gets a
+   *  block of raw bytes and with room enough and constructs a _Rep
+   *  object at the front.
+   *
+   *  The reason you want _M_data pointing to the character array and
+   *  not the _Rep is so that the debugger can see the string
+   *  contents. (Probably we should add a non-inline member to get
+   *  the _Rep for the debugger to use, so users can check the actual
+   *  string length.)
+   *
+   *  Note that the _Rep object is a POD so that you can have a
+   *  static <em>empty string</em> _Rep object already @a constructed before
+   *  static constructors have run.  The reference-count encoding is
+   *  chosen so that a 0 indicates one reference, so you never try to
+   *  destroy the empty-string _Rep object.
+   *
+   *  All but the last paragraph is considered pretty conventional
+   *  for a C++ string implementation.
+  */
+ template<typename _CharT, typename _Traits, typename _Alloc>
+    class __rc_string_base
+    : protected __vstring_utility<_CharT, _Traits, _Alloc>
+    {
+    public:
+      typedef _Traits					    traits_type;
+      typedef typename _Traits::char_type		    value_type;
+      typedef _Alloc					    allocator_type;
+
+      typedef __vstring_utility<_CharT, _Traits, _Alloc>    _Util_Base;
+      typedef typename _Util_Base::_CharT_alloc_type        _CharT_alloc_type;
+      typedef typename _CharT_alloc_type::size_type	    size_type;
+
+    private:
+      // _Rep: string representation
+      //   Invariants:
+      //   1. String really contains _M_length + 1 characters: due to 21.3.4
+      //      must be kept null-terminated.
+      //   2. _M_capacity >= _M_length
+      //      Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
+      //   3. _M_refcount has three states:
+      //      -1: leaked, one reference, no ref-copies allowed, non-const.
+      //       0: one reference, non-const.
+      //     n>0: n + 1 references, operations require a lock, const.
+      //   4. All fields == 0 is an empty string, given the extra storage
+      //      beyond-the-end for a null terminator; thus, the shared
+      //      empty string representation needs no constructor.
+      struct _Rep
+      {
+	union
+	{
+	  struct
+	  {
+	    size_type	    _M_length;
+	    size_type	    _M_capacity;
+	    _Atomic_word    _M_refcount;
+	  }                 _M_info;
+
+	  // Only for alignment purposes.
+	  _CharT            _M_align;
+	};
+
+	typedef typename _Alloc::template rebind<_Rep>::other _Rep_alloc_type;
+
+ 	_CharT*
+	_M_refdata() throw()
+	{ return reinterpret_cast<_CharT*>(this + 1); }
+
+	_CharT*
+	_M_refcopy() throw()
+	{
+	  __atomic_add_dispatch(&_M_info._M_refcount, 1);
+	  return _M_refdata();
+	}  // XXX MT
+
+	void
+	_M_set_length(size_type __n)
+	{
+	  _M_info._M_refcount = 0;  // One reference.
+	  _M_info._M_length = __n;
+	  // grrr. (per 21.3.4)
+	  // You cannot leave those LWG people alone for a second.
+	  traits_type::assign(_M_refdata()[__n], _CharT());
+	}
+
+	// Create & Destroy
+	static _Rep*
+	_S_create(size_type, size_type, const _Alloc&);
+
+	void
+	_M_destroy(const _Alloc&) throw();
+
+	_CharT*
+	_M_clone(const _Alloc&, size_type __res = 0);
+      };
+
+      struct _Rep_empty
+      : public _Rep
+      {
+	_CharT              _M_terminal;
+      };
+
+      static _Rep_empty     _S_empty_rep;
+
+      // The maximum number of individual char_type elements of an
+      // individual string is determined by _S_max_size. This is the
+      // value that will be returned by max_size().  (Whereas npos
+      // is the maximum number of bytes the allocator can allocate.)
+      // If one was to divvy up the theoretical largest size string,
+      // with a terminating character and m _CharT elements, it'd
+      // look like this:
+      // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
+      //        + sizeof(_Rep) - 1
+      // (NB: last two terms for rounding reasons, see _M_create below)
+      // Solving for m:
+      // m = ((npos - 2 * sizeof(_Rep) + 1) / sizeof(_CharT)) - 1
+      // In addition, this implementation halves this amount.
+      enum { _S_max_size = (((static_cast<size_type>(-1) - 2 * sizeof(_Rep)
+			      + 1) / sizeof(_CharT)) - 1) / 2 };
+
+      // Data Member (private):
+      mutable typename _Util_Base::template _Alloc_hider<_Alloc>  _M_dataplus;
+
+      void
+      _M_data(_CharT* __p)
+      { _M_dataplus._M_p = __p; }
+
+      _Rep*
+      _M_rep() const
+      { return &((reinterpret_cast<_Rep*>(_M_data()))[-1]); }
+
+      _CharT*
+      _M_grab(const _Alloc& __alloc) const
+      {
+	return (!_M_is_leaked() && _M_get_allocator() == __alloc)
+		? _M_rep()->_M_refcopy() : _M_rep()->_M_clone(__alloc);
+      }
+
+      void
+      _M_dispose()
+      {
+	// Be race-detector-friendly.  For more info see bits/c++config.
+	_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_rep()->_M_info.
+						_M_refcount);
+	if (__exchange_and_add_dispatch(&_M_rep()->_M_info._M_refcount,
+					-1) <= 0)
+	  {
+	    _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_rep()->_M_info.
+						   _M_refcount);
+	    _M_rep()->_M_destroy(_M_get_allocator());
+	  }
+      }  // XXX MT
+
+      bool
+      _M_is_leaked() const
+      { return _M_rep()->_M_info._M_refcount < 0; }
+
+      void
+      _M_set_sharable()
+      { _M_rep()->_M_info._M_refcount = 0; }
+
+      void
+      _M_leak_hard();
+
+      // _S_construct_aux is used to implement the 21.3.1 para 15 which
+      // requires special behaviour if _InIterator is an integral type
+      template<typename _InIterator>
+	static _CharT*
+	_S_construct_aux(_InIterator __beg, _InIterator __end,
+			 const _Alloc& __a, std::__false_type)
+	{
+	  typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+	  return _S_construct(__beg, __end, __a, _Tag());
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+	static _CharT*
+	_S_construct_aux(_Integer __beg, _Integer __end,
+			 const _Alloc& __a, std::__true_type)
+	{ return _S_construct_aux_2(static_cast<size_type>(__beg),
+				    __end, __a); }
+
+      static _CharT*
+      _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
+      { return _S_construct(__req, __c, __a); }
+
+      template<typename _InIterator>
+	static _CharT*
+	_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
+	{
+	  typedef typename std::__is_integer<_InIterator>::__type _Integral;
+	  return _S_construct_aux(__beg, __end, __a, _Integral());
+	}
+
+      // For Input Iterators, used in istreambuf_iterators, etc.
+      template<typename _InIterator>
+	static _CharT*
+	 _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+		      std::input_iterator_tag);
+
+      // For forward_iterators up to random_access_iterators, used for
+      // string::iterator, _CharT*, etc.
+      template<typename _FwdIterator>
+	static _CharT*
+	_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
+		     std::forward_iterator_tag);
+
+      static _CharT*
+      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
+
+    public:
+      size_type
+      _M_max_size() const
+      { return size_type(_S_max_size); }
+
+      _CharT*
+      _M_data() const
+      { return _M_dataplus._M_p; }
+
+      size_type
+      _M_length() const
+      { return _M_rep()->_M_info._M_length; }
+
+      size_type
+      _M_capacity() const
+      { return _M_rep()->_M_info._M_capacity; }
+
+      bool
+      _M_is_shared() const
+      { return _M_rep()->_M_info._M_refcount > 0; }
+
+      void
+      _M_set_leaked()
+      { _M_rep()->_M_info._M_refcount = -1; }
+
+      void
+      _M_leak()    // for use in begin() & non-const op[]
+      {
+	if (!_M_is_leaked())
+	  _M_leak_hard();
+      }
+
+      void
+      _M_set_length(size_type __n)
+      { _M_rep()->_M_set_length(__n); }
+
+      __rc_string_base()
+      : _M_dataplus(_S_empty_rep._M_refcopy()) { }
+
+      __rc_string_base(const _Alloc& __a);
+
+      __rc_string_base(const __rc_string_base& __rcs);
+
+#if __cplusplus >= 201103L
+      __rc_string_base(__rc_string_base&& __rcs)
+      : _M_dataplus(__rcs._M_dataplus)
+      { __rcs._M_data(_S_empty_rep._M_refcopy()); }
+#endif
+
+      __rc_string_base(size_type __n, _CharT __c, const _Alloc& __a);
+
+      template<typename _InputIterator>
+	__rc_string_base(_InputIterator __beg, _InputIterator __end,
+			 const _Alloc& __a);
+
+      ~__rc_string_base()
+      { _M_dispose(); }
+
+      allocator_type&
+      _M_get_allocator()
+      { return _M_dataplus; }
+
+      const allocator_type&
+      _M_get_allocator() const
+      { return _M_dataplus; }
+
+      void
+      _M_swap(__rc_string_base& __rcs);
+
+      void
+      _M_assign(const __rc_string_base& __rcs);
+
+      void
+      _M_reserve(size_type __res);
+
+      void
+      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+		size_type __len2);
+
+      void
+      _M_erase(size_type __pos, size_type __n);
+
+      void
+      _M_clear()
+      { _M_erase(size_type(0), _M_length()); }
+
+      bool
+      _M_compare(const __rc_string_base&) const
+      { return false; }
+    };
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename __rc_string_base<_CharT, _Traits, _Alloc>::_Rep_empty
+    __rc_string_base<_CharT, _Traits, _Alloc>::_S_empty_rep;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename __rc_string_base<_CharT, _Traits, _Alloc>::_Rep*
+    __rc_string_base<_CharT, _Traits, _Alloc>::_Rep::
+    _S_create(size_type __capacity, size_type __old_capacity,
+	      const _Alloc& __alloc)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 83.  String::npos vs. string::max_size()
+      if (__capacity > size_type(_S_max_size))
+	std::__throw_length_error(__N("__rc_string_base::_Rep::_S_create"));
+
+      // The standard places no restriction on allocating more memory
+      // than is strictly needed within this layer at the moment or as
+      // requested by an explicit application call to reserve().
+
+      // Many malloc implementations perform quite poorly when an
+      // application attempts to allocate memory in a stepwise fashion
+      // growing each allocation size by only 1 char.  Additionally,
+      // it makes little sense to allocate less linear memory than the
+      // natural blocking size of the malloc implementation.
+      // Unfortunately, we would need a somewhat low-level calculation
+      // with tuned parameters to get this perfect for any particular
+      // malloc implementation.  Fortunately, generalizations about
+      // common features seen among implementations seems to suffice.
+
+      // __pagesize need not match the actual VM page size for good
+      // results in practice, thus we pick a common value on the low
+      // side.  __malloc_header_size is an estimate of the amount of
+      // overhead per memory allocation (in practice seen N * sizeof
+      // (void*) where N is 0, 2 or 4).  According to folklore,
+      // picking this value on the high side is better than
+      // low-balling it (especially when this algorithm is used with
+      // malloc implementations that allocate memory blocks rounded up
+      // to a size which is a power of 2).
+      const size_type __pagesize = 4096;
+      const size_type __malloc_header_size = 4 * sizeof(void*);
+
+      // The below implements an exponential growth policy, necessary to
+      // meet amortized linear time requirements of the library: see
+      // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+	{
+	  __capacity = 2 * __old_capacity;
+	  // Never allocate a string bigger than _S_max_size.
+	  if (__capacity > size_type(_S_max_size))
+	    __capacity = size_type(_S_max_size);
+	}
+
+      // NB: Need an array of char_type[__capacity], plus a terminating
+      // null char_type() element, plus enough for the _Rep data structure,
+      // plus sizeof(_Rep) - 1 to upper round to a size multiple of
+      // sizeof(_Rep).
+      // Whew. Seemingly so needy, yet so elemental.
+      size_type __size = ((__capacity + 1) * sizeof(_CharT)
+			  + 2 * sizeof(_Rep) - 1);
+
+      const size_type __adj_size = __size + __malloc_header_size;
+      if (__adj_size > __pagesize && __capacity > __old_capacity)
+	{
+	  const size_type __extra = __pagesize - __adj_size % __pagesize;
+	  __capacity += __extra / sizeof(_CharT);
+	  if (__capacity > size_type(_S_max_size))
+	    __capacity = size_type(_S_max_size);
+	  __size = (__capacity + 1) * sizeof(_CharT) + 2 * sizeof(_Rep) - 1;
+	}
+
+      // NB: Might throw, but no worries about a leak, mate: _Rep()
+      // does not throw.
+      _Rep* __place = _Rep_alloc_type(__alloc).allocate(__size / sizeof(_Rep));
+      _Rep* __p = new (__place) _Rep;
+      __p->_M_info._M_capacity = __capacity;
+      return __p;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __rc_string_base<_CharT, _Traits, _Alloc>::_Rep::
+    _M_destroy(const _Alloc& __a) throw ()
+    {
+      const size_type __size = ((_M_info._M_capacity + 1) * sizeof(_CharT)
+				+ 2 * sizeof(_Rep) - 1);
+      _Rep_alloc_type(__a).deallocate(this, __size / sizeof(_Rep));
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    __rc_string_base<_CharT, _Traits, _Alloc>::_Rep::
+    _M_clone(const _Alloc& __alloc, size_type __res)
+    {
+      // Requested capacity of the clone.
+      const size_type __requested_cap = _M_info._M_length + __res;
+      _Rep* __r = _Rep::_S_create(__requested_cap, _M_info._M_capacity,
+				  __alloc);
+
+      if (_M_info._M_length)
+	__rc_string_base::_S_copy(__r->_M_refdata(), _M_refdata(), _M_info._M_length);
+
+      __r->_M_set_length(_M_info._M_length);
+      return __r->_M_refdata();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    __rc_string_base(const _Alloc& __a)
+    : _M_dataplus(__a, _S_construct(size_type(), _CharT(), __a)) { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    __rc_string_base(const __rc_string_base& __rcs)
+    : _M_dataplus(__rcs._M_get_allocator(),
+		  __rcs._M_grab(__rcs._M_get_allocator())) { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    __rc_string_base(size_type __n, _CharT __c, const _Alloc& __a)
+    : _M_dataplus(__a, _S_construct(__n, __c, __a)) { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    __rc_string_base(_InputIterator __beg, _InputIterator __end,
+		     const _Alloc& __a)
+    : _M_dataplus(__a, _S_construct(__beg, __end, __a)) { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    _M_leak_hard()
+    {
+      if (_M_is_shared())
+	_M_erase(0, 0);
+      _M_set_leaked();
+    }
+
+  // NB: This is the special case for Input Iterators, used in
+  // istreambuf_iterators, etc.
+  // Input Iterators have a cost structure very different from
+  // pointers, calling for a different coding style.
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      _CharT*
+      __rc_string_base<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+		   std::input_iterator_tag)
+      {
+	if (__beg == __end && __a == _Alloc())
+	  return _S_empty_rep._M_refcopy();
+
+	// Avoid reallocation for common case.
+	_CharT __buf[128];
+	size_type __len = 0;
+	while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
+	  {
+	    __buf[__len++] = *__beg;
+	    ++__beg;
+	  }
+	_Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
+	_S_copy(__r->_M_refdata(), __buf, __len);
+	__try
+	  {
+	    while (__beg != __end)
+	      {
+		if (__len == __r->_M_info._M_capacity)
+		  {
+		    // Allocate more space.
+		    _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
+		    _S_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
+		    __r->_M_destroy(__a);
+		    __r = __another;
+		  }
+		__r->_M_refdata()[__len++] = *__beg;
+		++__beg;
+	      }
+	  }
+	__catch(...)
+	  {
+	    __r->_M_destroy(__a);
+	    __throw_exception_again;
+	  }
+	__r->_M_set_length(__len);
+	return __r->_M_refdata();
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      _CharT*
+      __rc_string_base<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+		   std::forward_iterator_tag)
+      {
+	if (__beg == __end && __a == _Alloc())
+	  return _S_empty_rep._M_refcopy();
+
+	// NB: Not required, but considered best practice.
+	if (__is_null_pointer(__beg) && __beg != __end)
+	  std::__throw_logic_error(__N("__rc_string_base::"
+				       "_S_construct null not valid"));
+
+	const size_type __dnew = static_cast<size_type>(std::distance(__beg,
+								      __end));
+	// Check for out_of_range and length_error exceptions.
+	_Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
+	__try
+	  { __rc_string_base::_S_copy_chars(__r->_M_refdata(), __beg, __end); }
+	__catch(...)
+	  {
+	    __r->_M_destroy(__a);
+	    __throw_exception_again;
+	  }
+	__r->_M_set_length(__dnew);
+	return __r->_M_refdata();
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
+    {
+      if (__n == 0 && __a == _Alloc())
+	return _S_empty_rep._M_refcopy();
+
+      // Check for out_of_range and length_error exceptions.
+      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
+      if (__n)
+	__rc_string_base::_S_assign(__r->_M_refdata(), __n, __c);
+
+      __r->_M_set_length(__n);
+      return __r->_M_refdata();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    _M_swap(__rc_string_base& __rcs)
+    {
+      if (_M_is_leaked())
+	_M_set_sharable();
+      if (__rcs._M_is_leaked())
+	__rcs._M_set_sharable();
+
+      _CharT* __tmp = _M_data();
+      _M_data(__rcs._M_data());
+      __rcs._M_data(__tmp);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 431. Swapping containers with unequal allocators.
+      std::__alloc_swap<allocator_type>::_S_do_it(_M_get_allocator(),
+						  __rcs._M_get_allocator());
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    _M_assign(const __rc_string_base& __rcs)
+    {
+      if (_M_rep() != __rcs._M_rep())
+	{
+	  _CharT* __tmp = __rcs._M_grab(_M_get_allocator());
+	  _M_dispose();
+	  _M_data(__tmp);
+	}
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    _M_reserve(size_type __res)
+    {
+      // Make sure we don't shrink below the current size.
+      if (__res < _M_length())
+	__res = _M_length();
+
+      if (__res != _M_capacity() || _M_is_shared())
+	{
+	  _CharT* __tmp = _M_rep()->_M_clone(_M_get_allocator(),
+					     __res - _M_length());
+	  _M_dispose();
+	  _M_data(__tmp);
+	}
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+	      size_type __len2)
+    {
+      const size_type __how_much = _M_length() - __pos - __len1;
+
+      _Rep* __r = _Rep::_S_create(_M_length() + __len2 - __len1,
+				  _M_capacity(), _M_get_allocator());
+
+      if (__pos)
+	this->_S_copy(__r->_M_refdata(), _M_data(), __pos);
+      if (__s && __len2)
+	this->_S_copy(__r->_M_refdata() + __pos, __s, __len2);
+      if (__how_much)
+	this->_S_copy(__r->_M_refdata() + __pos + __len2,
+		_M_data() + __pos + __len1, __how_much);
+
+      _M_dispose();
+      _M_data(__r->_M_refdata());
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __rc_string_base<_CharT, _Traits, _Alloc>::
+    _M_erase(size_type __pos, size_type __n)
+    {
+      const size_type __new_size = _M_length() - __n;
+      const size_type __how_much = _M_length() - __pos - __n;
+
+      if (_M_is_shared())
+	{
+	  // Must reallocate.
+	  _Rep* __r = _Rep::_S_create(__new_size, _M_capacity(),
+				      _M_get_allocator());
+
+	  if (__pos)
+	    this->_S_copy(__r->_M_refdata(), _M_data(), __pos);
+	  if (__how_much)
+	    this->_S_copy(__r->_M_refdata() + __pos,
+		    _M_data() + __pos + __n, __how_much);
+
+	  _M_dispose();
+	  _M_data(__r->_M_refdata());
+	}
+      else if (__how_much && __n)
+	{
+	  // Work in-place.
+	  this->_S_move(_M_data() + __pos,
+		  _M_data() + __pos + __n, __how_much);
+	}
+
+      _M_rep()->_M_set_length(__new_size);
+    }
+
+  template<>
+    inline bool
+    __rc_string_base<char, std::char_traits<char>,
+		     std::allocator<char> >::
+    _M_compare(const __rc_string_base& __rcs) const
+    {
+      if (_M_rep() == __rcs._M_rep())
+	return true;
+      return false;
+    }
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    inline bool
+    __rc_string_base<wchar_t, std::char_traits<wchar_t>,
+		     std::allocator<wchar_t> >::
+    _M_compare(const __rc_string_base& __rcs) const
+    {
+      if (_M_rep() == __rcs._M_rep())
+	return true;
+      return false;
+    }
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _RC_STRING_BASE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/rope b/gcc-4.9/libstdc++-v3/include/ext/rope
new file mode 100644
index 0000000..df3d4bb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/rope
@@ -0,0 +1,2976 @@
+// SGI's rope class -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ext/rope
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset). 
+ */
+
+#ifndef _ROPE
+#define _ROPE 1
+
+#pragma GCC system_header
+
+#include <algorithm>
+#include <iosfwd>
+#include <bits/stl_construct.h>
+#include <bits/stl_uninitialized.h>
+#include <bits/stl_function.h>
+#include <bits/stl_numeric.h>
+#include <bits/allocator.h>
+#include <bits/gthr.h>
+#include <tr1/functional>
+
+# ifdef __GC
+#   define __GC_CONST const
+# else
+#   define __GC_CONST   // constant except for deallocation
+# endif
+
+#include <ext/memory> // For uninitialized_copy_n
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+  namespace __detail
+  {
+    enum { _S_max_rope_depth = 45 };
+    enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function};
+  } // namespace __detail
+
+  using std::size_t;
+  using std::ptrdiff_t;
+  using std::allocator;
+  using std::_Destroy;
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // See libstdc++/36832.
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy_const(_ForwardIterator __first,
+		   _ForwardIterator __last, _Allocator __alloc)
+    {
+      for (; __first != __last; ++__first)
+	__alloc.destroy(&*__first);
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy_const(_ForwardIterator __first,
+		   _ForwardIterator __last, allocator<_Tp>)
+    { _Destroy(__first, __last); }
+
+  // The _S_eos function is used for those functions that
+  // convert to/from C-like strings to detect the end of the string.
+  
+  // The end-of-C-string character.
+  // This is what the draft standard says it should be.
+  template <class _CharT>
+    inline _CharT
+    _S_eos(_CharT*)
+    { return _CharT(); }
+
+  // Test for basic character types.
+  // For basic character types leaves having a trailing eos.
+  template <class _CharT>
+    inline bool
+    _S_is_basic_char_type(_CharT*)
+    { return false; }
+  
+  template <class _CharT>
+    inline bool
+    _S_is_one_byte_char_type(_CharT*)
+    { return false; }
+
+  inline bool
+  _S_is_basic_char_type(char*)
+  { return true; }
+  
+  inline bool
+  _S_is_one_byte_char_type(char*)
+  { return true; }
+  
+  inline bool
+  _S_is_basic_char_type(wchar_t*)
+  { return true; }
+
+  // Store an eos iff _CharT is a basic character type.
+  // Do not reference _S_eos if it isn't.
+  template <class _CharT>
+    inline void
+    _S_cond_store_eos(_CharT&) { }
+
+  inline void
+  _S_cond_store_eos(char& __c)
+  { __c = 0; }
+
+  inline void
+  _S_cond_store_eos(wchar_t& __c)
+  { __c = 0; }
+
+  // char_producers are logically functions that generate a section of
+  // a string.  These can be converted to ropes.  The resulting rope
+  // invokes the char_producer on demand.  This allows, for example,
+  // files to be viewed as ropes without reading the entire file.
+  template <class _CharT>
+    class char_producer
+    {
+    public:
+      virtual ~char_producer() { };
+
+      virtual void
+      operator()(size_t __start_pos, size_t __len,
+		 _CharT* __buffer) = 0;
+      // Buffer should really be an arbitrary output iterator.
+      // That way we could flatten directly into an ostream, etc.
+      // This is thoroughly impossible, since iterator types don't
+      // have runtime descriptions.
+    };
+
+  // Sequence buffers:
+  //
+  // Sequence must provide an append operation that appends an
+  // array to the sequence.  Sequence buffers are useful only if
+  // appending an entire array is cheaper than appending element by element.
+  // This is true for many string representations.
+  // This should  perhaps inherit from ostream<sequence::value_type>
+  // and be implemented correspondingly, so that they can be used
+  // for formatted.  For the sake of portability, we don't do this yet.
+  //
+  // For now, sequence buffers behave as output iterators.  But they also
+  // behave a little like basic_ostringstream<sequence::value_type> and a
+  // little like containers.
+
+  template<class _Sequence, size_t _Buf_sz = 100>
+    class sequence_buffer
+    : public std::iterator<std::output_iterator_tag, void, void, void, void>
+    {
+    public:
+      typedef typename _Sequence::value_type value_type;
+    protected:
+      _Sequence* _M_prefix;
+      value_type _M_buffer[_Buf_sz];
+      size_t     _M_buf_count;
+    public:
+
+      void
+      flush()
+      {
+	_M_prefix->append(_M_buffer, _M_buffer + _M_buf_count);
+	_M_buf_count = 0;
+      }
+      
+      ~sequence_buffer()
+      { flush(); }
+      
+      sequence_buffer()
+      : _M_prefix(0), _M_buf_count(0) { }
+
+      sequence_buffer(const sequence_buffer& __x)
+      {
+	_M_prefix = __x._M_prefix;
+	_M_buf_count = __x._M_buf_count;
+	std::copy(__x._M_buffer, __x._M_buffer + __x._M_buf_count, _M_buffer);
+      }
+      
+      sequence_buffer(sequence_buffer& __x)
+      {
+	__x.flush();
+	_M_prefix = __x._M_prefix;
+	_M_buf_count = 0;
+      }
+      
+      sequence_buffer(_Sequence& __s)
+      : _M_prefix(&__s), _M_buf_count(0) { }
+      
+      sequence_buffer&
+      operator=(sequence_buffer& __x)
+      {
+	__x.flush();
+	_M_prefix = __x._M_prefix;
+	_M_buf_count = 0;
+	return *this;
+      }
+
+      sequence_buffer&
+      operator=(const sequence_buffer& __x)
+      {
+	_M_prefix = __x._M_prefix;
+	_M_buf_count = __x._M_buf_count;
+	std::copy(__x._M_buffer, __x._M_buffer + __x._M_buf_count, _M_buffer);
+	return *this;
+      }
+      
+      void
+      push_back(value_type __x)
+      {
+	if (_M_buf_count < _Buf_sz)
+	  {
+	    _M_buffer[_M_buf_count] = __x;
+	    ++_M_buf_count;
+	  }
+	else
+	  {
+	    flush();
+	    _M_buffer[0] = __x;
+	    _M_buf_count = 1;
+	  }
+      }
+      
+      void
+      append(value_type* __s, size_t __len)
+      {
+	if (__len + _M_buf_count <= _Buf_sz)
+	  {
+	    size_t __i = _M_buf_count;
+	    for (size_t __j = 0; __j < __len; __i++, __j++)
+	      _M_buffer[__i] = __s[__j];
+	    _M_buf_count += __len;
+	  }
+	else if (0 == _M_buf_count)
+	  _M_prefix->append(__s, __s + __len);
+	else
+	  {
+	    flush();
+	    append(__s, __len);
+	  }
+      }
+
+      sequence_buffer&
+      write(value_type* __s, size_t __len)
+      {
+	append(__s, __len);
+	return *this;
+      }
+      
+      sequence_buffer&
+      put(value_type __x)
+      {
+	push_back(__x);
+	return *this;
+      }
+      
+      sequence_buffer&
+      operator=(const value_type& __rhs)
+      {
+	push_back(__rhs);
+	return *this;
+      }
+      
+      sequence_buffer&
+      operator*()
+      { return *this; }
+      
+      sequence_buffer&
+      operator++()
+      { return *this; }
+      
+      sequence_buffer
+      operator++(int)
+      { return *this; }
+    };
+  
+  // The following should be treated as private, at least for now.
+  template<class _CharT>
+    class _Rope_char_consumer
+    {
+    public:
+      // If we had member templates, these should not be virtual.
+      // For now we need to use run-time parametrization where
+      // compile-time would do.  Hence this should all be private
+      // for now.
+      // The symmetry with char_producer is accidental and temporary.
+      virtual ~_Rope_char_consumer() { };
+  
+      virtual bool
+      operator()(const _CharT* __buffer, size_t __len) = 0;
+    };
+  
+  // First a lot of forward declarations.  The standard seems to require
+  // much stricter "declaration before use" than many of the implementations
+  // that preceded it.
+  template<class _CharT, class _Alloc = allocator<_CharT> >
+    class rope;
+  
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeConcatenation;
+
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeLeaf;
+  
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeFunction;
+  
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeSubstring;
+  
+  template<class _CharT, class _Alloc>
+    class _Rope_iterator;
+  
+  template<class _CharT, class _Alloc>
+    class _Rope_const_iterator;
+  
+  template<class _CharT, class _Alloc>
+    class _Rope_char_ref_proxy;
+  
+  template<class _CharT, class _Alloc>
+    class _Rope_char_ptr_proxy;
+
+  template<class _CharT, class _Alloc>
+    bool
+    operator==(const _Rope_char_ptr_proxy<_CharT, _Alloc>& __x,
+	       const _Rope_char_ptr_proxy<_CharT, _Alloc>& __y);
+
+  template<class _CharT, class _Alloc>
+    _Rope_const_iterator<_CharT, _Alloc>
+    operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	      ptrdiff_t __n);
+
+  template<class _CharT, class _Alloc>
+    _Rope_const_iterator<_CharT, _Alloc>
+    operator+(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	      ptrdiff_t __n);
+
+  template<class _CharT, class _Alloc>
+    _Rope_const_iterator<_CharT, _Alloc>
+    operator+(ptrdiff_t __n,
+	      const _Rope_const_iterator<_CharT, _Alloc>& __x);
+
+  template<class _CharT, class _Alloc>
+    bool
+    operator==(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_const_iterator<_CharT, _Alloc>& __y);
+
+  template<class _CharT, class _Alloc>
+    bool
+    operator<(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_const_iterator<_CharT, _Alloc>& __y);
+  
+  template<class _CharT, class _Alloc>
+    ptrdiff_t
+    operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_const_iterator<_CharT, _Alloc>& __y);
+
+  template<class _CharT, class _Alloc>
+    _Rope_iterator<_CharT, _Alloc>
+    operator-(const _Rope_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n);
+
+  template<class _CharT, class _Alloc>
+    _Rope_iterator<_CharT, _Alloc>
+    operator+(const _Rope_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n);
+
+  template<class _CharT, class _Alloc>
+    _Rope_iterator<_CharT, _Alloc>
+    operator+(ptrdiff_t __n, const _Rope_iterator<_CharT, _Alloc>& __x);
+
+  template<class _CharT, class _Alloc>
+    bool
+    operator==(const _Rope_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_iterator<_CharT, _Alloc>& __y);
+
+  template<class _CharT, class _Alloc>
+    bool
+    operator<(const _Rope_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_iterator<_CharT, _Alloc>& __y);
+
+  template<class _CharT, class _Alloc>
+    ptrdiff_t
+    operator-(const _Rope_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_iterator<_CharT, _Alloc>& __y);
+
+  template<class _CharT, class _Alloc>
+    rope<_CharT, _Alloc>
+    operator+(const rope<_CharT, _Alloc>& __left,
+	      const rope<_CharT, _Alloc>& __right);
+
+  template<class _CharT, class _Alloc>
+    rope<_CharT, _Alloc>
+    operator+(const rope<_CharT, _Alloc>& __left, const _CharT* __right);
+
+  template<class _CharT, class _Alloc>
+    rope<_CharT, _Alloc>
+    operator+(const rope<_CharT, _Alloc>& __left, _CharT __right);
+
+  // Some helpers, so we can use power on ropes.
+  // See below for why this isn't local to the implementation.
+  
+  // This uses a nonstandard refcount convention.
+  // The result has refcount 0.
+  template<class _CharT, class _Alloc>
+    struct _Rope_Concat_fn
+    : public std::binary_function<rope<_CharT, _Alloc>, rope<_CharT, _Alloc>,
+				  rope<_CharT, _Alloc> >
+    {
+      rope<_CharT, _Alloc>
+      operator()(const rope<_CharT, _Alloc>& __x,
+		 const rope<_CharT, _Alloc>& __y)
+      { return __x + __y; }
+    };
+
+  template <class _CharT, class _Alloc>
+    inline rope<_CharT, _Alloc>
+    identity_element(_Rope_Concat_fn<_CharT, _Alloc>)
+    { return rope<_CharT, _Alloc>(); }
+
+  // Class _Refcount_Base provides a type, _RC_t, a data member,
+  // _M_ref_count, and member functions _M_incr and _M_decr, which perform
+  // atomic preincrement/predecrement.  The constructor initializes
+  // _M_ref_count.
+  struct _Refcount_Base
+  {
+    // The type _RC_t
+    typedef size_t _RC_t;
+    
+    // The data member _M_ref_count
+    volatile _RC_t _M_ref_count;
+
+    // Constructor
+#ifdef __GTHREAD_MUTEX_INIT
+    __gthread_mutex_t _M_ref_count_lock = __GTHREAD_MUTEX_INIT;
+#else
+    __gthread_mutex_t _M_ref_count_lock;
+#endif
+
+    _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
+    {
+#ifndef __GTHREAD_MUTEX_INIT
+#ifdef __GTHREAD_MUTEX_INIT_FUNCTION
+      __GTHREAD_MUTEX_INIT_FUNCTION (&_M_ref_count_lock);
+#else
+#error __GTHREAD_MUTEX_INIT or __GTHREAD_MUTEX_INIT_FUNCTION should be defined by gthr.h abstraction layer, report problem to libstdc++@gcc.gnu.org.
+#endif
+#endif
+    }
+
+#ifndef __GTHREAD_MUTEX_INIT
+    ~_Refcount_Base()
+    { __gthread_mutex_destroy(&_M_ref_count_lock); }
+#endif
+
+    void
+    _M_incr()
+    {
+      __gthread_mutex_lock(&_M_ref_count_lock);
+      ++_M_ref_count;
+      __gthread_mutex_unlock(&_M_ref_count_lock);
+    }
+
+    _RC_t
+    _M_decr()
+    {
+      __gthread_mutex_lock(&_M_ref_count_lock);
+      volatile _RC_t __tmp = --_M_ref_count;
+      __gthread_mutex_unlock(&_M_ref_count_lock);
+      return __tmp;
+    }
+  };
+
+  //
+  // What follows should really be local to rope.  Unfortunately,
+  // that doesn't work, since it makes it impossible to define generic
+  // equality on rope iterators.  According to the draft standard, the
+  // template parameters for such an equality operator cannot be inferred
+  // from the occurrence of a member class as a parameter.
+  // (SGI compilers in fact allow this, but the __result wouldn't be
+  // portable.)
+  // Similarly, some of the static member functions are member functions
+  // only to avoid polluting the global namespace, and to circumvent
+  // restrictions on type inference for template functions.
+  //
+
+  //
+  // The internal data structure for representing a rope.  This is
+  // private to the implementation.  A rope is really just a pointer
+  // to one of these.
+  //
+  // A few basic functions for manipulating this data structure
+  // are members of _RopeRep.  Most of the more complex algorithms
+  // are implemented as rope members.
+  //
+  // Some of the static member functions of _RopeRep have identically
+  // named functions in rope that simply invoke the _RopeRep versions.
+
+#define __ROPE_DEFINE_ALLOCS(__a) \
+        __ROPE_DEFINE_ALLOC(_CharT,_Data) /* character data */ \
+        typedef _Rope_RopeConcatenation<_CharT,__a> __C; \
+        __ROPE_DEFINE_ALLOC(__C,_C) \
+        typedef _Rope_RopeLeaf<_CharT,__a> __L; \
+        __ROPE_DEFINE_ALLOC(__L,_L) \
+        typedef _Rope_RopeFunction<_CharT,__a> __F; \
+        __ROPE_DEFINE_ALLOC(__F,_F) \
+        typedef _Rope_RopeSubstring<_CharT,__a> __S; \
+        __ROPE_DEFINE_ALLOC(__S,_S)
+
+  //  Internal rope nodes potentially store a copy of the allocator
+  //  instance used to allocate them.  This is mostly redundant.
+  //  But the alternative would be to pass allocator instances around
+  //  in some form to nearly all internal functions, since any pointer
+  //  assignment may result in a zero reference count and thus require
+  //  deallocation.
+
+#define __STATIC_IF_SGI_ALLOC  /* not static */
+
+  template <class _CharT, class _Alloc>
+    struct _Rope_rep_base
+    : public _Alloc
+    {
+      typedef _Alloc allocator_type;
+
+      allocator_type
+      get_allocator() const
+      { return *static_cast<const _Alloc*>(this); }
+
+      allocator_type&
+      _M_get_allocator()
+      { return *static_cast<_Alloc*>(this); }
+
+      const allocator_type&
+      _M_get_allocator() const
+      { return *static_cast<const _Alloc*>(this); }
+
+      _Rope_rep_base(size_t __size, const allocator_type&)
+      : _M_size(__size) { }
+
+      size_t _M_size;
+
+# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef typename \
+          _Alloc::template rebind<_Tp>::other __name##Alloc; \
+        static _Tp* __name##_allocate(size_t __n) \
+          { return __name##Alloc().allocate(__n); } \
+        static void __name##_deallocate(_Tp *__p, size_t __n) \
+          { __name##Alloc().deallocate(__p, __n); }
+      __ROPE_DEFINE_ALLOCS(_Alloc)
+# undef __ROPE_DEFINE_ALLOC
+    };
+
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeRep
+    : public _Rope_rep_base<_CharT, _Alloc>
+# ifndef __GC
+	     , _Refcount_Base
+# endif
+    {
+    public:
+      __detail::_Tag _M_tag:8;
+      bool _M_is_balanced:8;
+      unsigned char _M_depth;
+      __GC_CONST _CharT* _M_c_string;
+#ifdef __GTHREAD_MUTEX_INIT
+      __gthread_mutex_t _M_c_string_lock = __GTHREAD_MUTEX_INIT;
+#else
+      __gthread_mutex_t _M_c_string_lock;
+#endif
+                        /* Flattened version of string, if needed.  */
+                        /* typically 0.                             */
+                        /* If it's not 0, then the memory is owned  */
+                        /* by this node.                            */
+                        /* In the case of a leaf, this may point to */
+                        /* the same memory as the data field.       */
+      typedef typename _Rope_rep_base<_CharT, _Alloc>::allocator_type
+        allocator_type;
+
+      using _Rope_rep_base<_CharT, _Alloc>::get_allocator;
+      using _Rope_rep_base<_CharT, _Alloc>::_M_get_allocator;
+
+      _Rope_RopeRep(__detail::_Tag __t, int __d, bool __b, size_t __size,
+		    const allocator_type& __a)
+      : _Rope_rep_base<_CharT, _Alloc>(__size, __a),
+#ifndef __GC
+	_Refcount_Base(1),
+#endif
+	_M_tag(__t), _M_is_balanced(__b), _M_depth(__d), _M_c_string(0)
+#ifdef __GTHREAD_MUTEX_INIT
+      { }
+#else
+      { __GTHREAD_MUTEX_INIT_FUNCTION (&_M_c_string_lock); }
+      ~_Rope_RopeRep()
+      { __gthread_mutex_destroy (&_M_c_string_lock); }
+#endif
+#ifdef __GC
+      void
+      _M_incr () { }
+#endif
+      static void
+      _S_free_string(__GC_CONST _CharT*, size_t __len,
+		     allocator_type& __a);
+#define __STL_FREE_STRING(__s, __l, __a) _S_free_string(__s, __l, __a);
+                        // Deallocate data section of a leaf.
+                        // This shouldn't be a member function.
+                        // But its hard to do anything else at the
+                        // moment, because it's templatized w.r.t.
+                        // an allocator.
+                        // Does nothing if __GC is defined.
+#ifndef __GC
+      void _M_free_c_string();
+      void _M_free_tree();
+      // Deallocate t. Assumes t is not 0.
+      void
+      _M_unref_nonnil()
+      {
+	if (0 == _M_decr())
+	  _M_free_tree();
+      }
+
+      void
+      _M_ref_nonnil()
+      { _M_incr(); }
+
+      static void
+      _S_unref(_Rope_RopeRep* __t)
+      {
+	if (0 != __t)
+	  __t->_M_unref_nonnil();
+      }
+
+      static void
+      _S_ref(_Rope_RopeRep* __t)
+      {
+	if (0 != __t)
+	  __t->_M_incr();
+      }
+      
+      static void
+      _S_free_if_unref(_Rope_RopeRep* __t)
+      {
+	if (0 != __t && 0 == __t->_M_ref_count)
+	  __t->_M_free_tree();
+      }
+#   else /* __GC */
+      void _M_unref_nonnil() { }
+      void _M_ref_nonnil() { }
+      static void _S_unref(_Rope_RopeRep*) { }
+      static void _S_ref(_Rope_RopeRep*) { }
+      static void _S_free_if_unref(_Rope_RopeRep*) { }
+#   endif
+protected:
+      _Rope_RopeRep&
+      operator=(const _Rope_RopeRep&);
+
+      _Rope_RopeRep(const _Rope_RopeRep&);
+    };
+
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeLeaf
+    : public _Rope_RopeRep<_CharT, _Alloc>
+    {
+    public:
+      // Apparently needed by VC++
+      // The data fields of leaves are allocated with some
+      // extra space, to accommodate future growth and for basic
+      // character types, to hold a trailing eos character.
+      enum { _S_alloc_granularity = 8 };
+      
+      static size_t
+      _S_rounded_up_size(size_t __n)
+      {
+        size_t __size_with_eos;
+	
+        if (_S_is_basic_char_type((_CharT*)0))
+	  __size_with_eos = __n + 1;
+	else
+	  __size_with_eos = __n;
+#ifdef __GC
+	return __size_with_eos;
+#else
+	// Allow slop for in-place expansion.
+	return ((__size_with_eos + size_t(_S_alloc_granularity) - 1)
+		&~ (size_t(_S_alloc_granularity) - 1));
+#endif
+      }
+      __GC_CONST _CharT* _M_data; /* Not necessarily 0 terminated. */
+                                  /* The allocated size is         */
+                                  /* _S_rounded_up_size(size), except */
+                                  /* in the GC case, in which it   */
+                                  /* doesn't matter.               */
+      typedef typename _Rope_rep_base<_CharT,_Alloc>::allocator_type
+        allocator_type;
+
+      _Rope_RopeLeaf(__GC_CONST _CharT* __d, size_t __size,
+		     const allocator_type& __a)
+      : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_leaf, 0, true,
+				      __size, __a), _M_data(__d)
+      {
+        if (_S_is_basic_char_type((_CharT *)0))
+	  {
+            // already eos terminated.
+            this->_M_c_string = __d;
+	  }
+      }
+      // The constructor assumes that d has been allocated with
+      // the proper allocator and the properly padded size.
+      // In contrast, the destructor deallocates the data:
+#ifndef __GC
+      ~_Rope_RopeLeaf() throw()
+      {
+        if (_M_data != this->_M_c_string)
+	  this->_M_free_c_string();
+	
+	this->__STL_FREE_STRING(_M_data, this->_M_size, this->_M_get_allocator());
+      }
+#endif
+protected:
+      _Rope_RopeLeaf&
+      operator=(const _Rope_RopeLeaf&);
+
+      _Rope_RopeLeaf(const _Rope_RopeLeaf&);
+    };
+
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeConcatenation
+    : public _Rope_RopeRep<_CharT, _Alloc>
+    {
+    public:
+      _Rope_RopeRep<_CharT, _Alloc>* _M_left;
+      _Rope_RopeRep<_CharT, _Alloc>* _M_right;
+
+      typedef typename _Rope_rep_base<_CharT, _Alloc>::allocator_type
+        allocator_type;
+
+      _Rope_RopeConcatenation(_Rope_RopeRep<_CharT, _Alloc>* __l,
+			      _Rope_RopeRep<_CharT, _Alloc>* __r,
+			      const allocator_type& __a)
+	: _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_concat,
+				      std::max(__l->_M_depth,
+					       __r->_M_depth) + 1,
+				      false,
+				      __l->_M_size + __r->_M_size, __a),
+        _M_left(__l), _M_right(__r)
+      { }
+#ifndef __GC
+      ~_Rope_RopeConcatenation() throw()
+      {
+	this->_M_free_c_string();
+	_M_left->_M_unref_nonnil();
+	_M_right->_M_unref_nonnil();
+      }
+#endif
+protected:
+      _Rope_RopeConcatenation&
+      operator=(const _Rope_RopeConcatenation&);
+      
+      _Rope_RopeConcatenation(const _Rope_RopeConcatenation&);
+    };
+
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeFunction
+    : public _Rope_RopeRep<_CharT, _Alloc>
+    {
+    public:
+      char_producer<_CharT>* _M_fn;
+#ifndef __GC
+      bool _M_delete_when_done; // Char_producer is owned by the
+                                // rope and should be explicitly
+                                // deleted when the rope becomes
+                                // inaccessible.
+#else
+      // In the GC case, we either register the rope for
+      // finalization, or not.  Thus the field is unnecessary;
+      // the information is stored in the collector data structures.
+      // We do need a finalization procedure to be invoked by the
+      // collector.
+      static void
+      _S_fn_finalization_proc(void * __tree, void *)
+      { delete ((_Rope_RopeFunction *)__tree) -> _M_fn; }
+#endif
+    typedef typename _Rope_rep_base<_CharT, _Alloc>::allocator_type
+      allocator_type;
+
+      _Rope_RopeFunction(char_producer<_CharT>* __f, size_t __size,
+                        bool __d, const allocator_type& __a)
+      : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_function, 0, true, __size, __a)
+	, _M_fn(__f)
+#ifndef __GC
+	, _M_delete_when_done(__d)
+#endif
+      {
+#ifdef __GC
+	if (__d)
+	  {
+	    GC_REGISTER_FINALIZER(this, _Rope_RopeFunction::
+				  _S_fn_finalization_proc, 0, 0, 0);
+	  }
+#endif
+      }
+#ifndef __GC
+      ~_Rope_RopeFunction() throw()
+      {
+	this->_M_free_c_string();
+	if (_M_delete_when_done)
+	  delete _M_fn;
+      }
+# endif
+    protected:
+      _Rope_RopeFunction&
+      operator=(const _Rope_RopeFunction&);
+
+      _Rope_RopeFunction(const _Rope_RopeFunction&);
+    };
+  // Substring results are usually represented using just
+  // concatenation nodes.  But in the case of very long flat ropes
+  // or ropes with a functional representation that isn't practical.
+  // In that case, we represent the __result as a special case of
+  // RopeFunction, whose char_producer points back to the rope itself.
+  // In all cases except repeated substring operations and
+  // deallocation, we treat the __result as a RopeFunction.
+  template<class _CharT, class _Alloc>
+    struct _Rope_RopeSubstring
+    : public _Rope_RopeFunction<_CharT, _Alloc>,
+      public char_producer<_CharT>
+    {
+    public:
+      // XXX this whole class should be rewritten.
+      _Rope_RopeRep<_CharT,_Alloc>* _M_base;      // not 0
+      size_t _M_start;
+
+      virtual void
+      operator()(size_t __start_pos, size_t __req_len,
+		 _CharT* __buffer)
+      {
+        switch(_M_base->_M_tag)
+	  {
+	  case __detail::_S_function:
+	  case __detail::_S_substringfn:
+	    {
+	      char_producer<_CharT>* __fn =
+		((_Rope_RopeFunction<_CharT,_Alloc>*)_M_base)->_M_fn;
+	      (*__fn)(__start_pos + _M_start, __req_len, __buffer);
+	    }
+	    break;
+	  case __detail::_S_leaf:
+	    {
+	      __GC_CONST _CharT* __s =
+		((_Rope_RopeLeaf<_CharT,_Alloc>*)_M_base)->_M_data;
+	      uninitialized_copy_n(__s + __start_pos + _M_start, __req_len,
+				   __buffer);
+	    }
+	    break;
+	  default:
+	    break;
+	  }
+      }
+      
+      typedef typename _Rope_rep_base<_CharT, _Alloc>::allocator_type
+        allocator_type;
+
+      _Rope_RopeSubstring(_Rope_RopeRep<_CharT, _Alloc>* __b, size_t __s,
+                          size_t __l, const allocator_type& __a)
+      : _Rope_RopeFunction<_CharT, _Alloc>(this, __l, false, __a),
+        char_producer<_CharT>(), _M_base(__b), _M_start(__s)
+      {
+#ifndef __GC
+	_M_base->_M_ref_nonnil();
+#endif
+        this->_M_tag = __detail::_S_substringfn;
+      }
+    virtual ~_Rope_RopeSubstring() throw()
+      {
+#ifndef __GC
+	_M_base->_M_unref_nonnil();
+	// _M_free_c_string();  -- done by parent class
+#endif
+      }
+    };
+
+  // Self-destructing pointers to Rope_rep.
+  // These are not conventional smart pointers.  Their
+  // only purpose in life is to ensure that unref is called
+  // on the pointer either at normal exit or if an exception
+  // is raised.  It is the caller's responsibility to
+  // adjust reference counts when these pointers are initialized
+  // or assigned to.  (This convention significantly reduces
+  // the number of potentially expensive reference count
+  // updates.)
+#ifndef __GC
+  template<class _CharT, class _Alloc>
+    struct _Rope_self_destruct_ptr
+    {
+      _Rope_RopeRep<_CharT, _Alloc>* _M_ptr;
+
+      ~_Rope_self_destruct_ptr()
+      { _Rope_RopeRep<_CharT, _Alloc>::_S_unref(_M_ptr); }
+#ifdef __EXCEPTIONS
+      _Rope_self_destruct_ptr() : _M_ptr(0) { };
+#else
+      _Rope_self_destruct_ptr() { };
+#endif
+      _Rope_self_destruct_ptr(_Rope_RopeRep<_CharT, _Alloc>* __p)
+      : _M_ptr(__p) { }
+    
+      _Rope_RopeRep<_CharT, _Alloc>&
+      operator*()
+      { return *_M_ptr; }
+    
+      _Rope_RopeRep<_CharT, _Alloc>*
+      operator->()
+      { return _M_ptr; }
+    
+      operator _Rope_RopeRep<_CharT, _Alloc>*()
+      { return _M_ptr; }
+    
+      _Rope_self_destruct_ptr&
+      operator=(_Rope_RopeRep<_CharT, _Alloc>* __x)
+      { _M_ptr = __x; return *this; }
+    };
+#endif
+
+  // Dereferencing a nonconst iterator has to return something
+  // that behaves almost like a reference.  It's not possible to
+  // return an actual reference since assignment requires extra
+  // work.  And we would get into the same problems as with the
+  // CD2 version of basic_string.
+  template<class _CharT, class _Alloc>
+    class _Rope_char_ref_proxy
+    {
+      friend class rope<_CharT, _Alloc>;
+      friend class _Rope_iterator<_CharT, _Alloc>;
+      friend class _Rope_char_ptr_proxy<_CharT, _Alloc>;
+#ifdef __GC
+      typedef _Rope_RopeRep<_CharT, _Alloc>* _Self_destruct_ptr;
+#else
+      typedef _Rope_self_destruct_ptr<_CharT, _Alloc> _Self_destruct_ptr;
+#endif
+      typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+      typedef rope<_CharT, _Alloc> _My_rope;
+      size_t _M_pos;
+      _CharT _M_current;
+      bool _M_current_valid;
+      _My_rope* _M_root;     // The whole rope.
+    public:
+      _Rope_char_ref_proxy(_My_rope* __r, size_t __p)
+      :  _M_pos(__p), _M_current(), _M_current_valid(false), _M_root(__r) { }
+
+      _Rope_char_ref_proxy(const _Rope_char_ref_proxy& __x)
+      : _M_pos(__x._M_pos), _M_current(__x._M_current), 
+	_M_current_valid(false), _M_root(__x._M_root) { }
+
+      // Don't preserve cache if the reference can outlive the
+      // expression.  We claim that's not possible without calling
+      // a copy constructor or generating reference to a proxy
+      // reference.  We declare the latter to have undefined semantics.
+      _Rope_char_ref_proxy(_My_rope* __r, size_t __p, _CharT __c)
+      : _M_pos(__p), _M_current(__c), _M_current_valid(true), _M_root(__r) { }
+
+      inline operator _CharT () const;
+
+      _Rope_char_ref_proxy&
+      operator=(_CharT __c);
+    
+      _Rope_char_ptr_proxy<_CharT, _Alloc> operator&() const;
+      
+      _Rope_char_ref_proxy&
+      operator=(const _Rope_char_ref_proxy& __c)
+      { return operator=((_CharT)__c); }
+    };
+
+  template<class _CharT, class __Alloc>
+    inline void
+    swap(_Rope_char_ref_proxy <_CharT, __Alloc > __a,
+	 _Rope_char_ref_proxy <_CharT, __Alloc > __b)
+    {
+      _CharT __tmp = __a;
+      __a = __b;
+      __b = __tmp;
+    }
+
+  template<class _CharT, class _Alloc>
+    class _Rope_char_ptr_proxy
+    {
+      // XXX this class should be rewritten.
+      friend class _Rope_char_ref_proxy<_CharT, _Alloc>;
+      size_t _M_pos;
+      rope<_CharT,_Alloc>* _M_root;     // The whole rope.
+    public:
+      _Rope_char_ptr_proxy(const _Rope_char_ref_proxy<_CharT,_Alloc>& __x)
+      : _M_pos(__x._M_pos), _M_root(__x._M_root) { }
+
+      _Rope_char_ptr_proxy(const _Rope_char_ptr_proxy& __x)
+      : _M_pos(__x._M_pos), _M_root(__x._M_root) { }
+
+      _Rope_char_ptr_proxy() { }
+      
+      _Rope_char_ptr_proxy(_CharT* __x)
+      : _M_root(0), _M_pos(0) { }
+
+      _Rope_char_ptr_proxy&
+      operator=(const _Rope_char_ptr_proxy& __x)
+      {
+        _M_pos = __x._M_pos;
+        _M_root = __x._M_root;
+        return *this;
+      }
+
+      template<class _CharT2, class _Alloc2>
+        friend bool
+        operator==(const _Rope_char_ptr_proxy<_CharT2, _Alloc2>& __x,
+		   const _Rope_char_ptr_proxy<_CharT2, _Alloc2>& __y);
+
+      _Rope_char_ref_proxy<_CharT, _Alloc> operator*() const
+      { return _Rope_char_ref_proxy<_CharT, _Alloc>(_M_root, _M_pos); }
+    };
+
+  // Rope iterators:
+  // Unlike in the C version, we cache only part of the stack
+  // for rope iterators, since they must be efficiently copyable.
+  // When we run out of cache, we have to reconstruct the iterator
+  // value.
+  // Pointers from iterators are not included in reference counts.
+  // Iterators are assumed to be thread private.  Ropes can
+  // be shared.
+  
+  template<class _CharT, class _Alloc>
+    class _Rope_iterator_base
+    : public std::iterator<std::random_access_iterator_tag, _CharT>
+    {
+      friend class rope<_CharT, _Alloc>;
+    public:
+      typedef _Alloc _allocator_type; // used in _Rope_rotate, VC++ workaround
+      typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+      // Borland doesn't want this to be protected.
+    protected:
+      enum { _S_path_cache_len = 4 }; // Must be <= 9.
+      enum { _S_iterator_buf_len = 15 };
+      size_t _M_current_pos;
+      _RopeRep* _M_root;     // The whole rope.
+      size_t _M_leaf_pos;    // Starting position for current leaf
+      __GC_CONST _CharT* _M_buf_start;
+                             // Buffer possibly
+                             // containing current char.
+      __GC_CONST _CharT* _M_buf_ptr;
+                             // Pointer to current char in buffer.
+                             // != 0 ==> buffer valid.
+      __GC_CONST _CharT* _M_buf_end;
+                             // One past __last valid char in buffer.
+      // What follows is the path cache.  We go out of our
+      // way to make this compact.
+      // Path_end contains the bottom section of the path from
+      // the root to the current leaf.
+      const _RopeRep* _M_path_end[_S_path_cache_len];
+      int _M_leaf_index;     // Last valid __pos in path_end;
+                             // _M_path_end[0] ... _M_path_end[leaf_index-1]
+                             // point to concatenation nodes.
+      unsigned char _M_path_directions;
+                          // (path_directions >> __i) & 1 is 1
+                          // iff we got from _M_path_end[leaf_index - __i - 1]
+                          // to _M_path_end[leaf_index - __i] by going to the
+                          // __right. Assumes path_cache_len <= 9.
+      _CharT _M_tmp_buf[_S_iterator_buf_len];
+                        // Short buffer for surrounding chars.
+                        // This is useful primarily for
+                        // RopeFunctions.  We put the buffer
+                        // here to avoid locking in the
+                        // multithreaded case.
+      // The cached path is generally assumed to be valid
+      // only if the buffer is valid.
+      static void _S_setbuf(_Rope_iterator_base& __x);
+                                        // Set buffer contents given
+                                        // path cache.
+      static void _S_setcache(_Rope_iterator_base& __x);
+                                        // Set buffer contents and
+                                        // path cache.
+      static void _S_setcache_for_incr(_Rope_iterator_base& __x);
+                                        // As above, but assumes path
+                                        // cache is valid for previous posn.
+      _Rope_iterator_base() { }
+
+      _Rope_iterator_base(_RopeRep* __root, size_t __pos)
+      : _M_current_pos(__pos), _M_root(__root), _M_buf_ptr(0) { }
+
+      void _M_incr(size_t __n);
+      void _M_decr(size_t __n);
+    public:
+      size_t
+      index() const
+      { return _M_current_pos; }
+    
+      _Rope_iterator_base(const _Rope_iterator_base& __x)
+      {
+        if (0 != __x._M_buf_ptr)
+	  *this = __x;
+	else
+	  {
+            _M_current_pos = __x._M_current_pos;
+            _M_root = __x._M_root;
+            _M_buf_ptr = 0;
+	  }
+      }
+    };
+
+  template<class _CharT, class _Alloc>
+    class _Rope_iterator;
+
+  template<class _CharT, class _Alloc>
+    class _Rope_const_iterator
+    : public _Rope_iterator_base<_CharT, _Alloc>
+    {
+      friend class rope<_CharT, _Alloc>;
+    protected:
+      typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+      // The one from the base class may not be directly visible.
+      _Rope_const_iterator(const _RopeRep* __root, size_t __pos)
+      : _Rope_iterator_base<_CharT, _Alloc>(const_cast<_RopeRep*>(__root),
+					    __pos)
+                   // Only nonconst iterators modify root ref count
+      { }
+  public:
+      typedef _CharT reference;   // Really a value.  Returning a reference
+                                  // Would be a mess, since it would have
+                                  // to be included in refcount.
+      typedef const _CharT* pointer;
+
+    public:
+      _Rope_const_iterator() { };
+
+      _Rope_const_iterator(const _Rope_const_iterator& __x)
+      : _Rope_iterator_base<_CharT,_Alloc>(__x) { }
+
+      _Rope_const_iterator(const _Rope_iterator<_CharT,_Alloc>& __x);
+    
+      _Rope_const_iterator(const rope<_CharT, _Alloc>& __r, size_t __pos)
+      : _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos) { }
+
+      _Rope_const_iterator&
+      operator=(const _Rope_const_iterator& __x)
+      {
+        if (0 != __x._M_buf_ptr)
+	  *(static_cast<_Rope_iterator_base<_CharT, _Alloc>*>(this)) = __x;
+	else
+	  {
+            this->_M_current_pos = __x._M_current_pos;
+            this->_M_root = __x._M_root;
+            this->_M_buf_ptr = 0;
+	  }
+        return(*this);
+      }
+
+      reference
+      operator*()
+      {
+        if (0 == this->_M_buf_ptr)
+	  this->_S_setcache(*this);
+        return *this->_M_buf_ptr;
+      }
+
+      // Without this const version, Rope iterators do not meet the
+      // requirements of an Input Iterator.
+      reference
+      operator*() const
+      {
+	return *const_cast<_Rope_const_iterator&>(*this);
+      }
+
+      _Rope_const_iterator&
+      operator++()
+      {
+        __GC_CONST _CharT* __next;
+        if (0 != this->_M_buf_ptr
+	    && (__next = this->_M_buf_ptr + 1) < this->_M_buf_end)
+	  {
+            this->_M_buf_ptr = __next;
+            ++this->_M_current_pos;
+	  }
+	else
+	  this->_M_incr(1);
+	return *this;
+      }
+
+      _Rope_const_iterator&
+      operator+=(ptrdiff_t __n)
+      {
+        if (__n >= 0)
+	  this->_M_incr(__n);
+	else
+	  this->_M_decr(-__n);
+	return *this;
+      }
+
+      _Rope_const_iterator&
+      operator--()
+      {
+        this->_M_decr(1);
+        return *this;
+      }
+
+      _Rope_const_iterator&
+      operator-=(ptrdiff_t __n)
+      {
+        if (__n >= 0)
+	  this->_M_decr(__n);
+	else
+	  this->_M_incr(-__n);
+	return *this;
+      }
+
+      _Rope_const_iterator
+      operator++(int)
+      {
+        size_t __old_pos = this->_M_current_pos;
+        this->_M_incr(1);
+        return _Rope_const_iterator<_CharT,_Alloc>(this->_M_root, __old_pos);
+        // This makes a subsequent dereference expensive.
+        // Perhaps we should instead copy the iterator
+        // if it has a valid cache?
+      }
+
+      _Rope_const_iterator
+      operator--(int)
+      {
+        size_t __old_pos = this->_M_current_pos;
+        this->_M_decr(1);
+        return _Rope_const_iterator<_CharT,_Alloc>(this->_M_root, __old_pos);
+      }
+
+      template<class _CharT2, class _Alloc2>
+        friend _Rope_const_iterator<_CharT2, _Alloc2>
+        operator-(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
+		  ptrdiff_t __n);
+
+      template<class _CharT2, class _Alloc2>
+        friend _Rope_const_iterator<_CharT2, _Alloc2>
+        operator+(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
+		  ptrdiff_t __n);
+
+      template<class _CharT2, class _Alloc2>
+        friend _Rope_const_iterator<_CharT2, _Alloc2>
+        operator+(ptrdiff_t __n,
+		  const _Rope_const_iterator<_CharT2, _Alloc2>& __x);
+
+      reference
+      operator[](size_t __n)
+      { return rope<_CharT, _Alloc>::_S_fetch(this->_M_root,
+					      this->_M_current_pos + __n); }
+
+      template<class _CharT2, class _Alloc2>
+        friend bool
+        operator==(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
+		   const _Rope_const_iterator<_CharT2, _Alloc2>& __y);
+
+      template<class _CharT2, class _Alloc2>
+        friend bool
+        operator<(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
+		  const _Rope_const_iterator<_CharT2, _Alloc2>& __y);
+
+      template<class _CharT2, class _Alloc2>
+        friend ptrdiff_t
+        operator-(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
+		  const _Rope_const_iterator<_CharT2, _Alloc2>& __y);
+    };
+
+  template<class _CharT, class _Alloc>
+    class _Rope_iterator
+    : public _Rope_iterator_base<_CharT, _Alloc>
+    {
+      friend class rope<_CharT, _Alloc>;
+    protected:
+      typedef typename _Rope_iterator_base<_CharT, _Alloc>::_RopeRep _RopeRep;
+      rope<_CharT, _Alloc>* _M_root_rope;
+
+      // root is treated as a cached version of this, and is used to
+      // detect changes to the underlying rope.
+
+      // Root is included in the reference count.  This is necessary
+      // so that we can detect changes reliably.  Unfortunately, it
+      // requires careful bookkeeping for the nonGC case.
+      _Rope_iterator(rope<_CharT, _Alloc>* __r, size_t __pos)
+      : _Rope_iterator_base<_CharT, _Alloc>(__r->_M_tree_ptr, __pos),
+        _M_root_rope(__r)
+      { _RopeRep::_S_ref(this->_M_root);
+        if (!(__r -> empty()))
+	  this->_S_setcache(*this);
+      }
+
+      void _M_check();
+    public:
+      typedef _Rope_char_ref_proxy<_CharT, _Alloc>  reference;
+      typedef _Rope_char_ref_proxy<_CharT, _Alloc>* pointer;
+
+      rope<_CharT, _Alloc>&
+      container()
+      { return *_M_root_rope; }
+
+      _Rope_iterator()
+      {
+        this->_M_root = 0;  // Needed for reference counting.
+      };
+
+      _Rope_iterator(const _Rope_iterator& __x)
+      : _Rope_iterator_base<_CharT, _Alloc>(__x)
+      {
+        _M_root_rope = __x._M_root_rope;
+        _RopeRep::_S_ref(this->_M_root);
+      }
+
+      _Rope_iterator(rope<_CharT, _Alloc>& __r, size_t __pos);
+
+      ~_Rope_iterator()
+      { _RopeRep::_S_unref(this->_M_root); }
+
+      _Rope_iterator&
+      operator=(const _Rope_iterator& __x)
+      {
+        _RopeRep* __old = this->_M_root;
+	
+        _RopeRep::_S_ref(__x._M_root);
+        if (0 != __x._M_buf_ptr)
+	  {
+            _M_root_rope = __x._M_root_rope;
+            *(static_cast<_Rope_iterator_base<_CharT, _Alloc>*>(this)) = __x;
+	  }
+	else
+	  {
+	    this->_M_current_pos = __x._M_current_pos;
+            this->_M_root = __x._M_root;
+            _M_root_rope = __x._M_root_rope;
+            this->_M_buf_ptr = 0;
+	  }
+        _RopeRep::_S_unref(__old);
+        return(*this);
+      }
+
+      reference
+      operator*()
+      {
+        _M_check();
+        if (0 == this->_M_buf_ptr)
+	  return _Rope_char_ref_proxy<_CharT, _Alloc>(_M_root_rope,
+						      this->_M_current_pos);
+	else
+	  return _Rope_char_ref_proxy<_CharT, _Alloc>(_M_root_rope,
+						      this->_M_current_pos,
+						      *this->_M_buf_ptr);
+      }
+
+      // See above comment.
+      reference
+      operator*() const
+      {
+	return *const_cast<_Rope_iterator&>(*this);
+      }
+
+      _Rope_iterator&
+      operator++()
+      {
+        this->_M_incr(1);
+        return *this;
+      }
+
+      _Rope_iterator&
+      operator+=(ptrdiff_t __n)
+      {
+        if (__n >= 0)
+	  this->_M_incr(__n);
+	else
+	  this->_M_decr(-__n);
+	return *this;
+      }
+
+      _Rope_iterator&
+      operator--()
+      {
+        this->_M_decr(1);
+        return *this;
+      }
+
+      _Rope_iterator&
+      operator-=(ptrdiff_t __n)
+      {
+        if (__n >= 0)
+	  this->_M_decr(__n);
+	else
+	  this->_M_incr(-__n);
+	return *this;
+      }
+
+      _Rope_iterator
+      operator++(int)
+      {
+        size_t __old_pos = this->_M_current_pos;
+        this->_M_incr(1);
+        return _Rope_iterator<_CharT,_Alloc>(_M_root_rope, __old_pos);
+      }
+
+      _Rope_iterator
+      operator--(int)
+      {
+        size_t __old_pos = this->_M_current_pos;
+        this->_M_decr(1);
+        return _Rope_iterator<_CharT,_Alloc>(_M_root_rope, __old_pos);
+      }
+
+      reference
+      operator[](ptrdiff_t __n)
+      { return _Rope_char_ref_proxy<_CharT, _Alloc>(_M_root_rope,
+						    this->_M_current_pos
+						    + __n); }
+
+      template<class _CharT2, class _Alloc2>
+        friend bool
+        operator==(const _Rope_iterator<_CharT2, _Alloc2>& __x,
+		   const _Rope_iterator<_CharT2, _Alloc2>& __y);
+
+      template<class _CharT2, class _Alloc2>
+        friend bool
+        operator<(const _Rope_iterator<_CharT2, _Alloc2>& __x,
+		  const _Rope_iterator<_CharT2, _Alloc2>& __y);
+
+      template<class _CharT2, class _Alloc2>
+        friend ptrdiff_t
+        operator-(const _Rope_iterator<_CharT2, _Alloc2>& __x,
+		  const _Rope_iterator<_CharT2, _Alloc2>& __y);
+
+      template<class _CharT2, class _Alloc2>
+        friend _Rope_iterator<_CharT2, _Alloc2>
+        operator-(const _Rope_iterator<_CharT2, _Alloc2>& __x, ptrdiff_t __n);
+
+      template<class _CharT2, class _Alloc2>
+        friend _Rope_iterator<_CharT2, _Alloc2>
+        operator+(const _Rope_iterator<_CharT2, _Alloc2>& __x, ptrdiff_t __n);
+
+      template<class _CharT2, class _Alloc2>
+        friend _Rope_iterator<_CharT2, _Alloc2>
+        operator+(ptrdiff_t __n, const _Rope_iterator<_CharT2, _Alloc2>& __x);
+    };
+
+
+  template <class _CharT, class _Alloc>
+    struct _Rope_base
+    : public _Alloc
+    {
+      typedef _Alloc allocator_type;
+
+      allocator_type
+      get_allocator() const
+      { return *static_cast<const _Alloc*>(this); }
+
+      allocator_type&
+      _M_get_allocator()
+      { return *static_cast<_Alloc*>(this); }
+
+      const allocator_type&
+      _M_get_allocator() const
+      { return *static_cast<const _Alloc*>(this); }
+
+      typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+      // The one in _Base may not be visible due to template rules.
+
+      _Rope_base(_RopeRep* __t, const allocator_type&)
+      : _M_tree_ptr(__t) { }
+
+      _Rope_base(const allocator_type&) { }
+
+      // The only data member of a rope:
+      _RopeRep *_M_tree_ptr;
+
+#define __ROPE_DEFINE_ALLOC(_Tp, __name) \
+        typedef typename \
+          _Alloc::template rebind<_Tp>::other __name##Alloc; \
+        static _Tp* __name##_allocate(size_t __n) \
+          { return __name##Alloc().allocate(__n); } \
+        static void __name##_deallocate(_Tp *__p, size_t __n) \
+          { __name##Alloc().deallocate(__p, __n); }
+      __ROPE_DEFINE_ALLOCS(_Alloc)
+#undef __ROPE_DEFINE_ALLOC
+
+	protected:
+      _Rope_base&
+      operator=(const _Rope_base&);
+      
+      _Rope_base(const _Rope_base&);
+    };
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+   */
+  template <class _CharT, class _Alloc>
+    class rope : public _Rope_base<_CharT, _Alloc>
+    {
+    public:
+      typedef _CharT value_type;
+      typedef ptrdiff_t difference_type;
+      typedef size_t size_type;
+      typedef _CharT const_reference;
+      typedef const _CharT* const_pointer;
+      typedef _Rope_iterator<_CharT, _Alloc> iterator;
+      typedef _Rope_const_iterator<_CharT, _Alloc> const_iterator;
+      typedef _Rope_char_ref_proxy<_CharT, _Alloc> reference;
+      typedef _Rope_char_ptr_proxy<_CharT, _Alloc> pointer;
+
+      friend class _Rope_iterator<_CharT, _Alloc>;
+      friend class _Rope_const_iterator<_CharT, _Alloc>;
+      friend struct _Rope_RopeRep<_CharT, _Alloc>;
+      friend class _Rope_iterator_base<_CharT, _Alloc>;
+      friend class _Rope_char_ptr_proxy<_CharT, _Alloc>;
+      friend class _Rope_char_ref_proxy<_CharT, _Alloc>;
+      friend struct _Rope_RopeSubstring<_CharT, _Alloc>;
+
+    protected:
+      typedef _Rope_base<_CharT, _Alloc> _Base;
+      typedef typename _Base::allocator_type allocator_type;
+      using _Base::_M_tree_ptr;
+      using _Base::get_allocator;
+      using _Base::_M_get_allocator;      
+      typedef __GC_CONST _CharT* _Cstrptr;
+      
+      static _CharT _S_empty_c_str[1];
+      
+      static bool
+      _S_is0(_CharT __c)
+      { return __c == _S_eos((_CharT*)0); }
+      
+      enum { _S_copy_max = 23 };
+                // For strings shorter than _S_copy_max, we copy to
+                // concatenate.
+
+      typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+      typedef _Rope_RopeConcatenation<_CharT, _Alloc> _RopeConcatenation;
+      typedef _Rope_RopeLeaf<_CharT, _Alloc> _RopeLeaf;
+      typedef _Rope_RopeFunction<_CharT, _Alloc> _RopeFunction;
+      typedef _Rope_RopeSubstring<_CharT, _Alloc> _RopeSubstring;
+
+      // Retrieve a character at the indicated position.
+      static _CharT _S_fetch(_RopeRep* __r, size_type __pos);
+
+#ifndef __GC
+      // Obtain a pointer to the character at the indicated position.
+      // The pointer can be used to change the character.
+      // If such a pointer cannot be produced, as is frequently the
+      // case, 0 is returned instead.
+      // (Returns nonzero only if all nodes in the path have a refcount
+      // of 1.)
+      static _CharT* _S_fetch_ptr(_RopeRep* __r, size_type __pos);
+#endif
+
+      static bool
+      _S_apply_to_pieces(// should be template parameter
+			 _Rope_char_consumer<_CharT>& __c,
+			 const _RopeRep* __r,
+			 size_t __begin, size_t __end);
+                         // begin and end are assumed to be in range.
+
+#ifndef __GC
+      static void
+      _S_unref(_RopeRep* __t)
+      { _RopeRep::_S_unref(__t); }
+
+      static void
+      _S_ref(_RopeRep* __t)
+      { _RopeRep::_S_ref(__t); }
+
+#else /* __GC */
+      static void _S_unref(_RopeRep*) { }
+      static void _S_ref(_RopeRep*) { }
+#endif
+
+#ifdef __GC
+      typedef _Rope_RopeRep<_CharT, _Alloc>* _Self_destruct_ptr;
+#else
+      typedef _Rope_self_destruct_ptr<_CharT, _Alloc> _Self_destruct_ptr;
+#endif
+
+      // _Result is counted in refcount.
+      static _RopeRep* _S_substring(_RopeRep* __base,
+                                    size_t __start, size_t __endp1);
+
+      static _RopeRep* _S_concat_char_iter(_RopeRep* __r,
+					   const _CharT* __iter, size_t __slen);
+      // Concatenate rope and char ptr, copying __s.
+      // Should really take an arbitrary iterator.
+      // Result is counted in refcount.
+      static _RopeRep* _S_destr_concat_char_iter(_RopeRep* __r,
+						 const _CharT* __iter,
+						 size_t __slen)
+	// As above, but one reference to __r is about to be
+	// destroyed.  Thus the pieces may be recycled if all
+	// relevant reference counts are 1.
+#ifdef __GC
+	// We can't really do anything since refcounts are unavailable.
+      { return _S_concat_char_iter(__r, __iter, __slen); }
+#else
+      ;
+#endif
+
+      static _RopeRep* _S_concat(_RopeRep* __left, _RopeRep* __right);
+      // General concatenation on _RopeRep.  _Result
+      // has refcount of 1.  Adjusts argument refcounts.
+
+   public:
+      void
+      apply_to_pieces(size_t __begin, size_t __end,
+		      _Rope_char_consumer<_CharT>& __c) const
+      { _S_apply_to_pieces(__c, this->_M_tree_ptr, __begin, __end); }
+
+   protected:
+
+      static size_t
+      _S_rounded_up_size(size_t __n)
+      { return _RopeLeaf::_S_rounded_up_size(__n); }
+
+      static size_t
+      _S_allocated_capacity(size_t __n)
+      {
+	if (_S_is_basic_char_type((_CharT*)0))
+	  return _S_rounded_up_size(__n) - 1;
+	else
+	  return _S_rounded_up_size(__n);
+	
+      }
+
+      // Allocate and construct a RopeLeaf using the supplied allocator
+      // Takes ownership of s instead of copying.
+      static _RopeLeaf*
+      _S_new_RopeLeaf(__GC_CONST _CharT *__s,
+		      size_t __size, allocator_type& __a)
+      {
+	_RopeLeaf* __space = typename _Base::_LAlloc(__a).allocate(1);
+	return new(__space) _RopeLeaf(__s, __size, __a);
+      }
+
+      static _RopeConcatenation*
+      _S_new_RopeConcatenation(_RopeRep* __left, _RopeRep* __right,
+			       allocator_type& __a)
+      {
+	_RopeConcatenation* __space = typename _Base::_CAlloc(__a).allocate(1);
+	return new(__space) _RopeConcatenation(__left, __right, __a);
+      }
+
+      static _RopeFunction*
+      _S_new_RopeFunction(char_producer<_CharT>* __f,
+			  size_t __size, bool __d, allocator_type& __a)
+      {
+	_RopeFunction* __space = typename _Base::_FAlloc(__a).allocate(1);
+	return new(__space) _RopeFunction(__f, __size, __d, __a);
+      }
+
+      static _RopeSubstring*
+      _S_new_RopeSubstring(_Rope_RopeRep<_CharT,_Alloc>* __b, size_t __s,
+			   size_t __l, allocator_type& __a)
+      {
+	_RopeSubstring* __space = typename _Base::_SAlloc(__a).allocate(1);
+	return new(__space) _RopeSubstring(__b, __s, __l, __a);
+      }
+      
+      static _RopeLeaf*
+      _S_RopeLeaf_from_unowned_char_ptr(const _CharT *__s,
+					size_t __size, allocator_type& __a)
+#define __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __size, __a) \
+                _S_RopeLeaf_from_unowned_char_ptr(__s, __size, __a)
+      {
+	if (0 == __size)
+	  return 0;
+	_CharT* __buf = __a.allocate(_S_rounded_up_size(__size));
+	
+	__uninitialized_copy_n_a(__s, __size, __buf, __a);
+	_S_cond_store_eos(__buf[__size]);
+	__try
+	  { return _S_new_RopeLeaf(__buf, __size, __a); }
+	__catch(...)
+	  {
+	    _RopeRep::__STL_FREE_STRING(__buf, __size, __a);
+	    __throw_exception_again;
+	  }
+      }
+
+      // Concatenation of nonempty strings.
+      // Always builds a concatenation node.
+      // Rebalances if the result is too deep.
+      // Result has refcount 1.
+      // Does not increment left and right ref counts even though
+      // they are referenced.
+      static _RopeRep*
+      _S_tree_concat(_RopeRep* __left, _RopeRep* __right);
+
+      // Concatenation helper functions
+      static _RopeLeaf*
+      _S_leaf_concat_char_iter(_RopeLeaf* __r,
+			       const _CharT* __iter, size_t __slen);
+      // Concatenate by copying leaf.
+      // should take an arbitrary iterator
+      // result has refcount 1.
+#ifndef __GC
+      static _RopeLeaf*
+      _S_destr_leaf_concat_char_iter(_RopeLeaf* __r,
+				     const _CharT* __iter, size_t __slen);
+      // A version that potentially clobbers __r if __r->_M_ref_count == 1.
+#endif
+
+    private:
+      
+      static size_t _S_char_ptr_len(const _CharT* __s);
+      // slightly generalized strlen
+
+      rope(_RopeRep* __t, const allocator_type& __a = allocator_type())
+      : _Base(__t, __a) { }
+
+
+      // Copy __r to the _CharT buffer.
+      // Returns __buffer + __r->_M_size.
+      // Assumes that buffer is uninitialized.
+      static _CharT* _S_flatten(_RopeRep* __r, _CharT* __buffer);
+
+      // Again, with explicit starting position and length.
+      // Assumes that buffer is uninitialized.
+      static _CharT* _S_flatten(_RopeRep* __r,
+				size_t __start, size_t __len,
+				_CharT* __buffer);
+
+      static const unsigned long
+      _S_min_len[__detail::_S_max_rope_depth + 1];
+      
+      static bool
+      _S_is_balanced(_RopeRep* __r)
+      { return (__r->_M_size >= _S_min_len[__r->_M_depth]); }
+
+      static bool
+      _S_is_almost_balanced(_RopeRep* __r)
+      { return (__r->_M_depth == 0
+		|| __r->_M_size >= _S_min_len[__r->_M_depth - 1]); }
+
+      static bool
+      _S_is_roughly_balanced(_RopeRep* __r)
+      { return (__r->_M_depth <= 1
+		|| __r->_M_size >= _S_min_len[__r->_M_depth - 2]); }
+
+      // Assumes the result is not empty.
+      static _RopeRep*
+      _S_concat_and_set_balanced(_RopeRep* __left, _RopeRep* __right)
+      {
+	_RopeRep* __result = _S_concat(__left, __right);
+	if (_S_is_balanced(__result))
+	  __result->_M_is_balanced = true;
+	return __result;
+      }
+
+      // The basic rebalancing operation.  Logically copies the
+      // rope.  The result has refcount of 1.  The client will
+      // usually decrement the reference count of __r.
+      // The result is within height 2 of balanced by the above
+      // definition.
+      static _RopeRep* _S_balance(_RopeRep* __r);
+
+      // Add all unbalanced subtrees to the forest of balanced trees.
+      // Used only by balance.
+      static void _S_add_to_forest(_RopeRep*__r, _RopeRep** __forest);
+
+      // Add __r to forest, assuming __r is already balanced.
+      static void _S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest);
+      
+      // Print to stdout, exposing structure
+      static void _S_dump(_RopeRep* __r, int __indent = 0);
+      
+      // Return -1, 0, or 1 if __x < __y, __x == __y, or __x > __y resp.
+      static int _S_compare(const _RopeRep* __x, const _RopeRep* __y);
+      
+    public:
+      bool
+      empty() const
+      { return 0 == this->_M_tree_ptr; }
+      
+      // Comparison member function.  This is public only for those
+      // clients that need a ternary comparison.  Others
+      // should use the comparison operators below.
+      int
+      compare(const rope& __y) const
+      { return _S_compare(this->_M_tree_ptr, __y._M_tree_ptr); }
+
+      rope(const _CharT* __s, const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	this->_M_tree_ptr =
+	  __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, _S_char_ptr_len(__s),
+					   _M_get_allocator());
+      }
+
+      rope(const _CharT* __s, size_t __len,
+	   const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	this->_M_tree_ptr =
+	  __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __len, _M_get_allocator());
+      }
+
+      // Should perhaps be templatized with respect to the iterator type
+      // and use Sequence_buffer.  (It should perhaps use sequence_buffer
+      // even now.)
+      rope(const _CharT* __s, const _CharT* __e,
+	   const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	this->_M_tree_ptr =
+	  __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __e - __s, _M_get_allocator());
+      }
+
+      rope(const const_iterator& __s, const const_iterator& __e,
+	   const allocator_type& __a = allocator_type())
+      : _Base(_S_substring(__s._M_root, __s._M_current_pos,
+			   __e._M_current_pos), __a)
+      { }
+
+      rope(const iterator& __s, const iterator& __e,
+	   const allocator_type& __a = allocator_type())
+      : _Base(_S_substring(__s._M_root, __s._M_current_pos,
+			   __e._M_current_pos), __a)
+      { }
+
+      rope(_CharT __c, const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	_CharT* __buf = this->_Data_allocate(_S_rounded_up_size(1));
+	
+	_M_get_allocator().construct(__buf, __c);
+	__try
+	  {
+	    this->_M_tree_ptr = _S_new_RopeLeaf(__buf, 1,
+						_M_get_allocator());
+	  }
+	__catch(...)
+	  {
+	    _RopeRep::__STL_FREE_STRING(__buf, 1, _M_get_allocator());
+	    __throw_exception_again;
+	  }
+      }
+
+      rope(size_t __n, _CharT __c,
+	   const allocator_type& __a = allocator_type());
+
+      rope(const allocator_type& __a = allocator_type())
+      : _Base(0, __a) { }
+
+      // Construct a rope from a function that can compute its members
+      rope(char_producer<_CharT> *__fn, size_t __len, bool __delete_fn,
+	   const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+	this->_M_tree_ptr = (0 == __len) ?
+	  0 : _S_new_RopeFunction(__fn, __len, __delete_fn, __a);
+      }
+
+      rope(const rope& __x, const allocator_type& __a = allocator_type())
+      : _Base(__x._M_tree_ptr, __a)
+      { _S_ref(this->_M_tree_ptr); }
+
+      ~rope() throw()
+      { _S_unref(this->_M_tree_ptr); }
+
+      rope&
+      operator=(const rope& __x)
+      {
+	_RopeRep* __old = this->_M_tree_ptr;
+	this->_M_tree_ptr = __x._M_tree_ptr;
+	_S_ref(this->_M_tree_ptr);
+	_S_unref(__old);
+	return *this;
+      }
+
+      void
+      clear()
+      {
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = 0;
+      }
+      
+      void
+      push_back(_CharT __x)
+      {
+	_RopeRep* __old = this->_M_tree_ptr;
+	this->_M_tree_ptr
+	  = _S_destr_concat_char_iter(this->_M_tree_ptr, &__x, 1);
+	_S_unref(__old);
+      }
+
+      void
+      pop_back()
+      {
+	_RopeRep* __old = this->_M_tree_ptr;
+	this->_M_tree_ptr = _S_substring(this->_M_tree_ptr,
+					 0, this->_M_tree_ptr->_M_size - 1);
+	_S_unref(__old);
+      }
+
+      _CharT
+      back() const
+      { return _S_fetch(this->_M_tree_ptr, this->_M_tree_ptr->_M_size - 1); }
+
+      void
+      push_front(_CharT __x)
+      {
+	_RopeRep* __old = this->_M_tree_ptr;
+	_RopeRep* __left =
+	  __STL_ROPE_FROM_UNOWNED_CHAR_PTR(&__x, 1, _M_get_allocator());
+	__try
+	  {
+	    this->_M_tree_ptr = _S_concat(__left, this->_M_tree_ptr);
+	    _S_unref(__old);
+	    _S_unref(__left);
+	  }
+	__catch(...)
+	  {
+	    _S_unref(__left);
+	    __throw_exception_again;
+	  }
+      }
+
+      void
+      pop_front()
+      {
+	_RopeRep* __old = this->_M_tree_ptr;
+	this->_M_tree_ptr
+	  = _S_substring(this->_M_tree_ptr, 1, this->_M_tree_ptr->_M_size);
+	_S_unref(__old);
+      }
+
+      _CharT
+      front() const
+      { return _S_fetch(this->_M_tree_ptr, 0); }
+
+      void
+      balance()
+      {
+	_RopeRep* __old = this->_M_tree_ptr;
+	this->_M_tree_ptr = _S_balance(this->_M_tree_ptr);
+	_S_unref(__old);
+      }
+
+      void
+      copy(_CharT* __buffer) const
+      {
+	_Destroy_const(__buffer, __buffer + size(), _M_get_allocator());
+	_S_flatten(this->_M_tree_ptr, __buffer);
+      }
+
+      // This is the copy function from the standard, but
+      // with the arguments reordered to make it consistent with the
+      // rest of the interface.
+      // Note that this guaranteed not to compile if the draft standard
+      // order is assumed.
+      size_type
+      copy(size_type __pos, size_type __n, _CharT* __buffer) const
+      {
+	size_t __size = size();
+	size_t __len = (__pos + __n > __size? __size - __pos : __n);
+
+	_Destroy_const(__buffer, __buffer + __len, _M_get_allocator());
+	_S_flatten(this->_M_tree_ptr, __pos, __len, __buffer);
+	return __len;
+      }
+
+      // Print to stdout, exposing structure.  May be useful for
+      // performance debugging.
+      void
+      dump()
+      { _S_dump(this->_M_tree_ptr); }
+      
+      // Convert to 0 terminated string in new allocated memory.
+      // Embedded 0s in the input do not terminate the copy.
+      const _CharT* c_str() const;
+
+      // As above, but also use the flattened representation as
+      // the new rope representation.
+      const _CharT* replace_with_c_str();
+      
+      // Reclaim memory for the c_str generated flattened string.
+      // Intentionally undocumented, since it's hard to say when this
+      // is safe for multiple threads.
+      void
+      delete_c_str ()
+      {
+	if (0 == this->_M_tree_ptr)
+	  return;
+	if (__detail::_S_leaf == this->_M_tree_ptr->_M_tag &&
+	    ((_RopeLeaf*)this->_M_tree_ptr)->_M_data ==
+	    this->_M_tree_ptr->_M_c_string)
+	  {
+	    // Representation shared
+	    return;
+	  }
+#ifndef __GC
+	this->_M_tree_ptr->_M_free_c_string();
+#endif
+	this->_M_tree_ptr->_M_c_string = 0;
+      }
+
+      _CharT
+      operator[] (size_type __pos) const
+      { return _S_fetch(this->_M_tree_ptr, __pos); }
+
+      _CharT
+      at(size_type __pos) const
+      {
+	// if (__pos >= size()) throw out_of_range;  // XXX
+	return (*this)[__pos];
+      }
+
+      const_iterator
+      begin() const
+      { return(const_iterator(this->_M_tree_ptr, 0)); }
+
+      // An easy way to get a const iterator from a non-const container.
+      const_iterator
+      const_begin() const
+      { return(const_iterator(this->_M_tree_ptr, 0)); }
+
+      const_iterator
+      end() const
+      { return(const_iterator(this->_M_tree_ptr, size())); }
+
+      const_iterator
+      const_end() const
+      { return(const_iterator(this->_M_tree_ptr, size())); }
+
+      size_type
+      size() const
+      {	return(0 == this->_M_tree_ptr? 0 : this->_M_tree_ptr->_M_size); }
+      
+      size_type
+      length() const
+      {	return size(); }
+
+      size_type
+      max_size() const
+      {
+	return _S_min_len[int(__detail::_S_max_rope_depth) - 1] - 1;
+	//  Guarantees that the result can be sufficiently
+	//  balanced.  Longer ropes will probably still work,
+	//  but it's harder to make guarantees.
+      }
+
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      const_rbegin() const
+      {	return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(begin()); }
+      
+      const_reverse_iterator
+      const_rend() const
+      {	return const_reverse_iterator(begin()); }
+
+      template<class _CharT2, class _Alloc2>
+        friend rope<_CharT2, _Alloc2>
+        operator+(const rope<_CharT2, _Alloc2>& __left,
+		  const rope<_CharT2, _Alloc2>& __right);
+
+      template<class _CharT2, class _Alloc2>
+        friend rope<_CharT2, _Alloc2>
+        operator+(const rope<_CharT2, _Alloc2>& __left, const _CharT2* __right);
+
+      template<class _CharT2, class _Alloc2>
+        friend rope<_CharT2, _Alloc2>
+        operator+(const rope<_CharT2, _Alloc2>& __left, _CharT2 __right);
+
+      // The symmetric cases are intentionally omitted, since they're
+      // presumed to be less common, and we don't handle them as well.
+
+      // The following should really be templatized.  The first
+      // argument should be an input iterator or forward iterator with
+      // value_type _CharT.
+      rope&
+      append(const _CharT* __iter, size_t __n)
+      {
+	_RopeRep* __result =
+	  _S_destr_concat_char_iter(this->_M_tree_ptr, __iter, __n);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+	return *this;
+      }
+
+      rope&
+      append(const _CharT* __c_string)
+      {
+	size_t __len = _S_char_ptr_len(__c_string);
+	append(__c_string, __len);
+	return(*this);
+      }
+
+      rope&
+      append(const _CharT* __s, const _CharT* __e)
+      {
+	_RopeRep* __result =
+	  _S_destr_concat_char_iter(this->_M_tree_ptr, __s, __e - __s);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+	return *this;
+      }
+
+      rope&
+      append(const_iterator __s, const_iterator __e)
+      {
+	_Self_destruct_ptr __appendee(_S_substring(__s._M_root,
+						   __s._M_current_pos,
+						   __e._M_current_pos));
+	_RopeRep* __result = _S_concat(this->_M_tree_ptr, 
+				       (_RopeRep*)__appendee);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+	return *this;
+      }
+
+      rope&
+      append(_CharT __c)
+      {
+	_RopeRep* __result =
+	  _S_destr_concat_char_iter(this->_M_tree_ptr, &__c, 1);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+	return *this;
+      }
+
+      rope&
+      append()
+      { return append(_CharT()); }  // XXX why?
+
+      rope&
+      append(const rope& __y)
+      {
+	_RopeRep* __result = _S_concat(this->_M_tree_ptr, __y._M_tree_ptr);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+	return *this;
+      }
+
+      rope&
+      append(size_t __n, _CharT __c)
+      {
+	rope<_CharT,_Alloc> __last(__n, __c);
+	return append(__last);
+      }
+
+      void
+      swap(rope& __b)
+      {
+	_RopeRep* __tmp = this->_M_tree_ptr;
+	this->_M_tree_ptr = __b._M_tree_ptr;
+	__b._M_tree_ptr = __tmp;
+      }
+
+    protected:
+      // Result is included in refcount.
+      static _RopeRep*
+      replace(_RopeRep* __old, size_t __pos1,
+	      size_t __pos2, _RopeRep* __r)
+      {
+	if (0 == __old)
+	  {
+	    _S_ref(__r);
+	    return __r;
+	  }
+	_Self_destruct_ptr __left(_S_substring(__old, 0, __pos1));
+	_Self_destruct_ptr __right(_S_substring(__old, __pos2, __old->_M_size));
+	_RopeRep* __result;
+
+	if (0 == __r)
+	  __result = _S_concat(__left, __right);
+	else
+	  {
+	    _Self_destruct_ptr __left_result(_S_concat(__left, __r));
+	    __result = _S_concat(__left_result, __right);
+	  }
+	return __result;
+      }
+
+    public:
+      void
+      insert(size_t __p, const rope& __r)
+      {
+	_RopeRep* __result =
+	  replace(this->_M_tree_ptr, __p, __p, __r._M_tree_ptr);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+      }
+
+      void
+      insert(size_t __p, size_t __n, _CharT __c)
+      {
+	rope<_CharT,_Alloc> __r(__n,__c);
+	insert(__p, __r);
+      }
+      
+      void
+      insert(size_t __p, const _CharT* __i, size_t __n)
+      {
+	_Self_destruct_ptr __left(_S_substring(this->_M_tree_ptr, 0, __p));
+	_Self_destruct_ptr __right(_S_substring(this->_M_tree_ptr,
+						__p, size()));
+	_Self_destruct_ptr __left_result(_S_concat_char_iter(__left, __i, __n));
+	// _S_ destr_concat_char_iter should be safe here.
+	// But as it stands it's probably not a win, since __left
+	// is likely to have additional references.
+	_RopeRep* __result = _S_concat(__left_result, __right);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+      }
+
+      void
+      insert(size_t __p, const _CharT* __c_string)
+      {	insert(__p, __c_string, _S_char_ptr_len(__c_string)); }
+
+      void
+      insert(size_t __p, _CharT __c)
+      { insert(__p, &__c, 1); }
+
+      void
+      insert(size_t __p)
+      {
+	_CharT __c = _CharT();
+	insert(__p, &__c, 1);
+      }
+
+      void
+      insert(size_t __p, const _CharT* __i, const _CharT* __j)
+      {
+	rope __r(__i, __j);
+	insert(__p, __r);
+      }
+
+      void
+      insert(size_t __p, const const_iterator& __i,
+	     const const_iterator& __j)
+      {
+	rope __r(__i, __j);
+	insert(__p, __r);
+      }
+
+      void
+      insert(size_t __p, const iterator& __i,
+	     const iterator& __j)
+      {
+	rope __r(__i, __j);
+	insert(__p, __r);
+      }
+
+      // (position, length) versions of replace operations:
+      
+      void
+      replace(size_t __p, size_t __n, const rope& __r)
+      {
+	_RopeRep* __result =
+	  replace(this->_M_tree_ptr, __p, __p + __n, __r._M_tree_ptr);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+      }
+
+      void
+      replace(size_t __p, size_t __n,
+	      const _CharT* __i, size_t __i_len)
+      {
+	rope __r(__i, __i_len);
+	replace(__p, __n, __r);
+      }
+
+      void
+      replace(size_t __p, size_t __n, _CharT __c)
+      {
+	rope __r(__c);
+	replace(__p, __n, __r);
+      }
+
+      void
+      replace(size_t __p, size_t __n, const _CharT* __c_string)
+      {
+	rope __r(__c_string);
+	replace(__p, __n, __r);
+      }
+      
+      void
+      replace(size_t __p, size_t __n,
+	      const _CharT* __i, const _CharT* __j)
+      {
+	rope __r(__i, __j);
+	replace(__p, __n, __r);
+      }
+      
+      void
+      replace(size_t __p, size_t __n,
+	      const const_iterator& __i, const const_iterator& __j)
+      {
+	rope __r(__i, __j);
+	replace(__p, __n, __r);
+      }
+
+      void
+      replace(size_t __p, size_t __n,
+	      const iterator& __i, const iterator& __j)
+      {
+	rope __r(__i, __j);
+	replace(__p, __n, __r);
+      }
+
+      // Single character variants:
+      void
+      replace(size_t __p, _CharT __c)
+      {
+	iterator __i(this, __p);
+	*__i = __c;
+      }
+
+      void
+      replace(size_t __p, const rope& __r)
+      { replace(__p, 1, __r); }
+
+      void
+      replace(size_t __p, const _CharT* __i, size_t __i_len)
+      { replace(__p, 1, __i, __i_len); }
+
+      void
+      replace(size_t __p, const _CharT* __c_string)
+      {	replace(__p, 1, __c_string); }
+
+      void
+      replace(size_t __p, const _CharT* __i, const _CharT* __j)
+      {	replace(__p, 1, __i, __j); }
+
+      void
+      replace(size_t __p, const const_iterator& __i,
+	      const const_iterator& __j)
+      { replace(__p, 1, __i, __j); }
+
+      void
+      replace(size_t __p, const iterator& __i,
+	      const iterator& __j)
+      { replace(__p, 1, __i, __j); }
+
+      // Erase, (position, size) variant.
+      void
+      erase(size_t __p, size_t __n)
+      {
+	_RopeRep* __result = replace(this->_M_tree_ptr, __p,
+				     __p + __n, 0);
+	_S_unref(this->_M_tree_ptr);
+	this->_M_tree_ptr = __result;
+      }
+
+      // Erase, single character
+      void
+      erase(size_t __p)
+      { erase(__p, __p + 1); }
+
+      // Insert, iterator variants.
+      iterator
+      insert(const iterator& __p, const rope& __r)
+      {
+	insert(__p.index(), __r);
+	return __p;
+      }
+
+      iterator
+      insert(const iterator& __p, size_t __n, _CharT __c)
+      {
+	insert(__p.index(), __n, __c);
+	return __p;
+      }
+
+      iterator insert(const iterator& __p, _CharT __c)
+      {
+	insert(__p.index(), __c);
+	return __p;
+      }
+      
+      iterator
+      insert(const iterator& __p )
+      {
+	insert(__p.index());
+	return __p;
+      }
+      
+      iterator
+      insert(const iterator& __p, const _CharT* c_string)
+      {
+	insert(__p.index(), c_string);
+	return __p;
+      }
+      
+      iterator
+      insert(const iterator& __p, const _CharT* __i, size_t __n)
+      {
+	insert(__p.index(), __i, __n);
+	return __p;
+      }
+      
+      iterator
+      insert(const iterator& __p, const _CharT* __i,
+	     const _CharT* __j)
+      {
+	insert(__p.index(), __i, __j); 
+	return __p;
+      }
+      
+      iterator
+      insert(const iterator& __p,
+	     const const_iterator& __i, const const_iterator& __j)
+      {
+	insert(__p.index(), __i, __j);
+	return __p;
+      }
+      
+      iterator
+      insert(const iterator& __p,
+	     const iterator& __i, const iterator& __j)
+      {
+	insert(__p.index(), __i, __j);
+	return __p;
+      }
+
+      // Replace, range variants.
+      void
+      replace(const iterator& __p, const iterator& __q, const rope& __r)
+      {	replace(__p.index(), __q.index() - __p.index(), __r); }
+
+      void
+      replace(const iterator& __p, const iterator& __q, _CharT __c)
+      { replace(__p.index(), __q.index() - __p.index(), __c); }
+      
+      void
+      replace(const iterator& __p, const iterator& __q,
+	      const _CharT* __c_string)
+      { replace(__p.index(), __q.index() - __p.index(), __c_string); }
+      
+      void
+      replace(const iterator& __p, const iterator& __q,
+	      const _CharT* __i, size_t __n)
+      { replace(__p.index(), __q.index() - __p.index(), __i, __n); }
+      
+      void
+      replace(const iterator& __p, const iterator& __q,
+	      const _CharT* __i, const _CharT* __j)
+      { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+      
+      void
+      replace(const iterator& __p, const iterator& __q,
+	      const const_iterator& __i, const const_iterator& __j)
+      { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+      
+      void
+      replace(const iterator& __p, const iterator& __q,
+	      const iterator& __i, const iterator& __j)
+      { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+
+      // Replace, iterator variants.
+      void
+      replace(const iterator& __p, const rope& __r)
+      { replace(__p.index(), __r); }
+      
+      void
+      replace(const iterator& __p, _CharT __c)
+      { replace(__p.index(), __c); }
+      
+      void
+      replace(const iterator& __p, const _CharT* __c_string)
+      { replace(__p.index(), __c_string); }
+      
+      void
+      replace(const iterator& __p, const _CharT* __i, size_t __n)
+      { replace(__p.index(), __i, __n); }
+      
+      void
+      replace(const iterator& __p, const _CharT* __i, const _CharT* __j)
+      { replace(__p.index(), __i, __j); }
+      
+      void
+      replace(const iterator& __p, const_iterator __i, const_iterator __j)
+      { replace(__p.index(), __i, __j); }
+      
+      void
+      replace(const iterator& __p, iterator __i, iterator __j)
+      { replace(__p.index(), __i, __j); }
+
+      // Iterator and range variants of erase
+      iterator
+      erase(const iterator& __p, const iterator& __q)
+      {
+	size_t __p_index = __p.index();
+	erase(__p_index, __q.index() - __p_index);
+	return iterator(this, __p_index);
+      }
+
+      iterator
+      erase(const iterator& __p)
+      {
+	size_t __p_index = __p.index();
+	erase(__p_index, 1);
+	return iterator(this, __p_index);
+      }
+
+      rope
+      substr(size_t __start, size_t __len = 1) const
+      {
+	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
+						 __start,
+						 __start + __len));
+      }
+
+      rope
+      substr(iterator __start, iterator __end) const
+      {
+	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
+						 __start.index(),
+						 __end.index()));
+      }
+
+      rope
+      substr(iterator __start) const
+      {
+	size_t __pos = __start.index();
+	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
+						 __pos, __pos + 1));
+      }
+
+      rope
+      substr(const_iterator __start, const_iterator __end) const
+      {
+	// This might eventually take advantage of the cache in the
+	// iterator.
+	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
+						 __start.index(),
+						 __end.index()));
+      }
+
+      rope<_CharT, _Alloc>
+      substr(const_iterator __start)
+      {
+	size_t __pos = __start.index();
+	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
+						 __pos, __pos + 1));
+      }
+
+      static const size_type npos;
+
+      size_type find(_CharT __c, size_type __pos = 0) const;
+
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const
+      {
+	size_type __result_pos;
+	const_iterator __result =
+	  std::search(const_begin() + __pos, const_end(),
+		      __s, __s + _S_char_ptr_len(__s));
+	__result_pos = __result.index();
+#ifndef __STL_OLD_ROPE_SEMANTICS
+	if (__result_pos == size())
+	  __result_pos = npos;
+#endif
+	return __result_pos;
+      }
+
+      iterator
+      mutable_begin()
+      { return(iterator(this, 0)); }
+      
+      iterator
+      mutable_end()
+      { return(iterator(this, size())); }
+
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      
+      reverse_iterator
+      mutable_rbegin()
+      { return reverse_iterator(mutable_end()); }
+
+      reverse_iterator
+      mutable_rend()
+      { return reverse_iterator(mutable_begin()); }
+
+      reference
+      mutable_reference_at(size_type __pos)
+      { return reference(this, __pos); }
+
+#ifdef __STD_STUFF
+      reference
+      operator[] (size_type __pos)
+      { return _char_ref_proxy(this, __pos); }
+
+      reference
+      at(size_type __pos)
+      {
+	// if (__pos >= size()) throw out_of_range;  // XXX
+	return (*this)[__pos];
+      }
+      
+      void resize(size_type __n, _CharT __c) { }
+      void resize(size_type __n) { }
+      void reserve(size_type __res_arg = 0) { }
+      
+      size_type
+      capacity() const
+      { return max_size(); }
+
+      // Stuff below this line is dangerous because it's error prone.
+      // I would really like to get rid of it.
+      // copy function with funny arg ordering.
+      size_type
+      copy(_CharT* __buffer, size_type __n,
+	   size_type __pos = 0) const
+      { return copy(__pos, __n, __buffer); }
+
+      iterator
+      end()
+      { return mutable_end(); }
+
+      iterator
+      begin()
+      { return mutable_begin(); }
+
+      reverse_iterator
+      rend()
+      { return mutable_rend(); }
+      
+      reverse_iterator
+      rbegin()
+      { return mutable_rbegin(); }
+
+#else
+      const_iterator
+      end()
+      { return const_end(); }
+
+      const_iterator
+      begin()
+      { return const_begin(); }
+
+      const_reverse_iterator
+      rend()
+      { return const_rend(); }
+
+      const_reverse_iterator
+      rbegin()
+      { return const_rbegin(); }
+
+#endif
+    };
+
+  template <class _CharT, class _Alloc>
+    const typename rope<_CharT, _Alloc>::size_type
+    rope<_CharT, _Alloc>::npos = (size_type)(-1);
+  
+  template <class _CharT, class _Alloc>
+    inline bool operator==(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+			   const _Rope_const_iterator<_CharT, _Alloc>& __y)
+    { return (__x._M_current_pos == __y._M_current_pos
+	      && __x._M_root == __y._M_root); }
+
+  template <class _CharT, class _Alloc>
+    inline bool operator<(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+			  const _Rope_const_iterator<_CharT, _Alloc>& __y)
+    { return (__x._M_current_pos < __y._M_current_pos); }
+
+  template <class _CharT, class _Alloc>
+    inline bool operator!=(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+			   const _Rope_const_iterator<_CharT, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template <class _CharT, class _Alloc>
+    inline bool operator>(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+			  const _Rope_const_iterator<_CharT, _Alloc>& __y)
+    { return __y < __x; }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator<=(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_const_iterator<_CharT, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator>=(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_const_iterator<_CharT, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  template <class _CharT, class _Alloc>
+    inline ptrdiff_t
+    operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_const_iterator<_CharT, _Alloc>& __y)
+    { return (ptrdiff_t)__x._M_current_pos - (ptrdiff_t)__y._M_current_pos; }
+
+  template <class _CharT, class _Alloc>
+    inline _Rope_const_iterator<_CharT, _Alloc>
+    operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n)
+    { return _Rope_const_iterator<_CharT, _Alloc>(__x._M_root,
+						  __x._M_current_pos - __n); }
+
+  template <class _CharT, class _Alloc>
+    inline _Rope_const_iterator<_CharT, _Alloc>
+    operator+(const _Rope_const_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n)
+    { return _Rope_const_iterator<_CharT, _Alloc>(__x._M_root,
+						  __x._M_current_pos + __n); }
+
+  template <class _CharT, class _Alloc>
+    inline _Rope_const_iterator<_CharT, _Alloc>
+    operator+(ptrdiff_t __n, const _Rope_const_iterator<_CharT, _Alloc>& __x)
+  { return _Rope_const_iterator<_CharT, _Alloc>(__x._M_root,
+						__x._M_current_pos + __n); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator==(const _Rope_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_iterator<_CharT, _Alloc>& __y)
+    {return (__x._M_current_pos == __y._M_current_pos
+	     && __x._M_root_rope == __y._M_root_rope); }
+  
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator<(const _Rope_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_iterator<_CharT, _Alloc>& __y)
+    { return (__x._M_current_pos < __y._M_current_pos); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator!=(const _Rope_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_iterator<_CharT, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator>(const _Rope_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_iterator<_CharT, _Alloc>& __y)
+    { return __y < __x; }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator<=(const _Rope_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_iterator<_CharT, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator>=(const _Rope_iterator<_CharT, _Alloc>& __x,
+	       const _Rope_iterator<_CharT, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  template <class _CharT, class _Alloc>
+    inline ptrdiff_t
+    operator-(const _Rope_iterator<_CharT, _Alloc>& __x,
+	      const _Rope_iterator<_CharT, _Alloc>& __y)
+    { return ((ptrdiff_t)__x._M_current_pos
+	      - (ptrdiff_t)__y._M_current_pos); }
+
+  template <class _CharT, class _Alloc>
+    inline _Rope_iterator<_CharT, _Alloc>
+    operator-(const _Rope_iterator<_CharT, _Alloc>& __x,
+	      ptrdiff_t __n)
+    { return _Rope_iterator<_CharT, _Alloc>(__x._M_root_rope,
+					    __x._M_current_pos - __n); }
+
+  template <class _CharT, class _Alloc>
+    inline _Rope_iterator<_CharT, _Alloc>
+    operator+(const _Rope_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n)
+    { return _Rope_iterator<_CharT, _Alloc>(__x._M_root_rope,
+					    __x._M_current_pos + __n); }
+
+  template <class _CharT, class _Alloc>
+    inline _Rope_iterator<_CharT, _Alloc>
+    operator+(ptrdiff_t __n, const _Rope_iterator<_CharT, _Alloc>& __x)
+    { return _Rope_iterator<_CharT, _Alloc>(__x._M_root_rope,
+					    __x._M_current_pos + __n); }
+
+  template <class _CharT, class _Alloc>
+    inline rope<_CharT, _Alloc>
+    operator+(const rope<_CharT, _Alloc>& __left,
+	      const rope<_CharT, _Alloc>& __right)
+    {
+      // Inlining this should make it possible to keep __left and
+      // __right in registers.
+      typedef rope<_CharT, _Alloc> rope_type;
+      return rope_type(rope_type::_S_concat(__left._M_tree_ptr, 
+					    __right._M_tree_ptr));
+    }
+
+  template <class _CharT, class _Alloc>
+    inline rope<_CharT, _Alloc>&
+    operator+=(rope<_CharT, _Alloc>& __left,
+	       const rope<_CharT, _Alloc>& __right)
+    {
+      __left.append(__right);
+      return __left;
+    }
+
+  template <class _CharT, class _Alloc>
+    inline rope<_CharT, _Alloc>
+    operator+(const rope<_CharT, _Alloc>& __left,
+	      const _CharT* __right)
+    {
+      typedef rope<_CharT, _Alloc> rope_type;
+      size_t __rlen = rope_type::_S_char_ptr_len(__right);
+      return rope_type(rope_type::_S_concat_char_iter(__left._M_tree_ptr,
+						      __right, __rlen));
+    }
+
+  template <class _CharT, class _Alloc>
+    inline rope<_CharT, _Alloc>&
+    operator+=(rope<_CharT, _Alloc>& __left,
+	       const _CharT* __right)
+    {
+      __left.append(__right);
+      return __left;
+    }
+
+  template <class _CharT, class _Alloc>
+    inline rope<_CharT, _Alloc>
+    operator+(const rope<_CharT, _Alloc>& __left, _CharT __right)
+    {
+      typedef rope<_CharT, _Alloc> rope_type;
+      return rope_type(rope_type::_S_concat_char_iter(__left._M_tree_ptr,
+						      &__right, 1));
+    }
+
+  template <class _CharT, class _Alloc>
+    inline rope<_CharT, _Alloc>&
+    operator+=(rope<_CharT, _Alloc>& __left, _CharT __right)
+    {
+      __left.append(__right);
+      return __left;
+    }
+  
+  template <class _CharT, class _Alloc>
+    bool
+    operator<(const rope<_CharT, _Alloc>& __left,
+	      const rope<_CharT, _Alloc>& __right)
+    { return __left.compare(__right) < 0; }
+
+  template <class _CharT, class _Alloc>
+    bool
+    operator==(const rope<_CharT, _Alloc>& __left,
+	       const rope<_CharT, _Alloc>& __right)
+    { return __left.compare(__right) == 0; }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator==(const _Rope_char_ptr_proxy<_CharT, _Alloc>& __x,
+	       const _Rope_char_ptr_proxy<_CharT, _Alloc>& __y)
+    { return (__x._M_pos == __y._M_pos && __x._M_root == __y._M_root); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator!=(const rope<_CharT, _Alloc>& __x,
+	       const rope<_CharT, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator>(const rope<_CharT, _Alloc>& __x,
+	      const rope<_CharT, _Alloc>& __y)
+    { return __y < __x; }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator<=(const rope<_CharT, _Alloc>& __x,
+	       const rope<_CharT, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator>=(const rope<_CharT, _Alloc>& __x,
+	       const rope<_CharT, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  template <class _CharT, class _Alloc>
+    inline bool
+    operator!=(const _Rope_char_ptr_proxy<_CharT, _Alloc>& __x,
+	       const _Rope_char_ptr_proxy<_CharT, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template<class _CharT, class _Traits, class _Alloc>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __o,
+	       const rope<_CharT, _Alloc>& __r);
+
+  typedef rope<char> crope;
+  typedef rope<wchar_t> wrope;
+
+  inline crope::reference
+  __mutable_reference_at(crope& __c, size_t __i)
+  { return __c.mutable_reference_at(__i); }
+
+  inline wrope::reference
+  __mutable_reference_at(wrope& __c, size_t __i)
+  { return __c.mutable_reference_at(__i); }
+
+  template <class _CharT, class _Alloc>
+    inline void
+    swap(rope<_CharT, _Alloc>& __x, rope<_CharT, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{ 
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<>
+    struct hash<__gnu_cxx::crope>
+    {
+      size_t
+      operator()(const __gnu_cxx::crope& __str) const
+      {
+	size_t __size = __str.size();
+	if (0 == __size)
+	  return 0;
+	return 13 * __str[0] + 5 * __str[__size - 1] + __size;
+      }
+    };
+
+
+  template<>
+    struct hash<__gnu_cxx::wrope>
+    {
+      size_t
+      operator()(const __gnu_cxx::wrope& __str) const
+      {
+	size_t __size = __str.size();
+	if (0 == __size)
+	  return 0;
+	return 13 * __str[0] + 5 * __str[__size - 1] + __size;
+      }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace tr1
+} // namespace std
+
+# include <ext/ropeimpl.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/ropeimpl.h b/gcc-4.9/libstdc++-v3/include/ext/ropeimpl.h
new file mode 100644
index 0000000..8363e74
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/ropeimpl.h
@@ -0,0 +1,1703 @@
+// SGI's rope class implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file ropeimpl.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/rope}
+ */
+
+#include <cstdio>
+#include <ostream>
+#include <bits/functexcept.h>
+
+#include <ext/algorithm> // For copy_n and lexicographical_compare_3way
+#include <ext/memory> // For uninitialized_copy_n
+#include <ext/numeric> // For power
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::printf;
+  using std::basic_ostream;
+  using std::__throw_length_error;
+  using std::_Destroy;
+  using std::__uninitialized_fill_n_a;
+
+  // Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
+  // if necessary.  Assumes _M_path_end[leaf_index] and leaf_pos are correct.
+  // Results in a valid buf_ptr if the iterator can be legitimately
+  // dereferenced.
+  template <class _CharT, class _Alloc>
+    void
+    _Rope_iterator_base<_CharT, _Alloc>::
+    _S_setbuf(_Rope_iterator_base<_CharT, _Alloc>& __x)
+    {
+      const _RopeRep* __leaf = __x._M_path_end[__x._M_leaf_index];
+      size_t __leaf_pos = __x._M_leaf_pos;
+      size_t __pos = __x._M_current_pos;
+
+      switch(__leaf->_M_tag)
+	{
+	case __detail::_S_leaf:
+	  __x._M_buf_start = ((_Rope_RopeLeaf<_CharT, _Alloc>*)__leaf)->_M_data;
+	  __x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos);
+	  __x._M_buf_end = __x._M_buf_start + __leaf->_M_size;
+	  break;
+	case __detail::_S_function:
+	case __detail::_S_substringfn:
+	  {
+	    size_t __len = _S_iterator_buf_len;
+	    size_t __buf_start_pos = __leaf_pos;
+	    size_t __leaf_end = __leaf_pos + __leaf->_M_size;
+	    char_producer<_CharT>* __fn = ((_Rope_RopeFunction<_CharT,
+					    _Alloc>*)__leaf)->_M_fn;
+	    if (__buf_start_pos + __len <= __pos)
+	      {
+		__buf_start_pos = __pos - __len / 4;
+		if (__buf_start_pos + __len > __leaf_end)
+		  __buf_start_pos = __leaf_end - __len;
+	      }
+	    if (__buf_start_pos + __len > __leaf_end)
+	      __len = __leaf_end - __buf_start_pos;
+	    (*__fn)(__buf_start_pos - __leaf_pos, __len, __x._M_tmp_buf);
+	    __x._M_buf_ptr = __x._M_tmp_buf + (__pos - __buf_start_pos);
+	    __x._M_buf_start = __x._M_tmp_buf;
+	    __x._M_buf_end = __x._M_tmp_buf + __len;
+	  }
+	  break;
+	default:
+	  break;
+	}
+    }
+
+  // Set path and buffer inside a rope iterator.  We assume that
+  // pos and root are already set.
+  template <class _CharT, class _Alloc>
+    void
+    _Rope_iterator_base<_CharT, _Alloc>::
+    _S_setcache(_Rope_iterator_base<_CharT, _Alloc>& __x)
+    {
+      const _RopeRep* __path[int(__detail::_S_max_rope_depth) + 1];
+      const _RopeRep* __curr_rope;
+      int __curr_depth = -1;  /* index into path    */
+      size_t __curr_start_pos = 0;
+      size_t __pos = __x._M_current_pos;
+      unsigned char __dirns = 0; // Bit vector marking right turns in the path
+
+      if (__pos >= __x._M_root->_M_size)
+	{
+	  __x._M_buf_ptr = 0;
+	  return;
+	}
+      __curr_rope = __x._M_root;
+      if (0 != __curr_rope->_M_c_string)
+	{
+	  /* Treat the root as a leaf. */
+	  __x._M_buf_start = __curr_rope->_M_c_string;
+	  __x._M_buf_end = __curr_rope->_M_c_string + __curr_rope->_M_size;
+	  __x._M_buf_ptr = __curr_rope->_M_c_string + __pos;
+	  __x._M_path_end[0] = __curr_rope;
+	  __x._M_leaf_index = 0;
+	  __x._M_leaf_pos = 0;
+	  return;
+	}
+      for(;;)
+	{
+	  ++__curr_depth;
+	  __path[__curr_depth] = __curr_rope;
+	  switch(__curr_rope->_M_tag)
+	    {
+	    case __detail::_S_leaf:
+	    case __detail::_S_function:
+	    case __detail::_S_substringfn:
+	      __x._M_leaf_pos = __curr_start_pos;
+	      goto done;
+	    case __detail::_S_concat:
+	      {
+		_Rope_RopeConcatenation<_CharT, _Alloc>* __c =
+		  (_Rope_RopeConcatenation<_CharT, _Alloc>*)__curr_rope;
+		_RopeRep* __left = __c->_M_left;
+		size_t __left_len = __left->_M_size;
+
+		__dirns <<= 1;
+		if (__pos >= __curr_start_pos + __left_len)
+		  {
+		    __dirns |= 1;
+		    __curr_rope = __c->_M_right;
+		    __curr_start_pos += __left_len;
+		  }
+		else
+		  __curr_rope = __left;
+	      }
+	      break;
+	    }
+	}
+    done:
+      // Copy last section of path into _M_path_end.
+      {
+	int __i = -1;
+	int __j = __curr_depth + 1 - int(_S_path_cache_len);
+
+	if (__j < 0) __j = 0;
+	while (__j <= __curr_depth)
+	  __x._M_path_end[++__i] = __path[__j++];
+	__x._M_leaf_index = __i;
+      }
+      __x._M_path_directions = __dirns;
+      _S_setbuf(__x);
+    }
+
+  // Specialized version of the above.  Assumes that
+  // the path cache is valid for the previous position.
+  template <class _CharT, class _Alloc>
+    void
+    _Rope_iterator_base<_CharT, _Alloc>::
+    _S_setcache_for_incr(_Rope_iterator_base<_CharT, _Alloc>& __x)
+    {
+      int __current_index = __x._M_leaf_index;
+      const _RopeRep* __current_node = __x._M_path_end[__current_index];
+      size_t __len = __current_node->_M_size;
+      size_t __node_start_pos = __x._M_leaf_pos;
+      unsigned char __dirns = __x._M_path_directions;
+      _Rope_RopeConcatenation<_CharT, _Alloc>* __c;
+
+      if (__x._M_current_pos - __node_start_pos < __len)
+	{
+	  /* More stuff in this leaf, we just didn't cache it. */
+	  _S_setbuf(__x);
+	  return;
+	}
+      //  node_start_pos is starting position of last_node.
+      while (--__current_index >= 0)
+	{
+	  if (!(__dirns & 1) /* Path turned left */)
+	    break;
+	  __current_node = __x._M_path_end[__current_index];
+	  __c = (_Rope_RopeConcatenation<_CharT, _Alloc>*)__current_node;
+	  // Otherwise we were in the right child.  Thus we should pop
+	  // the concatenation node.
+	  __node_start_pos -= __c->_M_left->_M_size;
+	  __dirns >>= 1;
+	}
+      if (__current_index < 0)
+	{
+	  // We underflowed the cache. Punt.
+	  _S_setcache(__x);
+	  return;
+	}
+      __current_node = __x._M_path_end[__current_index];
+      __c = (_Rope_RopeConcatenation<_CharT, _Alloc>*)__current_node;
+      // current_node is a concatenation node.  We are positioned on the first
+      // character in its right child.
+      // node_start_pos is starting position of current_node.
+      __node_start_pos += __c->_M_left->_M_size;
+      __current_node = __c->_M_right;
+      __x._M_path_end[++__current_index] = __current_node;
+      __dirns |= 1;
+      while (__detail::_S_concat == __current_node->_M_tag)
+	{
+	  ++__current_index;
+	  if (int(_S_path_cache_len) == __current_index)
+	    {
+	      int __i;
+	      for (__i = 0; __i < int(_S_path_cache_len) - 1; __i++)
+		__x._M_path_end[__i] = __x._M_path_end[__i+1];
+	      --__current_index;
+	    }
+	  __current_node =
+	    ((_Rope_RopeConcatenation<_CharT, _Alloc>*)__current_node)->_M_left;
+	  __x._M_path_end[__current_index] = __current_node;
+	  __dirns <<= 1;
+	  // node_start_pos is unchanged.
+	}
+      __x._M_leaf_index = __current_index;
+      __x._M_leaf_pos = __node_start_pos;
+      __x._M_path_directions = __dirns;
+      _S_setbuf(__x);
+    }
+
+  template <class _CharT, class _Alloc>
+    void
+    _Rope_iterator_base<_CharT, _Alloc>::
+    _M_incr(size_t __n)
+    {
+      _M_current_pos += __n;
+      if (0 != _M_buf_ptr)
+	{
+	  size_t __chars_left = _M_buf_end - _M_buf_ptr;
+	  if (__chars_left > __n)
+	    _M_buf_ptr += __n;
+	  else if (__chars_left == __n)
+	    {
+	      _M_buf_ptr += __n;
+	      _S_setcache_for_incr(*this);
+	    }
+	  else
+	    _M_buf_ptr = 0;
+	}
+    }
+
+  template <class _CharT, class _Alloc>
+    void
+    _Rope_iterator_base<_CharT, _Alloc>::
+    _M_decr(size_t __n)
+    {
+      if (0 != _M_buf_ptr)
+	{
+	  size_t __chars_left = _M_buf_ptr - _M_buf_start;
+	  if (__chars_left >= __n)
+	    _M_buf_ptr -= __n;
+	  else
+	    _M_buf_ptr = 0;
+	}
+      _M_current_pos -= __n;
+    }
+
+  template <class _CharT, class _Alloc>
+    void
+    _Rope_iterator<_CharT, _Alloc>::
+    _M_check()
+    {
+      if (_M_root_rope->_M_tree_ptr != this->_M_root)
+	{
+	  // _Rope was modified.  Get things fixed up.
+	  _RopeRep::_S_unref(this->_M_root);
+	  this->_M_root = _M_root_rope->_M_tree_ptr;
+	  _RopeRep::_S_ref(this->_M_root);
+	  this->_M_buf_ptr = 0;
+	}
+    }
+
+  template <class _CharT, class _Alloc>
+    inline
+    _Rope_const_iterator<_CharT, _Alloc>::
+    _Rope_const_iterator(const _Rope_iterator<_CharT, _Alloc>& __x)
+    : _Rope_iterator_base<_CharT, _Alloc>(__x)
+    { }
+
+  template <class _CharT, class _Alloc>
+    inline
+    _Rope_iterator<_CharT, _Alloc>::
+    _Rope_iterator(rope<_CharT, _Alloc>& __r, size_t __pos)
+    : _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos),
+      _M_root_rope(&__r)
+    { _RopeRep::_S_ref(this->_M_root); }
+
+  template <class _CharT, class _Alloc>
+    inline size_t
+    rope<_CharT, _Alloc>::
+    _S_char_ptr_len(const _CharT* __s)
+    {
+      const _CharT* __p = __s;
+      
+      while (!_S_is0(*__p))
+	++__p;
+      return (__p - __s);
+    }
+
+
+#ifndef __GC
+
+  template <class _CharT, class _Alloc>
+    inline void
+    _Rope_RopeRep<_CharT, _Alloc>::
+    _M_free_c_string()
+    {
+      _CharT* __cstr = _M_c_string;
+      if (0 != __cstr)
+	{
+	  size_t __size = this->_M_size + 1;
+	  _Destroy(__cstr, __cstr + __size, _M_get_allocator());
+	  this->_Data_deallocate(__cstr, __size);
+	}
+    }
+
+  template <class _CharT, class _Alloc>
+    inline void
+    _Rope_RopeRep<_CharT, _Alloc>::
+    _S_free_string(_CharT* __s, size_t __n, allocator_type& __a)
+    {
+      if (!_S_is_basic_char_type((_CharT*)0))
+	_Destroy(__s, __s + __n, __a);
+      
+      //  This has to be a static member, so this gets a bit messy
+      __a.deallocate(__s,
+		     _Rope_RopeLeaf<_CharT, _Alloc>::_S_rounded_up_size(__n));
+    }
+
+  //  There are several reasons for not doing this with virtual destructors
+  //  and a class specific delete operator:
+  //  - A class specific delete operator can't easily get access to
+  //    allocator instances if we need them.
+  //  - Any virtual function would need a 4 or byte vtable pointer;
+  //    this only requires a one byte tag per object.
+  template <class _CharT, class _Alloc>
+    void
+    _Rope_RopeRep<_CharT, _Alloc>::
+    _M_free_tree()
+    {
+      switch(_M_tag)
+	{
+	case __detail::_S_leaf:
+	  {
+	    _Rope_RopeLeaf<_CharT, _Alloc>* __l
+	      = (_Rope_RopeLeaf<_CharT, _Alloc>*)this;
+	    __l->_Rope_RopeLeaf<_CharT, _Alloc>::~_Rope_RopeLeaf();
+	    this->_L_deallocate(__l, 1);
+	    break;
+	  }
+	case __detail::_S_concat:
+	  {
+	    _Rope_RopeConcatenation<_CharT,_Alloc>* __c
+	      = (_Rope_RopeConcatenation<_CharT, _Alloc>*)this;
+	    __c->_Rope_RopeConcatenation<_CharT, _Alloc>::
+	      ~_Rope_RopeConcatenation();
+	    this->_C_deallocate(__c, 1);
+	    break;
+	  }
+	case __detail::_S_function:
+	  {
+	    _Rope_RopeFunction<_CharT, _Alloc>* __f
+	      = (_Rope_RopeFunction<_CharT, _Alloc>*)this;
+	    __f->_Rope_RopeFunction<_CharT, _Alloc>::~_Rope_RopeFunction();
+	    this->_F_deallocate(__f, 1);
+	    break;
+	  }
+	case __detail::_S_substringfn:
+	  {
+	    _Rope_RopeSubstring<_CharT, _Alloc>* __ss =
+	      (_Rope_RopeSubstring<_CharT, _Alloc>*)this;
+	    __ss->_Rope_RopeSubstring<_CharT, _Alloc>::
+	      ~_Rope_RopeSubstring();
+	    this->_S_deallocate(__ss, 1);
+	    break;
+	  }
+	}
+    }
+#else
+
+  template <class _CharT, class _Alloc>
+    inline void
+    _Rope_RopeRep<_CharT, _Alloc>::
+    _S_free_string(const _CharT*, size_t, allocator_type)
+    { }
+
+#endif
+
+  // Concatenate a C string onto a leaf rope by copying the rope data.
+  // Used for short ropes.
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT, _Alloc>::_RopeLeaf*
+    rope<_CharT, _Alloc>::
+    _S_leaf_concat_char_iter(_RopeLeaf* __r, const _CharT* __iter, size_t __len)
+    {
+      size_t __old_len = __r->_M_size;
+      _CharT* __new_data = (_CharT*)
+	rope::_Data_allocate(_S_rounded_up_size(__old_len + __len));
+      _RopeLeaf* __result;
+
+      uninitialized_copy_n(__r->_M_data, __old_len, __new_data);
+      uninitialized_copy_n(__iter, __len, __new_data + __old_len);
+      _S_cond_store_eos(__new_data[__old_len + __len]);
+      __try
+	{
+	  __result = _S_new_RopeLeaf(__new_data, __old_len + __len,
+				     __r->_M_get_allocator());
+	}
+      __catch(...)
+	{
+	  _RopeRep::__STL_FREE_STRING(__new_data, __old_len + __len,
+				      __r->_M_get_allocator());
+	  __throw_exception_again;
+	}
+      return __result;
+    }
+
+#ifndef __GC
+  // As above, but it's OK to clobber original if refcount is 1
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT,_Alloc>::_RopeLeaf*
+    rope<_CharT, _Alloc>::
+    _S_destr_leaf_concat_char_iter(_RopeLeaf* __r, const _CharT* __iter,
+				   size_t __len)
+    {
+      if (__r->_M_ref_count > 1)
+	return _S_leaf_concat_char_iter(__r, __iter, __len);
+      size_t __old_len = __r->_M_size;
+      if (_S_allocated_capacity(__old_len) >= __old_len + __len)
+	{
+	  // The space has been partially initialized for the standard
+	  // character types.  But that doesn't matter for those types.
+	  uninitialized_copy_n(__iter, __len, __r->_M_data + __old_len);
+	  if (_S_is_basic_char_type((_CharT*)0))
+	    _S_cond_store_eos(__r->_M_data[__old_len + __len]);
+	  else if (__r->_M_c_string != __r->_M_data && 0 != __r->_M_c_string)
+	    {
+	      __r->_M_free_c_string();
+	      __r->_M_c_string = 0;
+	    }
+	  __r->_M_size = __old_len + __len;
+	  __r->_M_ref_count = 2;
+	  return __r;
+	}
+      else
+	{
+	  _RopeLeaf* __result = _S_leaf_concat_char_iter(__r, __iter, __len);
+	  return __result;
+	}
+    }
+#endif
+
+  // Assumes left and right are not 0.
+  // Does not increment (nor decrement on exception) child reference counts.
+  // Result has ref count 1.
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT, _Alloc>::_RopeRep*
+    rope<_CharT, _Alloc>::
+    _S_tree_concat(_RopeRep* __left, _RopeRep* __right)
+    {
+      _RopeConcatenation* __result = _S_new_RopeConcatenation(__left, __right,
+							      __left->
+							      _M_get_allocator());
+      size_t __depth = __result->_M_depth;
+      
+      if (__depth > 20
+	  && (__result->_M_size < 1000
+	      || __depth > size_t(__detail::_S_max_rope_depth)))
+	{
+	  _RopeRep* __balanced;
+
+	  __try
+	    {
+	      __balanced = _S_balance(__result);
+	      __result->_M_unref_nonnil();
+	    }
+	  __catch(...)
+	    {
+	      rope::_C_deallocate(__result,1);
+	      __throw_exception_again;
+	    }
+	  // In case of exception, we need to deallocate
+	  // otherwise dangling result node.  But caller
+	  // still owns its children.  Thus unref is
+	  // inappropriate.
+	  return __balanced;
+	}
+      else
+	return __result;
+    }
+
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT, _Alloc>::_RopeRep*
+    rope<_CharT, _Alloc>::
+    _S_concat_char_iter(_RopeRep* __r, const _CharT*__s, size_t __slen)
+    {
+      _RopeRep* __result;
+      if (0 == __slen)
+	{
+	  _S_ref(__r);
+	  return __r;
+	}
+      if (0 == __r)
+	return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
+						__r->_M_get_allocator());
+      if (__r->_M_tag == __detail::_S_leaf
+	  && __r->_M_size + __slen <= size_t(_S_copy_max))
+	{
+	  __result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
+	  return __result;
+	}
+      if (__detail::_S_concat == __r->_M_tag
+	  && __detail::_S_leaf == ((_RopeConcatenation*) __r)->_M_right->_M_tag)
+	{
+	  _RopeLeaf* __right =
+	    (_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right);
+	  if (__right->_M_size + __slen <= size_t(_S_copy_max))
+	    {
+	      _RopeRep* __left = ((_RopeConcatenation*)__r)->_M_left;
+	      _RopeRep* __nright =
+		_S_leaf_concat_char_iter((_RopeLeaf*)__right, __s, __slen);
+	      __left->_M_ref_nonnil();
+	      __try
+		{ __result = _S_tree_concat(__left, __nright); }
+	      __catch(...)
+		{
+		  _S_unref(__left);
+		  _S_unref(__nright);
+		  __throw_exception_again;
+		}
+	      return __result;
+	    }
+	}
+      _RopeRep* __nright =
+	__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->_M_get_allocator());
+      __try
+	{
+	  __r->_M_ref_nonnil();
+	  __result = _S_tree_concat(__r, __nright);
+	}
+      __catch(...)
+	{
+	  _S_unref(__r);
+	  _S_unref(__nright);
+	  __throw_exception_again;
+	}
+      return __result;
+    }
+
+#ifndef __GC
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT,_Alloc>::_RopeRep*
+    rope<_CharT,_Alloc>::
+    _S_destr_concat_char_iter(_RopeRep* __r, const _CharT* __s, size_t __slen)
+    {
+      _RopeRep* __result;
+      if (0 == __r)
+	return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
+						__r->_M_get_allocator());
+      size_t __count = __r->_M_ref_count;
+      size_t __orig_size = __r->_M_size;
+      if (__count > 1)
+	return _S_concat_char_iter(__r, __s, __slen);
+      if (0 == __slen)
+	{
+	  __r->_M_ref_count = 2;      // One more than before
+	  return __r;
+	}
+      if (__orig_size + __slen <= size_t(_S_copy_max)
+	  && __detail::_S_leaf == __r->_M_tag)
+	{
+	  __result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, 
+						    __slen);
+	  return __result;
+	}
+      if (__detail::_S_concat == __r->_M_tag)
+	{
+	  _RopeLeaf* __right = (_RopeLeaf*)(((_RopeConcatenation*)
+					     __r)->_M_right);
+	  if (__detail::_S_leaf == __right->_M_tag
+	      && __right->_M_size + __slen <= size_t(_S_copy_max))
+	    {
+	      _RopeRep* __new_right =
+		_S_destr_leaf_concat_char_iter(__right, __s, __slen);
+	      if (__right == __new_right)
+		__new_right->_M_ref_count = 1;
+	      else
+		__right->_M_unref_nonnil();
+	      __r->_M_ref_count = 2;    // One more than before.
+	      ((_RopeConcatenation*)__r)->_M_right = __new_right;
+	      __r->_M_size = __orig_size + __slen;
+	      if (0 != __r->_M_c_string)
+		{
+		  __r->_M_free_c_string();
+		  __r->_M_c_string = 0;
+		}
+	      return __r;
+	    }
+	}
+      _RopeRep* __right =
+	__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->_M_get_allocator());
+      __r->_M_ref_nonnil();
+      __try
+	{ __result = _S_tree_concat(__r, __right); }
+      __catch(...)
+	{
+	  _S_unref(__r);
+	  _S_unref(__right);
+	  __throw_exception_again;
+	}
+      return __result;
+    }
+#endif /* !__GC */
+  
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT, _Alloc>::_RopeRep*
+    rope<_CharT, _Alloc>::
+    _S_concat(_RopeRep* __left, _RopeRep* __right)
+    {
+      if (0 == __left)
+	{
+	  _S_ref(__right);
+	  return __right;
+	}
+      if (0 == __right)
+	{
+	  __left->_M_ref_nonnil();
+	  return __left;
+	}
+      if (__detail::_S_leaf == __right->_M_tag)
+	{
+	  if (__detail::_S_leaf == __left->_M_tag)
+	    {
+	      if (__right->_M_size + __left->_M_size <= size_t(_S_copy_max))
+		return _S_leaf_concat_char_iter((_RopeLeaf*)__left,
+						((_RopeLeaf*)__right)->_M_data,
+						__right->_M_size);
+	    }
+	  else if (__detail::_S_concat == __left->_M_tag
+		   && __detail::_S_leaf == ((_RopeConcatenation*)
+						   __left)->_M_right->_M_tag)
+	    {
+	      _RopeLeaf* __leftright =
+		(_RopeLeaf*)(((_RopeConcatenation*)__left)->_M_right);
+	      if (__leftright->_M_size
+		  + __right->_M_size <= size_t(_S_copy_max))
+		{
+		  _RopeRep* __leftleft = ((_RopeConcatenation*)__left)->_M_left;
+		  _RopeRep* __rest = _S_leaf_concat_char_iter(__leftright,
+							      ((_RopeLeaf*)
+							       __right)->
+							      _M_data,
+							      __right->_M_size);
+		  __leftleft->_M_ref_nonnil();
+		  __try
+		    { return(_S_tree_concat(__leftleft, __rest)); }
+		  __catch(...)
+		    {
+		      _S_unref(__leftleft);
+		      _S_unref(__rest);
+		      __throw_exception_again;
+		    }
+		}
+	    }
+	}
+      __left->_M_ref_nonnil();
+      __right->_M_ref_nonnil();
+      __try
+	{ return(_S_tree_concat(__left, __right)); }
+      __catch(...)
+	{
+	  _S_unref(__left);
+	  _S_unref(__right);
+	  __throw_exception_again;
+	}
+    }
+
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT, _Alloc>::_RopeRep*
+    rope<_CharT, _Alloc>::
+    _S_substring(_RopeRep* __base, size_t __start, size_t __endp1)
+    {
+      if (0 == __base)
+	return 0;
+      size_t __len = __base->_M_size;
+      size_t __adj_endp1;
+      const size_t __lazy_threshold = 128;
+      
+      if (__endp1 >= __len)
+	{
+	  if (0 == __start)
+	    {
+	      __base->_M_ref_nonnil();
+	      return __base;
+	    }
+	  else
+	    __adj_endp1 = __len;
+	  
+	}
+      else
+	__adj_endp1 = __endp1;
+
+      switch(__base->_M_tag)
+	{
+	case __detail::_S_concat:
+	    {
+	      _RopeConcatenation* __c = (_RopeConcatenation*)__base;
+	      _RopeRep* __left = __c->_M_left;
+	      _RopeRep* __right = __c->_M_right;
+	      size_t __left_len = __left->_M_size;
+	      _RopeRep* __result;
+	      
+	      if (__adj_endp1 <= __left_len)
+		return _S_substring(__left, __start, __endp1);
+	      else if (__start >= __left_len)
+		return _S_substring(__right, __start - __left_len,
+				    __adj_endp1 - __left_len);
+	      _Self_destruct_ptr __left_result(_S_substring(__left,
+							    __start,
+							    __left_len));
+	      _Self_destruct_ptr __right_result(_S_substring(__right, 0,
+							     __endp1 
+							     - __left_len));
+	      __result = _S_concat(__left_result, __right_result);
+	      return __result;
+	    }
+	case __detail::_S_leaf:
+	  {
+	    _RopeLeaf* __l = (_RopeLeaf*)__base;
+	    _RopeLeaf* __result;
+	    size_t __result_len;
+	    if (__start >= __adj_endp1)
+	      return 0;
+	    __result_len = __adj_endp1 - __start;
+	    if (__result_len > __lazy_threshold)
+	      goto lazy;
+#ifdef __GC
+	    const _CharT* __section = __l->_M_data + __start;
+	    __result = _S_new_RopeLeaf(__section, __result_len,
+				       __base->_M_get_allocator());
+	    __result->_M_c_string = 0;  // Not eos terminated.
+#else
+	    // We should sometimes create substring node instead.
+	    __result = __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__l->_M_data + __start,
+							__result_len,
+							__base->
+							_M_get_allocator());
+#endif
+	    return __result;
+	  }
+	case __detail::_S_substringfn:
+	  // Avoid introducing multiple layers of substring nodes.
+	  {
+	    _RopeSubstring* __old = (_RopeSubstring*)__base;
+	    size_t __result_len;
+	    if (__start >= __adj_endp1)
+	      return 0;
+	    __result_len = __adj_endp1 - __start;
+	    if (__result_len > __lazy_threshold)
+	      {
+		_RopeSubstring* __result =
+		  _S_new_RopeSubstring(__old->_M_base,
+				       __start + __old->_M_start,
+				       __adj_endp1 - __start,
+				       __base->_M_get_allocator());
+		return __result;
+		
+	      } // *** else fall through: ***
+	  }
+	case __detail::_S_function:
+	  {
+	    _RopeFunction* __f = (_RopeFunction*)__base;
+	    _CharT* __section;
+	    size_t __result_len;
+	    if (__start >= __adj_endp1)
+	      return 0;
+	    __result_len = __adj_endp1 - __start;
+	    
+	    if (__result_len > __lazy_threshold)
+	      goto lazy;
+	    __section = (_CharT*)
+	      rope::_Data_allocate(_S_rounded_up_size(__result_len));
+	    __try
+	      {	(*(__f->_M_fn))(__start, __result_len, __section); }
+	    __catch(...)
+	      {
+		_RopeRep::__STL_FREE_STRING(__section, __result_len,
+					    __base->_M_get_allocator());
+		__throw_exception_again;
+	      }
+	    _S_cond_store_eos(__section[__result_len]);
+	    return _S_new_RopeLeaf(__section, __result_len,
+				   __base->_M_get_allocator());
+	  }
+	}
+    lazy:
+      {
+	// Create substring node.
+	return _S_new_RopeSubstring(__base, __start, __adj_endp1 - __start,
+				    __base->_M_get_allocator());
+      }
+    }
+
+  template<class _CharT>
+    class _Rope_flatten_char_consumer
+    : public _Rope_char_consumer<_CharT>
+    {
+    private:
+      _CharT* _M_buf_ptr;
+    public:
+      
+      _Rope_flatten_char_consumer(_CharT* __buffer)
+      { _M_buf_ptr = __buffer; };
+
+      ~_Rope_flatten_char_consumer() {}
+      
+      bool
+      operator()(const _CharT* __leaf, size_t __n)
+      {
+	uninitialized_copy_n(__leaf, __n, _M_buf_ptr);
+	_M_buf_ptr += __n;
+	return true;
+      }
+    };
+
+  template<class _CharT>
+    class _Rope_find_char_char_consumer
+    : public _Rope_char_consumer<_CharT>
+    {
+    private:
+      _CharT _M_pattern;
+    public:
+      size_t _M_count;  // Number of nonmatching characters
+      
+      _Rope_find_char_char_consumer(_CharT __p)
+      : _M_pattern(__p), _M_count(0) {}
+	
+      ~_Rope_find_char_char_consumer() {}
+      
+      bool
+      operator()(const _CharT* __leaf, size_t __n)
+      {
+	size_t __i;
+	for (__i = 0; __i < __n; __i++)
+	  {
+	    if (__leaf[__i] == _M_pattern)
+	      {
+		_M_count += __i;
+		return false;
+	      }
+	  }
+	_M_count += __n; return true;
+      }
+    };
+
+  template<class _CharT, class _Traits>
+  // Here _CharT is both the stream and rope character type.
+    class _Rope_insert_char_consumer
+    : public _Rope_char_consumer<_CharT>
+    {
+    private:
+      typedef basic_ostream<_CharT,_Traits> _Insert_ostream;
+      _Insert_ostream& _M_o;
+    public:
+      _Rope_insert_char_consumer(_Insert_ostream& __writer)
+	: _M_o(__writer) {};
+      ~_Rope_insert_char_consumer() { };
+      // Caller is presumed to own the ostream
+      bool operator() (const _CharT* __leaf, size_t __n);
+      // Returns true to continue traversal.
+    };
+
+  template<class _CharT, class _Traits>
+    bool
+    _Rope_insert_char_consumer<_CharT, _Traits>::
+    operator()(const _CharT* __leaf, size_t __n)
+    {
+      size_t __i;
+      //  We assume that formatting is set up correctly for each element.
+      for (__i = 0; __i < __n; __i++)
+	_M_o.put(__leaf[__i]);
+      return true;
+    }
+
+  template <class _CharT, class _Alloc>
+    bool
+    rope<_CharT, _Alloc>::
+    _S_apply_to_pieces(_Rope_char_consumer<_CharT>& __c,
+		       const _RopeRep* __r, size_t __begin, size_t __end)
+    {
+      if (0 == __r)
+	return true;
+      switch(__r->_M_tag)
+	{
+	case __detail::_S_concat:
+	  {
+	    _RopeConcatenation* __conc = (_RopeConcatenation*)__r;
+	    _RopeRep* __left =  __conc->_M_left;
+	    size_t __left_len = __left->_M_size;
+	    if (__begin < __left_len)
+	      {
+		size_t __left_end = std::min(__left_len, __end);
+		if (!_S_apply_to_pieces(__c, __left, __begin, __left_end))
+		  return false;
+	      }
+	    if (__end > __left_len)
+	      {
+		_RopeRep* __right =  __conc->_M_right;
+		size_t __right_start = std::max(__left_len, __begin);
+		if (!_S_apply_to_pieces(__c, __right,
+					__right_start - __left_len,
+					__end - __left_len))
+		  return false;
+	      }
+	  }
+	  return true;
+	case __detail::_S_leaf:
+	  {
+	    _RopeLeaf* __l = (_RopeLeaf*)__r;
+	    return __c(__l->_M_data + __begin, __end - __begin);
+	  }
+	case __detail::_S_function:
+	case __detail::_S_substringfn:
+	    {
+	      _RopeFunction* __f = (_RopeFunction*)__r;
+	      size_t __len = __end - __begin;
+	      bool __result;
+	      _CharT* __buffer =
+		(_CharT*)_Alloc().allocate(__len * sizeof(_CharT));
+	      __try
+		{
+		  (*(__f->_M_fn))(__begin, __len, __buffer);
+		  __result = __c(__buffer, __len);
+                  _Alloc().deallocate(__buffer, __len * sizeof(_CharT));
+                }
+	      __catch(...)
+		{
+		  _Alloc().deallocate(__buffer, __len * sizeof(_CharT));
+		  __throw_exception_again;
+		}
+	      return __result;
+	    }
+	default:
+	  return false;
+	}
+    }
+
+  template<class _CharT, class _Traits>
+    inline void
+    _Rope_fill(basic_ostream<_CharT, _Traits>& __o, size_t __n)
+    {
+      char __f = __o.fill();
+      size_t __i;
+      
+      for (__i = 0; __i < __n; __i++)
+	__o.put(__f);
+    }
+
+
+  template <class _CharT>
+    inline bool
+    _Rope_is_simple(_CharT*)
+    { return false; }
+
+  inline bool
+  _Rope_is_simple(char*)
+  { return true; }
+
+  inline bool
+  _Rope_is_simple(wchar_t*)
+  { return true; }
+
+  template<class _CharT, class _Traits, class _Alloc>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __o,
+	       const rope<_CharT, _Alloc>& __r)
+    {
+      size_t __w = __o.width();
+      bool __left = bool(__o.flags() & std::ios::left);
+      size_t __pad_len;
+      size_t __rope_len = __r.size();
+      _Rope_insert_char_consumer<_CharT, _Traits> __c(__o);
+      bool __is_simple = _Rope_is_simple((_CharT*)0);
+      
+      if (__rope_len < __w)
+	__pad_len = __w - __rope_len;
+      else
+	__pad_len = 0;
+
+      if (!__is_simple)
+	__o.width(__w / __rope_len);
+      __try
+	{
+	  if (__is_simple && !__left && __pad_len > 0)
+	    _Rope_fill(__o, __pad_len);
+	  __r.apply_to_pieces(0, __r.size(), __c);
+	  if (__is_simple && __left && __pad_len > 0)
+	    _Rope_fill(__o, __pad_len);
+	  if (!__is_simple)
+	    __o.width(__w);
+	}
+      __catch(...)
+	{
+	  if (!__is_simple)
+	    __o.width(__w);
+	  __throw_exception_again;
+	}
+      return __o;
+    }
+
+  template <class _CharT, class _Alloc>
+    _CharT*
+    rope<_CharT, _Alloc>::
+    _S_flatten(_RopeRep* __r, size_t __start, size_t __len,
+	       _CharT* __buffer)
+    {
+      _Rope_flatten_char_consumer<_CharT> __c(__buffer);
+      _S_apply_to_pieces(__c, __r, __start, __start + __len);
+      return(__buffer + __len);
+    }
+
+  template <class _CharT, class _Alloc>
+    size_t
+    rope<_CharT, _Alloc>::
+    find(_CharT __pattern, size_t __start) const
+    {
+      _Rope_find_char_char_consumer<_CharT> __c(__pattern);
+      _S_apply_to_pieces(__c, this->_M_tree_ptr, __start, size());
+      size_type __result_pos = __start + __c._M_count;
+#ifndef __STL_OLD_ROPE_SEMANTICS
+      if (__result_pos == size())
+	__result_pos = npos;
+#endif
+      return __result_pos;
+    }
+
+  template <class _CharT, class _Alloc>
+    _CharT*
+    rope<_CharT, _Alloc>::
+    _S_flatten(_RopeRep* __r, _CharT* __buffer)
+    {
+      if (0 == __r)
+	return __buffer;
+      switch(__r->_M_tag)
+	{
+	case __detail::_S_concat:
+	  {
+	    _RopeConcatenation* __c = (_RopeConcatenation*)__r;
+	    _RopeRep* __left = __c->_M_left;
+	    _RopeRep* __right = __c->_M_right;
+	    _CharT* __rest = _S_flatten(__left, __buffer);
+	    return _S_flatten(__right, __rest);
+	  }
+	case __detail::_S_leaf:
+	  {
+	    _RopeLeaf* __l = (_RopeLeaf*)__r;
+	    return copy_n(__l->_M_data, __l->_M_size, __buffer).second;
+	  }
+	case __detail::_S_function:
+	case __detail::_S_substringfn:
+	  // We don't yet do anything with substring nodes.
+	  // This needs to be fixed before ropefiles will work well.
+	  {
+	    _RopeFunction* __f = (_RopeFunction*)__r;
+	    (*(__f->_M_fn))(0, __f->_M_size, __buffer);
+	    return __buffer + __f->_M_size;
+	  }
+	default:
+	  return 0;
+	}
+    }
+
+  // This needs work for _CharT != char
+  template <class _CharT, class _Alloc>
+    void
+    rope<_CharT, _Alloc>::
+    _S_dump(_RopeRep* __r, int __indent)
+    {
+      for (int __i = 0; __i < __indent; __i++)
+	putchar(' ');
+      if (0 == __r)
+	{
+	  printf("NULL\n");
+	  return;
+	}
+      if (_S_concat == __r->_M_tag)
+	{
+	  _RopeConcatenation* __c = (_RopeConcatenation*)__r;
+	  _RopeRep* __left = __c->_M_left;
+	  _RopeRep* __right = __c->_M_right;
+	  
+#ifdef __GC
+	  printf("Concatenation %p (depth = %d, len = %ld, %s balanced)\n",
+		 __r, __r->_M_depth, __r->_M_size,
+		 __r->_M_is_balanced? "" : "not");
+#else
+	  printf("Concatenation %p (rc = %ld, depth = %d, "
+		 "len = %ld, %s balanced)\n",
+		 __r, __r->_M_ref_count, __r->_M_depth, __r->_M_size,
+		 __r->_M_is_balanced? "" : "not");
+#endif
+	  _S_dump(__left, __indent + 2);
+	  _S_dump(__right, __indent + 2);
+	  return;
+	}
+      else
+	{
+	  char* __kind;
+	  
+	  switch (__r->_M_tag)
+	    {
+	    case __detail::_S_leaf:
+	      __kind = "Leaf";
+	      break;
+	    case __detail::_S_function:
+	      __kind = "Function";
+	      break;
+	    case __detail::_S_substringfn:
+	      __kind = "Function representing substring";
+	      break;
+	    default:
+	      __kind = "(corrupted kind field!)";
+	    }
+#ifdef __GC
+	  printf("%s %p (depth = %d, len = %ld) ",
+		 __kind, __r, __r->_M_depth, __r->_M_size);
+#else
+	  printf("%s %p (rc = %ld, depth = %d, len = %ld) ",
+		 __kind, __r, __r->_M_ref_count, __r->_M_depth, __r->_M_size);
+#endif
+	  if (_S_is_one_byte_char_type((_CharT*)0))
+	    {
+	      const int __max_len = 40;
+	      _Self_destruct_ptr __prefix(_S_substring(__r, 0, __max_len));
+	      _CharT __buffer[__max_len + 1];
+	      bool __too_big = __r->_M_size > __prefix->_M_size;
+	      
+	      _S_flatten(__prefix, __buffer);
+	      __buffer[__prefix->_M_size] = _S_eos((_CharT*)0);
+	      printf("%s%s\n", (char*)__buffer,
+		     __too_big? "...\n" : "\n");
+	    }
+	  else
+	    printf("\n");
+	}
+    }
+
+  template <class _CharT, class _Alloc>
+    const unsigned long
+    rope<_CharT, _Alloc>::
+    _S_min_len[int(__detail::_S_max_rope_depth) + 1] = {
+      /* 0 */1, /* 1 */2, /* 2 */3, /* 3 */5, /* 4 */8, /* 5 */13, /* 6 */21,
+      /* 7 */34, /* 8 */55, /* 9 */89, /* 10 */144, /* 11 */233, /* 12 */377,
+      /* 13 */610, /* 14 */987, /* 15 */1597, /* 16 */2584, /* 17 */4181,
+      /* 18 */6765, /* 19 */10946, /* 20 */17711, /* 21 */28657, /* 22 */46368,
+      /* 23 */75025, /* 24 */121393, /* 25 */196418, /* 26 */317811,
+      /* 27 */514229, /* 28 */832040, /* 29 */1346269, /* 30 */2178309,
+      /* 31 */3524578, /* 32 */5702887, /* 33 */9227465, /* 34 */14930352,
+      /* 35 */24157817, /* 36 */39088169, /* 37 */63245986, /* 38 */102334155,
+      /* 39 */165580141, /* 40 */267914296, /* 41 */433494437,
+      /* 42 */701408733, /* 43 */1134903170, /* 44 */1836311903,
+      /* 45 */2971215073u };
+  // These are Fibonacci numbers < 2**32.
+
+  template <class _CharT, class _Alloc>
+    typename rope<_CharT, _Alloc>::_RopeRep*
+    rope<_CharT, _Alloc>::
+    _S_balance(_RopeRep* __r)
+    {
+      _RopeRep* __forest[int(__detail::_S_max_rope_depth) + 1];
+      _RopeRep* __result = 0;
+      int __i;
+      // Invariant:
+      // The concatenation of forest in descending order is equal to __r.
+      // __forest[__i]._M_size >= _S_min_len[__i]
+      // __forest[__i]._M_depth = __i
+      // References from forest are included in refcount.
+      
+      for (__i = 0; __i <= int(__detail::_S_max_rope_depth); ++__i)
+	__forest[__i] = 0;
+      __try
+	{
+	  _S_add_to_forest(__r, __forest);
+	  for (__i = 0; __i <= int(__detail::_S_max_rope_depth); ++__i)
+	    if (0 != __forest[__i])
+	      {
+#ifndef __GC
+		_Self_destruct_ptr __old(__result);
+#endif
+		__result = _S_concat(__forest[__i], __result);
+		__forest[__i]->_M_unref_nonnil();
+#if !defined(__GC) && defined(__EXCEPTIONS)
+		__forest[__i] = 0;
+#endif
+	      }
+	}
+      __catch(...)
+	{
+	  for(__i = 0; __i <= int(__detail::_S_max_rope_depth); __i++)
+	    _S_unref(__forest[__i]);
+	  __throw_exception_again;
+	}
+      
+      if (__result->_M_depth > int(__detail::_S_max_rope_depth))
+	__throw_length_error(__N("rope::_S_balance"));
+      return(__result);
+    }
+
+  template <class _CharT, class _Alloc>
+    void
+    rope<_CharT, _Alloc>::
+    _S_add_to_forest(_RopeRep* __r, _RopeRep** __forest)
+    {
+      if (__r->_M_is_balanced)
+	{
+	  _S_add_leaf_to_forest(__r, __forest);
+	  return;
+	}
+
+      {
+	_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+	
+	_S_add_to_forest(__c->_M_left, __forest);
+	_S_add_to_forest(__c->_M_right, __forest);
+      }
+    }
+
+
+  template <class _CharT, class _Alloc>
+    void
+    rope<_CharT, _Alloc>::
+    _S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest)
+    {
+      _RopeRep* __insertee;		// included in refcount
+      _RopeRep* __too_tiny = 0;		// included in refcount
+      int __i;				// forest[0..__i-1] is empty
+      size_t __s = __r->_M_size;
+      
+      for (__i = 0; __s >= _S_min_len[__i+1]/* not this bucket */; ++__i)
+	{
+	  if (0 != __forest[__i])
+	    {
+#ifndef __GC
+	      _Self_destruct_ptr __old(__too_tiny);
+#endif
+	      __too_tiny = _S_concat_and_set_balanced(__forest[__i],
+						      __too_tiny);
+	      __forest[__i]->_M_unref_nonnil();
+	      __forest[__i] = 0;
+	    }
+	}
+      {
+#ifndef __GC
+	_Self_destruct_ptr __old(__too_tiny);
+#endif
+	__insertee = _S_concat_and_set_balanced(__too_tiny, __r);
+      }
+      // Too_tiny dead, and no longer included in refcount.
+      // Insertee is live and included.
+      for (;; ++__i)
+	{
+	  if (0 != __forest[__i])
+	    {
+#ifndef __GC
+	      _Self_destruct_ptr __old(__insertee);
+#endif
+	      __insertee = _S_concat_and_set_balanced(__forest[__i],
+						      __insertee);
+	      __forest[__i]->_M_unref_nonnil();
+	      __forest[__i] = 0;
+	    }
+	  if (__i == int(__detail::_S_max_rope_depth)
+	      || __insertee->_M_size < _S_min_len[__i+1])
+	    {
+	      __forest[__i] = __insertee;
+	      // refcount is OK since __insertee is now dead.
+	      return;
+	    }
+	}
+    }
+
+  template <class _CharT, class _Alloc>
+    _CharT
+    rope<_CharT, _Alloc>::
+    _S_fetch(_RopeRep* __r, size_type __i)
+    {
+      __GC_CONST _CharT* __cstr = __r->_M_c_string;
+      
+      if (0 != __cstr)
+	return __cstr[__i];
+      for(;;)
+	{
+	  switch(__r->_M_tag)
+	    {
+	    case __detail::_S_concat:
+	      {
+		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+		_RopeRep* __left = __c->_M_left;
+		size_t __left_len = __left->_M_size;
+		
+		if (__i >= __left_len)
+		  {
+		    __i -= __left_len;
+		    __r = __c->_M_right;
+		  } 
+		else
+		  __r = __left;
+	      }
+	      break;
+	    case __detail::_S_leaf:
+	      {
+		_RopeLeaf* __l = (_RopeLeaf*)__r;
+		return __l->_M_data[__i];
+	      }
+	    case __detail::_S_function:
+	    case __detail::_S_substringfn:
+	      {
+		_RopeFunction* __f = (_RopeFunction*)__r;
+		_CharT __result;
+		
+		(*(__f->_M_fn))(__i, 1, &__result);
+		return __result;
+	      }
+	    }
+	}
+    }
+  
+#ifndef __GC
+  // Return a uniquely referenced character slot for the given
+  // position, or 0 if that's not possible.
+  template <class _CharT, class _Alloc>
+    _CharT*
+    rope<_CharT, _Alloc>::
+    _S_fetch_ptr(_RopeRep* __r, size_type __i)
+    {
+      _RopeRep* __clrstack[__detail::_S_max_rope_depth];
+      size_t __csptr = 0;
+      
+      for(;;)
+	{
+	  if (__r->_M_ref_count > 1)
+	    return 0;
+	  switch(__r->_M_tag)
+	    {
+	    case __detail::_S_concat:
+	      {
+		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
+		_RopeRep* __left = __c->_M_left;
+		size_t __left_len = __left->_M_size;
+		
+		if (__c->_M_c_string != 0)
+		  __clrstack[__csptr++] = __c;
+		if (__i >= __left_len)
+		  {
+		    __i -= __left_len;
+		    __r = __c->_M_right;
+		  } 
+		else
+		  __r = __left;
+	      }
+	      break;
+	    case __detail::_S_leaf:
+	      {
+		_RopeLeaf* __l = (_RopeLeaf*)__r;
+		if (__l->_M_c_string != __l->_M_data && __l->_M_c_string != 0)
+		  __clrstack[__csptr++] = __l;
+		while (__csptr > 0)
+		  {
+		    -- __csptr;
+		    _RopeRep* __d = __clrstack[__csptr];
+		    __d->_M_free_c_string();
+		    __d->_M_c_string = 0;
+		  }
+		return __l->_M_data + __i;
+	      }
+	    case __detail::_S_function:
+	    case __detail::_S_substringfn:
+	      return 0;
+	    }
+	}
+    }
+#endif /* __GC */
+
+  // The following could be implemented trivially using
+  // lexicographical_compare_3way.
+  // We do a little more work to avoid dealing with rope iterators for
+  // flat strings.
+  template <class _CharT, class _Alloc>
+    int
+    rope<_CharT, _Alloc>::
+    _S_compare (const _RopeRep* __left, const _RopeRep* __right)
+    {
+      size_t __left_len;
+      size_t __right_len;
+      
+      if (0 == __right)
+	return 0 != __left;
+      if (0 == __left)
+	return -1;
+      __left_len = __left->_M_size;
+      __right_len = __right->_M_size;
+      if (__detail::_S_leaf == __left->_M_tag)
+	{
+	  _RopeLeaf* __l = (_RopeLeaf*) __left;
+	  if (__detail::_S_leaf == __right->_M_tag)
+	    {
+	      _RopeLeaf* __r = (_RopeLeaf*) __right;
+	      return lexicographical_compare_3way(__l->_M_data,
+						  __l->_M_data + __left_len,
+						  __r->_M_data, __r->_M_data
+						  + __right_len);
+	    }
+	  else
+	    {
+	      const_iterator __rstart(__right, 0);
+	      const_iterator __rend(__right, __right_len);
+	      return lexicographical_compare_3way(__l->_M_data, __l->_M_data
+						  + __left_len,
+						  __rstart, __rend);
+	    }
+	}
+      else
+	{
+	  const_iterator __lstart(__left, 0);
+	  const_iterator __lend(__left, __left_len);
+	  if (__detail::_S_leaf == __right->_M_tag)
+	    {
+	      _RopeLeaf* __r = (_RopeLeaf*) __right;
+	      return lexicographical_compare_3way(__lstart, __lend,
+						  __r->_M_data, __r->_M_data
+						  + __right_len);
+	    }
+	  else
+	    {
+	      const_iterator __rstart(__right, 0);
+	      const_iterator __rend(__right, __right_len);
+	      return lexicographical_compare_3way(__lstart, __lend,
+						  __rstart, __rend);
+	    }
+	}
+    }
+
+  // Assignment to reference proxies.
+  template <class _CharT, class _Alloc>
+    _Rope_char_ref_proxy<_CharT, _Alloc>&
+    _Rope_char_ref_proxy<_CharT, _Alloc>::
+    operator=(_CharT __c)
+    {
+      _RopeRep* __old = _M_root->_M_tree_ptr;
+#ifndef __GC
+      // First check for the case in which everything is uniquely
+      // referenced.  In that case we can do this destructively.
+      _CharT* __ptr = _My_rope::_S_fetch_ptr(__old, _M_pos);
+      if (0 != __ptr)
+	{
+	  *__ptr = __c;
+	  return *this;
+	}
+#endif
+      _Self_destruct_ptr __left(_My_rope::_S_substring(__old, 0, _M_pos));
+      _Self_destruct_ptr __right(_My_rope::_S_substring(__old, _M_pos + 1,
+							__old->_M_size));
+      _Self_destruct_ptr __result_left(_My_rope::
+				       _S_destr_concat_char_iter(__left,
+								 &__c, 1));
+
+      _RopeRep* __result = _My_rope::_S_concat(__result_left, __right);
+#ifndef __GC
+      _RopeRep::_S_unref(__old);
+#endif
+      _M_root->_M_tree_ptr = __result;
+      return *this;
+    }
+
+  template <class _CharT, class _Alloc>
+    inline _Rope_char_ref_proxy<_CharT, _Alloc>::
+    operator _CharT() const
+    {
+      if (_M_current_valid)
+	return _M_current;
+      else
+	return _My_rope::_S_fetch(_M_root->_M_tree_ptr, _M_pos);
+    }
+
+  template <class _CharT, class _Alloc>
+    _Rope_char_ptr_proxy<_CharT, _Alloc>
+    _Rope_char_ref_proxy<_CharT, _Alloc>::
+    operator&() const
+    { return _Rope_char_ptr_proxy<_CharT, _Alloc>(*this); }
+
+  template <class _CharT, class _Alloc>
+    rope<_CharT, _Alloc>::
+    rope(size_t __n, _CharT __c, const allocator_type& __a)
+    : _Base(__a)
+    {
+      rope<_CharT,_Alloc> __result;
+      const size_t __exponentiate_threshold = 32;
+      size_t __exponent;
+      size_t __rest;
+      _CharT* __rest_buffer;
+      _RopeRep* __remainder;
+      rope<_CharT, _Alloc> __remainder_rope;
+
+      if (0 == __n)
+	return;
+
+      __exponent = __n / __exponentiate_threshold;
+      __rest = __n % __exponentiate_threshold;
+      if (0 == __rest)
+	__remainder = 0;
+      else
+	{
+	  __rest_buffer = this->_Data_allocate(_S_rounded_up_size(__rest));
+	  __uninitialized_fill_n_a(__rest_buffer, __rest, __c,
+				   _M_get_allocator());
+	  _S_cond_store_eos(__rest_buffer[__rest]);
+	  __try
+	    { __remainder = _S_new_RopeLeaf(__rest_buffer, __rest,
+					    _M_get_allocator()); }
+	  __catch(...)
+	    {
+	      _RopeRep::__STL_FREE_STRING(__rest_buffer, __rest,
+					  _M_get_allocator());
+	      __throw_exception_again;
+	    }
+	}
+      __remainder_rope._M_tree_ptr = __remainder;
+      if (__exponent != 0)
+	{
+	  _CharT* __base_buffer =
+	    this->_Data_allocate(_S_rounded_up_size(__exponentiate_threshold));
+	  _RopeLeaf* __base_leaf;
+	  rope __base_rope;
+	  __uninitialized_fill_n_a(__base_buffer, __exponentiate_threshold, __c,
+				   _M_get_allocator());
+	  _S_cond_store_eos(__base_buffer[__exponentiate_threshold]);
+	  __try
+	    {
+	      __base_leaf = _S_new_RopeLeaf(__base_buffer,
+					    __exponentiate_threshold,
+					    _M_get_allocator());
+	    }
+	  __catch(...)
+	    {
+	      _RopeRep::__STL_FREE_STRING(__base_buffer,
+					  __exponentiate_threshold,
+					  _M_get_allocator());
+	      __throw_exception_again;
+	    }
+	  __base_rope._M_tree_ptr = __base_leaf;
+	  if (1 == __exponent)
+	    __result = __base_rope;
+	  else
+	    __result = power(__base_rope, __exponent,
+			     _Rope_Concat_fn<_CharT, _Alloc>());
+	    
+	  if (0 != __remainder)
+	    __result += __remainder_rope;
+	}
+      else
+	__result = __remainder_rope;
+	  
+      this->_M_tree_ptr = __result._M_tree_ptr;
+      this->_M_tree_ptr->_M_ref_nonnil();
+    }
+      
+  template<class _CharT, class _Alloc>
+    _CharT
+    rope<_CharT, _Alloc>::_S_empty_c_str[1];
+      
+  template<class _CharT, class _Alloc>
+    const _CharT*
+    rope<_CharT, _Alloc>::
+    c_str() const
+    {
+      if (0 == this->_M_tree_ptr)
+	{
+	  _S_empty_c_str[0] = _S_eos((_CharT*)0);  // Possibly redundant,
+	                                           // but probably fast.
+	  return _S_empty_c_str;
+	}
+      __gthread_mutex_lock (&this->_M_tree_ptr->_M_c_string_lock);
+      __GC_CONST _CharT* __result = this->_M_tree_ptr->_M_c_string;
+      if (0 == __result)
+	{
+	  size_t __s = size();
+	  __result = this->_Data_allocate(__s + 1);
+	  _S_flatten(this->_M_tree_ptr, __result);
+	  __result[__s] = _S_eos((_CharT*)0);
+	  this->_M_tree_ptr->_M_c_string = __result;
+	}
+      __gthread_mutex_unlock (&this->_M_tree_ptr->_M_c_string_lock);
+      return(__result);
+    }
+  
+  template<class _CharT, class _Alloc>
+    const _CharT* rope<_CharT, _Alloc>::
+    replace_with_c_str()
+    {
+      if (0 == this->_M_tree_ptr)
+	{
+	  _S_empty_c_str[0] = _S_eos((_CharT*)0);
+	  return _S_empty_c_str;
+	}
+      __GC_CONST _CharT* __old_c_string = this->_M_tree_ptr->_M_c_string;
+      if (__detail::_S_leaf == this->_M_tree_ptr->_M_tag
+	  && 0 != __old_c_string)
+	return(__old_c_string);
+      size_t __s = size();
+      _CharT* __result = this->_Data_allocate(_S_rounded_up_size(__s));
+      _S_flatten(this->_M_tree_ptr, __result);
+      __result[__s] = _S_eos((_CharT*)0);
+      this->_M_tree_ptr->_M_unref_nonnil();
+      this->_M_tree_ptr = _S_new_RopeLeaf(__result, __s,
+					  this->_M_get_allocator());
+      return(__result);
+    }
+
+  // Algorithm specializations.  More should be added.
+  
+  template<class _Rope_iterator>  // was templated on CharT and Alloc
+    void		          // VC++ workaround
+    _Rope_rotate(_Rope_iterator __first,
+		 _Rope_iterator __middle,
+		 _Rope_iterator __last)
+    {
+      typedef typename _Rope_iterator::value_type _CharT;
+      typedef typename _Rope_iterator::_allocator_type _Alloc;
+      
+      rope<_CharT, _Alloc>& __r(__first.container());
+      rope<_CharT, _Alloc> __prefix = __r.substr(0, __first.index());
+      rope<_CharT, _Alloc> __suffix =
+	__r.substr(__last.index(), __r.size() - __last.index());
+      rope<_CharT, _Alloc> __part1 =
+	__r.substr(__middle.index(), __last.index() - __middle.index());
+      rope<_CharT, _Alloc> __part2 =
+	__r.substr(__first.index(), __middle.index() - __first.index());
+      __r = __prefix;
+      __r += __part1;
+      __r += __part2;
+      __r += __suffix;
+    }
+
+#if !defined(__GNUC__)
+  // Appears to confuse g++
+  inline void
+  rotate(_Rope_iterator<char, __STL_DEFAULT_ALLOCATOR(char)> __first,
+	 _Rope_iterator<char, __STL_DEFAULT_ALLOCATOR(char)> __middle,
+	 _Rope_iterator<char, __STL_DEFAULT_ALLOCATOR(char)> __last)
+  { _Rope_rotate(__first, __middle, __last); }
+#endif
+
+# if 0
+  // Probably not useful for several reasons:
+  // - for SGIs 7.1 compiler and probably some others,
+  //   this forces lots of rope<wchar_t, ...> instantiations, creating a
+  //   code bloat and compile time problem.  (Fixed in 7.2.)
+  // - wchar_t is 4 bytes wide on most UNIX platforms, making it
+  //   unattractive for unicode strings.  Unsigned short may be a better
+  //   character type.
+  inline void
+  rotate(_Rope_iterator<wchar_t, __STL_DEFAULT_ALLOCATOR(char)> __first,
+	 _Rope_iterator<wchar_t, __STL_DEFAULT_ALLOCATOR(char)> __middle,
+	 _Rope_iterator<wchar_t, __STL_DEFAULT_ALLOCATOR(char)> __last)
+  { _Rope_rotate(__first, __middle, __last); }
+# endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
diff --git a/gcc-4.9/libstdc++-v3/include/ext/slist b/gcc-4.9/libstdc++-v3/include/ext/slist
new file mode 100644
index 0000000..5ef18ad
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/slist
@@ -0,0 +1,1082 @@
+// Singly-linked list implementation -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file ext/slist
+ *  This file is a GNU extension to the Standard C++ Library (possibly
+ *  containing extensions from the HP/SGI STL subset). 
+ */
+
+#ifndef _SLIST
+#define _SLIST 1
+
+#include <algorithm>
+#include <bits/allocator.h>
+#include <bits/stl_construct.h>
+#include <bits/stl_uninitialized.h>
+#include <bits/concept_check.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  using std::size_t;
+  using std::ptrdiff_t;
+  using std::_Construct;
+  using std::_Destroy;
+  using std::allocator;
+  using std::__true_type;
+  using std::__false_type;
+
+  struct _Slist_node_base
+  {
+    _Slist_node_base* _M_next;
+  };
+  
+  inline _Slist_node_base*
+  __slist_make_link(_Slist_node_base* __prev_node,
+		    _Slist_node_base* __new_node)
+  {
+    __new_node->_M_next = __prev_node->_M_next;
+    __prev_node->_M_next = __new_node;
+    return __new_node;
+  }
+
+  inline _Slist_node_base*
+  __slist_previous(_Slist_node_base* __head,
+		   const _Slist_node_base* __node)
+  {
+    while (__head && __head->_M_next != __node)
+      __head = __head->_M_next;
+    return __head;
+  }
+
+  inline const _Slist_node_base*
+  __slist_previous(const _Slist_node_base* __head,
+		   const _Slist_node_base* __node)
+  {
+    while (__head && __head->_M_next != __node)
+      __head = __head->_M_next;
+    return __head;
+  }
+
+  inline void
+  __slist_splice_after(_Slist_node_base* __pos,
+		       _Slist_node_base* __before_first,
+		       _Slist_node_base* __before_last)
+  {
+    if (__pos != __before_first && __pos != __before_last)
+      {
+	_Slist_node_base* __first = __before_first->_M_next;
+	_Slist_node_base* __after = __pos->_M_next;
+	__before_first->_M_next = __before_last->_M_next;
+	__pos->_M_next = __first;
+	__before_last->_M_next = __after;
+      }
+  }
+
+  inline void
+  __slist_splice_after(_Slist_node_base* __pos, _Slist_node_base* __head)
+  {
+    _Slist_node_base* __before_last = __slist_previous(__head, 0);
+    if (__before_last != __head)
+      {
+	_Slist_node_base* __after = __pos->_M_next;
+	__pos->_M_next = __head->_M_next;
+	__head->_M_next = 0;
+	__before_last->_M_next = __after;
+      }
+  }
+
+  inline _Slist_node_base*
+  __slist_reverse(_Slist_node_base* __node)
+  {
+    _Slist_node_base* __result = __node;
+    __node = __node->_M_next;
+    __result->_M_next = 0;
+    while(__node)
+      {
+	_Slist_node_base* __next = __node->_M_next;
+	__node->_M_next = __result;
+	__result = __node;
+	__node = __next;
+      }
+    return __result;
+  }
+
+  inline size_t
+  __slist_size(_Slist_node_base* __node)
+  {
+    size_t __result = 0;
+    for (; __node != 0; __node = __node->_M_next)
+      ++__result;
+    return __result;
+  }
+
+  template <class _Tp>
+    struct _Slist_node : public _Slist_node_base
+    {
+      _Tp _M_data;
+    };
+
+  struct _Slist_iterator_base
+  {
+    typedef size_t                    size_type;
+    typedef ptrdiff_t                 difference_type;
+    typedef std::forward_iterator_tag iterator_category;
+
+    _Slist_node_base* _M_node;
+    
+    _Slist_iterator_base(_Slist_node_base* __x)
+    : _M_node(__x) {}
+
+    void
+    _M_incr()
+    { _M_node = _M_node->_M_next; }
+
+    bool
+    operator==(const _Slist_iterator_base& __x) const
+    { return _M_node == __x._M_node; }
+
+    bool
+    operator!=(const _Slist_iterator_base& __x) const
+    { return _M_node != __x._M_node; }
+  };
+
+  template <class _Tp, class _Ref, class _Ptr>
+    struct _Slist_iterator : public _Slist_iterator_base
+    {
+      typedef _Slist_iterator<_Tp, _Tp&, _Tp*>             iterator;
+      typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+      typedef _Slist_iterator<_Tp, _Ref, _Ptr>             _Self;
+
+      typedef _Tp              value_type;
+      typedef _Ptr             pointer;
+      typedef _Ref             reference;
+      typedef _Slist_node<_Tp> _Node;
+
+      explicit
+      _Slist_iterator(_Node* __x)
+      : _Slist_iterator_base(__x) {}
+
+      _Slist_iterator()
+      : _Slist_iterator_base(0) {}
+
+      _Slist_iterator(const iterator& __x)
+      : _Slist_iterator_base(__x._M_node) {}
+
+      reference
+      operator*() const
+      { return ((_Node*) _M_node)->_M_data; }
+
+      pointer
+      operator->() const
+      { return &(operator*()); }
+
+      _Self&
+      operator++()
+      {
+	_M_incr();
+	return *this;
+      }
+
+      _Self
+      operator++(int)
+      {
+	_Self __tmp = *this;
+	_M_incr();
+	return __tmp;
+      }
+    };
+
+  template <class _Tp, class _Alloc>
+    struct _Slist_base
+    : public _Alloc::template rebind<_Slist_node<_Tp> >::other
+    {
+      typedef typename _Alloc::template rebind<_Slist_node<_Tp> >::other
+        _Node_alloc;
+      typedef _Alloc allocator_type;
+
+      allocator_type
+      get_allocator() const
+      { return *static_cast<const _Node_alloc*>(this); }
+
+      _Slist_base(const allocator_type& __a)
+      : _Node_alloc(__a)
+      { this->_M_head._M_next = 0; }
+
+      ~_Slist_base()
+      { _M_erase_after(&this->_M_head, 0); }
+
+    protected:
+      _Slist_node_base _M_head;
+
+      _Slist_node<_Tp>*
+      _M_get_node()
+      { return _Node_alloc::allocate(1); }
+  
+      void
+      _M_put_node(_Slist_node<_Tp>* __p)
+      { _Node_alloc::deallocate(__p, 1); }
+
+    protected:
+      _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)
+      {
+	_Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);
+	_Slist_node_base* __next_next = __next->_M_next;
+	__pos->_M_next = __next_next;
+	get_allocator().destroy(&__next->_M_data);
+	_M_put_node(__next);
+	return __next_next;
+      }
+      _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);
+    };
+
+  template <class _Tp, class _Alloc>
+    _Slist_node_base*
+    _Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first,
+					    _Slist_node_base* __last_node)
+    {
+      _Slist_node<_Tp>* __cur = (_Slist_node<_Tp>*) (__before_first->_M_next);
+      while (__cur != __last_node)
+	{
+	  _Slist_node<_Tp>* __tmp = __cur;
+	  __cur = (_Slist_node<_Tp>*) __cur->_M_next;
+	  get_allocator().destroy(&__tmp->_M_data);
+	  _M_put_node(__tmp);
+	}
+      __before_first->_M_next = __last_node;
+      return __last_node;
+    }
+
+  /**
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+   *  @doctodo
+   */
+  template <class _Tp, class _Alloc = allocator<_Tp> >
+    class slist : private _Slist_base<_Tp,_Alloc>
+    {
+      // concept requirements
+      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
+	
+    private:
+      typedef _Slist_base<_Tp,_Alloc> _Base;
+
+    public:
+      typedef _Tp               value_type;
+      typedef value_type*       pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type&       reference;
+      typedef const value_type& const_reference;
+      typedef size_t            size_type;
+      typedef ptrdiff_t         difference_type;
+      
+      typedef _Slist_iterator<_Tp, _Tp&, _Tp*>             iterator;
+      typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+      
+      typedef typename _Base::allocator_type allocator_type;
+
+      allocator_type
+      get_allocator() const
+      { return _Base::get_allocator(); }
+
+    private:
+      typedef _Slist_node<_Tp>      _Node;
+      typedef _Slist_node_base      _Node_base;
+      typedef _Slist_iterator_base  _Iterator_base;
+      
+      _Node*
+      _M_create_node(const value_type& __x)
+      {
+	_Node* __node = this->_M_get_node();
+	__try
+	  {
+	    get_allocator().construct(&__node->_M_data, __x);
+	    __node->_M_next = 0;
+	  }
+	__catch(...)
+	  {
+	    this->_M_put_node(__node);
+	    __throw_exception_again;
+	  }
+	return __node;
+      }
+
+      _Node*
+      _M_create_node()
+      {
+	_Node* __node = this->_M_get_node();
+	__try
+	  {
+	    get_allocator().construct(&__node->_M_data, value_type());
+	    __node->_M_next = 0;
+	  }
+	__catch(...)
+	  {
+	    this->_M_put_node(__node);
+	    __throw_exception_again;
+	  }
+	return __node;
+      }
+
+    public:
+      explicit
+      slist(const allocator_type& __a = allocator_type())
+      : _Base(__a) {}
+
+      slist(size_type __n, const value_type& __x,
+	    const allocator_type& __a =  allocator_type())
+      : _Base(__a)
+      { _M_insert_after_fill(&this->_M_head, __n, __x); }
+
+      explicit
+      slist(size_type __n)
+      : _Base(allocator_type())
+      { _M_insert_after_fill(&this->_M_head, __n, value_type()); }
+
+      // We don't need any dispatching tricks here, because
+      // _M_insert_after_range already does them.
+      template <class _InputIterator>
+        slist(_InputIterator __first, _InputIterator __last,
+	      const allocator_type& __a =  allocator_type())
+	: _Base(__a)
+        { _M_insert_after_range(&this->_M_head, __first, __last); }
+
+      slist(const slist& __x)
+      : _Base(__x.get_allocator())
+      { _M_insert_after_range(&this->_M_head, __x.begin(), __x.end()); }
+
+      slist&
+      operator= (const slist& __x);
+
+      ~slist() {}
+
+    public:
+      // assign(), a generalized assignment member function.  Two
+      // versions: one that takes a count, and one that takes a range.
+      // The range version is a member template, so we dispatch on whether
+      // or not the type is an integer.
+      
+      void
+      assign(size_type __n, const _Tp& __val)
+      { _M_fill_assign(__n, __val); }
+
+      void
+      _M_fill_assign(size_type __n, const _Tp& __val);
+
+      template <class _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  _M_assign_dispatch(__first, __last, _Integral());
+	}
+
+      template <class _Integer>
+      void
+      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+      { _M_fill_assign((size_type) __n, (_Tp) __val); }
+
+      template <class _InputIterator>
+      void
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+			 __false_type);
+
+    public:
+
+      iterator
+      begin()
+      { return iterator((_Node*)this->_M_head._M_next); }
+
+      const_iterator
+      begin() const
+      { return const_iterator((_Node*)this->_M_head._M_next);}
+
+      iterator
+      end()
+      { return iterator(0); }
+
+      const_iterator
+      end() const
+      { return const_iterator(0); }
+
+      // Experimental new feature: before_begin() returns a
+      // non-dereferenceable iterator that, when incremented, yields
+      // begin().  This iterator may be used as the argument to
+      // insert_after, erase_after, etc.  Note that even for an empty
+      // slist, before_begin() is not the same iterator as end().  It
+      // is always necessary to increment before_begin() at least once to
+      // obtain end().
+      iterator
+      before_begin()
+      { return iterator((_Node*) &this->_M_head); }
+
+      const_iterator
+      before_begin() const
+      { return const_iterator((_Node*) &this->_M_head); }
+
+      size_type
+      size() const
+      { return __slist_size(this->_M_head._M_next); }
+
+      size_type
+      max_size() const
+      { return size_type(-1); }
+
+      bool
+      empty() const
+      { return this->_M_head._M_next == 0; }
+
+      void
+      swap(slist& __x)
+      { std::swap(this->_M_head._M_next, __x._M_head._M_next); }
+
+    public:
+
+      reference
+      front()
+      { return ((_Node*) this->_M_head._M_next)->_M_data; }
+
+      const_reference
+      front() const
+      { return ((_Node*) this->_M_head._M_next)->_M_data; }
+
+      void
+      push_front(const value_type& __x)
+      { __slist_make_link(&this->_M_head, _M_create_node(__x)); }
+
+      void
+      push_front()
+      { __slist_make_link(&this->_M_head, _M_create_node()); }
+
+      void
+      pop_front()
+      {
+	_Node* __node = (_Node*) this->_M_head._M_next;
+	this->_M_head._M_next = __node->_M_next;
+	get_allocator().destroy(&__node->_M_data);
+	this->_M_put_node(__node);
+      }
+
+      iterator
+      previous(const_iterator __pos)
+      { return iterator((_Node*) __slist_previous(&this->_M_head,
+						  __pos._M_node)); }
+
+      const_iterator
+      previous(const_iterator __pos) const
+      { return const_iterator((_Node*) __slist_previous(&this->_M_head,
+							__pos._M_node)); }
+
+    private:
+      _Node*
+      _M_insert_after(_Node_base* __pos, const value_type& __x)
+      { return (_Node*) (__slist_make_link(__pos, _M_create_node(__x))); }
+
+      _Node*
+      _M_insert_after(_Node_base* __pos)
+      { return (_Node*) (__slist_make_link(__pos, _M_create_node())); }
+
+      void
+      _M_insert_after_fill(_Node_base* __pos,
+			   size_type __n, const value_type& __x)
+      {
+	for (size_type __i = 0; __i < __n; ++__i)
+	  __pos = __slist_make_link(__pos, _M_create_node(__x));
+      }
+
+      // Check whether it's an integral type.  If so, it's not an iterator.
+      template <class _InIterator>
+        void
+        _M_insert_after_range(_Node_base* __pos,
+			      _InIterator __first, _InIterator __last)
+        {
+	  typedef typename std::__is_integer<_InIterator>::__type _Integral;
+	  _M_insert_after_range(__pos, __first, __last, _Integral());
+	}
+
+      template <class _Integer>
+        void
+        _M_insert_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
+			      __true_type)
+        { _M_insert_after_fill(__pos, __n, __x); }
+
+      template <class _InIterator>
+        void
+        _M_insert_after_range(_Node_base* __pos,
+			      _InIterator __first, _InIterator __last,
+			      __false_type)
+        {
+	  while (__first != __last)
+	    {
+	      __pos = __slist_make_link(__pos, _M_create_node(*__first));
+	      ++__first;
+	    }
+	}
+
+    public:
+      iterator
+      insert_after(iterator __pos, const value_type& __x)
+      { return iterator(_M_insert_after(__pos._M_node, __x)); }
+
+      iterator
+      insert_after(iterator __pos)
+      { return insert_after(__pos, value_type()); }
+
+      void
+      insert_after(iterator __pos, size_type __n, const value_type& __x)
+      { _M_insert_after_fill(__pos._M_node, __n, __x); }
+
+      // We don't need any dispatching tricks here, because
+      // _M_insert_after_range already does them.
+      template <class _InIterator>
+        void
+        insert_after(iterator __pos, _InIterator __first, _InIterator __last)
+        { _M_insert_after_range(__pos._M_node, __first, __last); }
+
+      iterator
+      insert(iterator __pos, const value_type& __x)
+      { return iterator(_M_insert_after(__slist_previous(&this->_M_head,
+							 __pos._M_node),
+					__x)); }
+
+      iterator
+      insert(iterator __pos)
+      { return iterator(_M_insert_after(__slist_previous(&this->_M_head,
+							 __pos._M_node),
+					value_type())); }
+
+      void
+      insert(iterator __pos, size_type __n, const value_type& __x)
+      { _M_insert_after_fill(__slist_previous(&this->_M_head, __pos._M_node),
+			     __n, __x); }
+
+      // We don't need any dispatching tricks here, because
+      // _M_insert_after_range already does them.
+      template <class _InIterator>
+        void
+        insert(iterator __pos, _InIterator __first, _InIterator __last)
+        { _M_insert_after_range(__slist_previous(&this->_M_head, __pos._M_node),
+				__first, __last); }
+
+    public:
+      iterator
+      erase_after(iterator __pos)
+      { return iterator((_Node*) this->_M_erase_after(__pos._M_node)); }
+
+      iterator
+      erase_after(iterator __before_first, iterator __last)
+      { 
+	return iterator((_Node*) this->_M_erase_after(__before_first._M_node,
+						      __last._M_node));
+      }
+
+      iterator
+      erase(iterator __pos)
+      { 
+	return iterator((_Node*) this->_M_erase_after
+			(__slist_previous(&this->_M_head, __pos._M_node)));
+      }
+
+      iterator
+      erase(iterator __first, iterator __last)
+      { 
+	return iterator((_Node*) this->_M_erase_after
+			(__slist_previous(&this->_M_head, __first._M_node),
+			 __last._M_node));
+      }
+      
+      void
+      resize(size_type new_size, const _Tp& __x);
+
+      void
+      resize(size_type new_size)
+      { resize(new_size, _Tp()); }
+
+      void
+      clear()
+      { this->_M_erase_after(&this->_M_head, 0); }
+
+    public:
+      // Moves the range [__before_first + 1, __before_last + 1) to *this,
+      //  inserting it immediately after __pos.  This is constant time.
+      void
+      splice_after(iterator __pos,
+		   iterator __before_first, iterator __before_last)
+      {
+	if (__before_first != __before_last)
+	  __slist_splice_after(__pos._M_node, __before_first._M_node,
+			       __before_last._M_node);
+      }
+
+      // Moves the element that follows __prev to *this, inserting it
+      // immediately after __pos.  This is constant time.
+      void
+      splice_after(iterator __pos, iterator __prev)
+      { __slist_splice_after(__pos._M_node,
+			     __prev._M_node, __prev._M_node->_M_next); }
+
+      // Removes all of the elements from the list __x to *this, inserting
+      // them immediately after __pos.  __x must not be *this.  Complexity:
+      // linear in __x.size().
+      void
+      splice_after(iterator __pos, slist& __x)
+      { __slist_splice_after(__pos._M_node, &__x._M_head); }
+
+      // Linear in distance(begin(), __pos), and linear in __x.size().
+      void
+      splice(iterator __pos, slist& __x)
+      {
+	if (__x._M_head._M_next)
+	  __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
+			       &__x._M_head,
+			       __slist_previous(&__x._M_head, 0)); }
+
+      // Linear in distance(begin(), __pos), and in distance(__x.begin(), __i).
+      void
+      splice(iterator __pos, slist& __x, iterator __i)
+      { __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
+			     __slist_previous(&__x._M_head, __i._M_node),
+			     __i._M_node); }
+
+      // Linear in distance(begin(), __pos), in distance(__x.begin(), __first),
+      // and in distance(__first, __last).
+      void
+      splice(iterator __pos, slist& __x, iterator __first, iterator __last)
+      {
+	if (__first != __last)
+	  __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
+			       __slist_previous(&__x._M_head, __first._M_node),
+			       __slist_previous(__first._M_node,
+						__last._M_node));
+      }
+
+    public:
+      void
+      reverse()
+      {
+	if (this->_M_head._M_next)
+	  this->_M_head._M_next = __slist_reverse(this->_M_head._M_next);
+      }
+
+      void
+      remove(const _Tp& __val);
+
+      void
+      unique();
+      
+      void
+      merge(slist& __x);
+      
+      void
+      sort();
+
+      template <class _Predicate>
+        void
+        remove_if(_Predicate __pred);
+
+      template <class _BinaryPredicate>
+        void
+        unique(_BinaryPredicate __pred);
+
+      template <class _StrictWeakOrdering>
+        void
+        merge(slist&, _StrictWeakOrdering);
+
+      template <class _StrictWeakOrdering>
+        void
+        sort(_StrictWeakOrdering __comp);
+    };
+
+  template <class _Tp, class _Alloc>
+    slist<_Tp, _Alloc>&
+    slist<_Tp, _Alloc>::operator=(const slist<_Tp, _Alloc>& __x)
+    {
+      if (&__x != this)
+	{
+	  _Node_base* __p1 = &this->_M_head;
+	  _Node* __n1 = (_Node*) this->_M_head._M_next;
+	  const _Node* __n2 = (const _Node*) __x._M_head._M_next;
+	  while (__n1 && __n2)
+	    {
+	      __n1->_M_data = __n2->_M_data;
+	      __p1 = __n1;
+	      __n1 = (_Node*) __n1->_M_next;
+	      __n2 = (const _Node*) __n2->_M_next;
+	    }
+	  if (__n2 == 0)
+	    this->_M_erase_after(__p1, 0);
+	  else
+	    _M_insert_after_range(__p1, const_iterator((_Node*)__n2),
+                                  const_iterator(0));
+	}
+      return *this;
+    }
+
+  template <class _Tp, class _Alloc>
+    void
+    slist<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val)
+    {
+      _Node_base* __prev = &this->_M_head;
+      _Node* __node = (_Node*) this->_M_head._M_next;
+      for (; __node != 0 && __n > 0; --__n)
+	{
+	  __node->_M_data = __val;
+	  __prev = __node;
+	  __node = (_Node*) __node->_M_next;
+	}
+      if (__n > 0)
+	_M_insert_after_fill(__prev, __n, __val);
+      else
+	this->_M_erase_after(__prev, 0);
+    }
+  
+  template <class _Tp, class _Alloc>
+    template <class _InputIterator>
+      void
+      slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIterator __first,
+					     _InputIterator __last,
+					     __false_type)
+      {
+	_Node_base* __prev = &this->_M_head;
+	_Node* __node = (_Node*) this->_M_head._M_next;
+	while (__node != 0 && __first != __last)
+	  {
+	    __node->_M_data = *__first;
+	    __prev = __node;
+	    __node = (_Node*) __node->_M_next;
+	    ++__first;
+	  }
+	if (__first != __last)
+	  _M_insert_after_range(__prev, __first, __last);
+	else
+	  this->_M_erase_after(__prev, 0);
+      }
+  
+  template <class _Tp, class _Alloc>
+    inline bool
+    operator==(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
+    {
+      typedef typename slist<_Tp,_Alloc>::const_iterator const_iterator;
+      const_iterator __end1 = _SL1.end();
+      const_iterator __end2 = _SL2.end();
+      
+      const_iterator __i1 = _SL1.begin();
+      const_iterator __i2 = _SL2.begin();
+      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
+	{
+	  ++__i1;
+	  ++__i2;
+	}
+      return __i1 == __end1 && __i2 == __end2;
+    }
+
+
+  template <class _Tp, class _Alloc>
+    inline bool
+    operator<(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
+    { return std::lexicographical_compare(_SL1.begin(), _SL1.end(),
+					  _SL2.begin(), _SL2.end()); }
+
+  template <class _Tp, class _Alloc>
+    inline bool
+    operator!=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
+    { return !(_SL1 == _SL2); }
+
+  template <class _Tp, class _Alloc>
+    inline bool
+    operator>(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
+    { return _SL2 < _SL1; }
+
+  template <class _Tp, class _Alloc>
+    inline bool
+    operator<=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
+    { return !(_SL2 < _SL1); }
+
+  template <class _Tp, class _Alloc>
+    inline bool
+    operator>=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
+    { return !(_SL1 < _SL2); }
+
+  template <class _Tp, class _Alloc>
+    inline void
+    swap(slist<_Tp, _Alloc>& __x, slist<_Tp, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template <class _Tp, class _Alloc>
+    void
+    slist<_Tp, _Alloc>::resize(size_type __len, const _Tp& __x)
+    {
+      _Node_base* __cur = &this->_M_head;
+      while (__cur->_M_next != 0 && __len > 0)
+	{
+	  --__len;
+	  __cur = __cur->_M_next;
+	}
+      if (__cur->_M_next)
+	this->_M_erase_after(__cur, 0);
+      else
+	_M_insert_after_fill(__cur, __len, __x);
+    }
+
+  template <class _Tp, class _Alloc>
+    void
+    slist<_Tp, _Alloc>::remove(const _Tp& __val)
+    { 
+      _Node_base* __cur = &this->_M_head;
+      while (__cur && __cur->_M_next)
+	{
+	  if (((_Node*) __cur->_M_next)->_M_data == __val)
+	    this->_M_erase_after(__cur);
+	  else
+	    __cur = __cur->_M_next;
+	}
+    }
+
+  template <class _Tp, class _Alloc>
+    void
+    slist<_Tp, _Alloc>::unique()
+    {
+      _Node_base* __cur = this->_M_head._M_next;
+      if (__cur)
+	{
+	  while (__cur->_M_next)
+	    {
+	      if (((_Node*)__cur)->_M_data
+		  == ((_Node*)(__cur->_M_next))->_M_data)
+		this->_M_erase_after(__cur);
+	      else
+		__cur = __cur->_M_next;
+	    }
+	}
+    }
+
+  template <class _Tp, class _Alloc>
+    void
+    slist<_Tp, _Alloc>::merge(slist<_Tp, _Alloc>& __x)
+    {
+      _Node_base* __n1 = &this->_M_head;
+      while (__n1->_M_next && __x._M_head._M_next)
+	{
+	  if (((_Node*) __x._M_head._M_next)->_M_data
+	      < ((_Node*) __n1->_M_next)->_M_data)
+	    __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
+	  __n1 = __n1->_M_next;
+	}
+      if (__x._M_head._M_next)
+	{
+	  __n1->_M_next = __x._M_head._M_next;
+	  __x._M_head._M_next = 0;
+	}
+    }
+
+  template <class _Tp, class _Alloc>
+    void
+    slist<_Tp, _Alloc>::sort()
+    {
+      if (this->_M_head._M_next && this->_M_head._M_next->_M_next)
+	{
+	  slist __carry;
+	  slist __counter[64];
+	  int __fill = 0;
+	  while (!empty())
+	    {
+	      __slist_splice_after(&__carry._M_head,
+				   &this->_M_head, this->_M_head._M_next);
+	      int __i = 0;
+	      while (__i < __fill && !__counter[__i].empty())
+		{
+		  __counter[__i].merge(__carry);
+		  __carry.swap(__counter[__i]);
+		  ++__i;
+		}
+	      __carry.swap(__counter[__i]);
+	      if (__i == __fill)
+		++__fill;
+	    }
+	  
+	  for (int __i = 1; __i < __fill; ++__i)
+	    __counter[__i].merge(__counter[__i-1]);
+	  this->swap(__counter[__fill-1]);
+	}
+    }
+
+  template <class _Tp, class _Alloc>
+    template <class _Predicate>
+      void slist<_Tp, _Alloc>::remove_if(_Predicate __pred)
+      {
+	_Node_base* __cur = &this->_M_head;
+	while (__cur->_M_next)
+	  {
+	    if (__pred(((_Node*) __cur->_M_next)->_M_data))
+	      this->_M_erase_after(__cur);
+	    else
+	      __cur = __cur->_M_next;
+	  }
+      }
+
+  template <class _Tp, class _Alloc>
+    template <class _BinaryPredicate>
+      void
+      slist<_Tp, _Alloc>::unique(_BinaryPredicate __pred)
+      {
+	_Node* __cur = (_Node*) this->_M_head._M_next;
+	if (__cur)
+	  {
+	    while (__cur->_M_next)
+	      {
+		if (__pred(((_Node*)__cur)->_M_data,
+			   ((_Node*)(__cur->_M_next))->_M_data))
+		  this->_M_erase_after(__cur);
+		else
+		  __cur = (_Node*) __cur->_M_next;
+	      }
+	  }
+      }
+
+  template <class _Tp, class _Alloc>
+    template <class _StrictWeakOrdering>
+      void
+      slist<_Tp, _Alloc>::merge(slist<_Tp, _Alloc>& __x,
+			       _StrictWeakOrdering __comp)
+      {
+	_Node_base* __n1 = &this->_M_head;
+	while (__n1->_M_next && __x._M_head._M_next)
+	  {
+	    if (__comp(((_Node*) __x._M_head._M_next)->_M_data,
+		       ((_Node*) __n1->_M_next)->_M_data))
+	      __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
+	    __n1 = __n1->_M_next;
+	  }
+	if (__x._M_head._M_next)
+	  {
+	    __n1->_M_next = __x._M_head._M_next;
+	    __x._M_head._M_next = 0;
+	  }
+      }
+
+  template <class _Tp, class _Alloc>
+    template <class _StrictWeakOrdering>
+      void
+      slist<_Tp, _Alloc>::sort(_StrictWeakOrdering __comp)
+      {
+	if (this->_M_head._M_next && this->_M_head._M_next->_M_next)
+	  {
+	    slist __carry;
+	    slist __counter[64];
+	    int __fill = 0;
+	    while (!empty())
+	      {
+		__slist_splice_after(&__carry._M_head,
+				     &this->_M_head, this->_M_head._M_next);
+		int __i = 0;
+		while (__i < __fill && !__counter[__i].empty())
+		  {
+		    __counter[__i].merge(__carry, __comp);
+		    __carry.swap(__counter[__i]);
+		    ++__i;
+		  }
+		__carry.swap(__counter[__i]);
+		if (__i == __fill)
+		  ++__fill;
+	      }
+
+	    for (int __i = 1; __i < __fill; ++__i)
+	      __counter[__i].merge(__counter[__i-1], __comp);
+	    this->swap(__counter[__fill-1]);
+	  }
+      }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Specialization of insert_iterator so that insertions will be constant
+  // time rather than linear time.
+  template <class _Tp, class _Alloc>
+    class insert_iterator<__gnu_cxx::slist<_Tp, _Alloc> >
+    {
+    protected:
+      typedef __gnu_cxx::slist<_Tp, _Alloc> _Container;
+      _Container* container;
+      typename _Container::iterator iter;
+
+    public:
+      typedef _Container          container_type;
+      typedef output_iterator_tag iterator_category;
+      typedef void                value_type;
+      typedef void                difference_type;
+      typedef void                pointer;
+      typedef void                reference;
+
+      insert_iterator(_Container& __x, typename _Container::iterator __i)
+      : container(&__x)
+      {
+	if (__i == __x.begin())
+	  iter = __x.before_begin();
+	else
+	  iter = __x.previous(__i);
+      }
+
+      insert_iterator<_Container>&
+      operator=(const typename _Container::value_type& __value)
+      {
+	iter = container->insert_after(iter, __value);
+	return *this;
+      }
+
+      insert_iterator<_Container>&
+      operator*()
+      { return *this; }
+
+      insert_iterator<_Container>&
+      operator++()
+      { return *this; }
+
+      insert_iterator<_Container>&
+      operator++(int)
+      { return *this; }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/sso_string_base.h b/gcc-4.9/libstdc++-v3/include/ext/sso_string_base.h
new file mode 100644
index 0000000..80c88ae
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/sso_string_base.h
@@ -0,0 +1,576 @@
+// Short-string-optimized versatile string base -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/sso_string_base.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/vstring.h}
+ */
+
+#ifndef _SSO_STRING_BASE_H
+#define _SSO_STRING_BASE_H 1
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class __sso_string_base
+    : protected __vstring_utility<_CharT, _Traits, _Alloc>
+    {
+    public:
+      typedef _Traits					    traits_type;
+      typedef typename _Traits::char_type		    value_type;
+
+      typedef __vstring_utility<_CharT, _Traits, _Alloc>    _Util_Base;
+      typedef typename _Util_Base::_CharT_alloc_type        _CharT_alloc_type;
+      typedef typename _CharT_alloc_type::size_type	    size_type;
+      
+    private:
+      // Data Members:
+      typename _Util_Base::template _Alloc_hider<_CharT_alloc_type>
+                                                            _M_dataplus;
+      size_type                                             _M_string_length;
+
+      enum { _S_local_capacity = 15 };
+      
+      union
+      {
+	_CharT           _M_local_data[_S_local_capacity + 1];
+	size_type        _M_allocated_capacity;
+      };
+
+      void
+      _M_data(_CharT* __p)
+      { _M_dataplus._M_p = __p; }
+
+      void
+      _M_length(size_type __length)
+      { _M_string_length = __length; }
+
+      void
+      _M_capacity(size_type __capacity)
+      { _M_allocated_capacity = __capacity; }
+
+      bool
+      _M_is_local() const
+      { return _M_data() == _M_local_data; }
+
+      // Create & Destroy
+      _CharT*
+      _M_create(size_type&, size_type);
+      
+      void
+      _M_dispose()
+      {
+	if (!_M_is_local())
+	  _M_destroy(_M_allocated_capacity);
+      }
+
+      void
+      _M_destroy(size_type __size) throw()
+      { _M_get_allocator().deallocate(_M_data(), __size + 1); }
+
+      // _M_construct_aux is used to implement the 21.3.1 para 15 which
+      // requires special behaviour if _InIterator is an integral type
+      template<typename _InIterator>
+        void
+        _M_construct_aux(_InIterator __beg, _InIterator __end, 
+			 std::__false_type)
+	{
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          _M_construct(__beg, __end, _Tag());
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 438. Ambiguity in the "do the right thing" clause
+      template<typename _Integer>
+        void
+        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
+	{ _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
+
+      void
+      _M_construct_aux_2(size_type __req, _CharT __c)
+      { _M_construct(__req, __c); }
+
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end)
+	{
+	  typedef typename std::__is_integer<_InIterator>::__type _Integral;
+	  _M_construct_aux(__beg, __end, _Integral());
+        }
+
+      // For Input Iterators, used in istreambuf_iterators, etc.
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end,
+		     std::input_iterator_tag);
+      
+      // For forward_iterators up to random_access_iterators, used for
+      // string::iterator, _CharT*, etc.
+      template<typename _FwdIterator>
+        void
+        _M_construct(_FwdIterator __beg, _FwdIterator __end,
+		     std::forward_iterator_tag);
+
+      void
+      _M_construct(size_type __req, _CharT __c);
+
+    public:
+      size_type
+      _M_max_size() const
+      { return (_M_get_allocator().max_size() - 1) / 2; }
+
+      _CharT*
+      _M_data() const
+      { return _M_dataplus._M_p; }
+
+      size_type
+      _M_length() const
+      { return _M_string_length; }
+
+      size_type
+      _M_capacity() const
+      {
+	return _M_is_local() ? size_type(_S_local_capacity)
+	                     : _M_allocated_capacity; 
+      }
+
+      bool
+      _M_is_shared() const
+      { return false; }
+
+      void
+      _M_set_leaked() { }
+
+      void
+      _M_leak() { }
+
+      void
+      _M_set_length(size_type __n)
+      {
+	_M_length(__n);
+	traits_type::assign(_M_data()[__n], _CharT());
+      }
+
+      __sso_string_base()
+      : _M_dataplus(_M_local_data)
+      { _M_set_length(0); }
+
+      __sso_string_base(const _Alloc& __a);
+
+      __sso_string_base(const __sso_string_base& __rcs);
+
+#if __cplusplus >= 201103L
+      __sso_string_base(__sso_string_base&& __rcs);
+#endif
+
+      __sso_string_base(size_type __n, _CharT __c, const _Alloc& __a);
+
+      template<typename _InputIterator>
+        __sso_string_base(_InputIterator __beg, _InputIterator __end,
+			  const _Alloc& __a);
+
+      ~__sso_string_base()
+      { _M_dispose(); }
+
+      _CharT_alloc_type&
+      _M_get_allocator()
+      { return _M_dataplus; }
+
+      const _CharT_alloc_type&
+      _M_get_allocator() const
+      { return _M_dataplus; }
+
+      void
+      _M_swap(__sso_string_base& __rcs);
+
+      void
+      _M_assign(const __sso_string_base& __rcs);
+
+      void
+      _M_reserve(size_type __res);
+
+      void
+      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+		size_type __len2);
+
+      void
+      _M_erase(size_type __pos, size_type __n);
+
+      void
+      _M_clear()
+      { _M_set_length(0); }
+
+      bool
+      _M_compare(const __sso_string_base&) const
+      { return false; }
+    };
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    _M_swap(__sso_string_base& __rcs)
+    {
+      if (this == &__rcs)
+	return;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 431. Swapping containers with unequal allocators.
+      std::__alloc_swap<_CharT_alloc_type>::_S_do_it(_M_get_allocator(),
+						     __rcs._M_get_allocator());
+
+      if (_M_is_local())
+	if (__rcs._M_is_local())
+	  {
+	    if (_M_length() && __rcs._M_length())
+	      {
+		_CharT __tmp_data[_S_local_capacity + 1];
+		traits_type::copy(__tmp_data, __rcs._M_local_data,
+				  _S_local_capacity + 1);
+		traits_type::copy(__rcs._M_local_data, _M_local_data,
+				  _S_local_capacity + 1);
+		traits_type::copy(_M_local_data, __tmp_data,
+				  _S_local_capacity + 1);
+	      }
+	    else if (__rcs._M_length())
+	      {
+		traits_type::copy(_M_local_data, __rcs._M_local_data,
+				  _S_local_capacity + 1);
+		_M_length(__rcs._M_length());
+		__rcs._M_set_length(0);
+		return;
+	      }
+	    else if (_M_length())
+	      {
+		traits_type::copy(__rcs._M_local_data, _M_local_data,
+				  _S_local_capacity + 1);
+		__rcs._M_length(_M_length());
+		_M_set_length(0);
+		return;
+	      }
+	  }
+	else
+	  {
+	    const size_type __tmp_capacity = __rcs._M_allocated_capacity;
+	    traits_type::copy(__rcs._M_local_data, _M_local_data,
+			      _S_local_capacity + 1);
+	    _M_data(__rcs._M_data());
+	    __rcs._M_data(__rcs._M_local_data);
+	    _M_capacity(__tmp_capacity);
+	  }
+      else
+	{
+	  const size_type __tmp_capacity = _M_allocated_capacity;
+	  if (__rcs._M_is_local())
+	    {
+	      traits_type::copy(_M_local_data, __rcs._M_local_data,
+				_S_local_capacity + 1);
+	      __rcs._M_data(_M_data());
+	      _M_data(_M_local_data);
+	    }
+	  else
+	    {
+	      _CharT* __tmp_ptr = _M_data();
+	      _M_data(__rcs._M_data());
+	      __rcs._M_data(__tmp_ptr);
+	      _M_capacity(__rcs._M_allocated_capacity);
+	    }
+	  __rcs._M_capacity(__tmp_capacity);
+	}
+
+      const size_type __tmp_length = _M_length();
+      _M_length(__rcs._M_length());
+      __rcs._M_length(__tmp_length);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    _M_create(size_type& __capacity, size_type __old_capacity)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 83.  String::npos vs. string::max_size()
+      if (__capacity > _M_max_size())
+	std::__throw_length_error(__N("__sso_string_base::_M_create"));
+
+      // The below implements an exponential growth policy, necessary to
+      // meet amortized linear time requirements of the library: see
+      // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+	{
+	  __capacity = 2 * __old_capacity;
+	  // Never allocate a string bigger than max_size.
+	  if (__capacity > _M_max_size())
+	    __capacity = _M_max_size();
+	}
+
+      // NB: Need an array of char_type[__capacity], plus a terminating
+      // null char_type() element.
+      return _M_get_allocator().allocate(__capacity + 1);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    __sso_string_base(const _Alloc& __a)
+    : _M_dataplus(__a, _M_local_data)
+    { _M_set_length(0); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    __sso_string_base(const __sso_string_base& __rcs)
+    : _M_dataplus(__rcs._M_get_allocator(), _M_local_data)
+    { _M_construct(__rcs._M_data(), __rcs._M_data() + __rcs._M_length()); }
+
+#if __cplusplus >= 201103L
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    __sso_string_base(__sso_string_base&& __rcs)
+    : _M_dataplus(__rcs._M_get_allocator(), _M_local_data)
+    {
+      if (__rcs._M_is_local())
+	{
+	  if (__rcs._M_length())
+	    traits_type::copy(_M_local_data, __rcs._M_local_data,
+			      _S_local_capacity + 1);
+	}
+      else
+	{
+	  _M_data(__rcs._M_data());
+	  _M_capacity(__rcs._M_allocated_capacity);
+	}
+
+      _M_set_length(__rcs._M_length());
+      __rcs._M_data(__rcs._M_local_data);
+      __rcs._M_set_length(0);
+    }
+#endif
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    __sso_string_base(size_type __n, _CharT __c, const _Alloc& __a)
+    : _M_dataplus(__a, _M_local_data)
+    { _M_construct(__n, __c); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    __sso_string_base(_InputIterator __beg, _InputIterator __end,
+		      const _Alloc& __a)
+    : _M_dataplus(__a, _M_local_data)
+    { _M_construct(__beg, __end); }
+
+  // NB: This is the special case for Input Iterators, used in
+  // istreambuf_iterators, etc.
+  // Input Iterators have a cost structure very different from
+  // pointers, calling for a different coding style.
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      __sso_string_base<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+		   std::input_iterator_tag)
+      {
+	size_type __len = 0;
+	size_type __capacity = size_type(_S_local_capacity);
+
+	while (__beg != __end && __len < __capacity)
+	  {
+	    _M_data()[__len++] = *__beg;
+	    ++__beg;
+	  }
+	
+	__try
+	  {
+	    while (__beg != __end)
+	      {
+		if (__len == __capacity)
+		  {
+		    // Allocate more space.
+		    __capacity = __len + 1;
+		    _CharT* __another = _M_create(__capacity, __len);
+		    this->_S_copy(__another, _M_data(), __len);
+		    _M_dispose();
+		    _M_data(__another);
+		    _M_capacity(__capacity);
+		  }
+		_M_data()[__len++] = *__beg;
+		++__beg;
+	      }
+	  }
+	__catch(...)
+	  {
+	    _M_dispose();
+	    __throw_exception_again;
+	  }
+
+	_M_set_length(__len);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      __sso_string_base<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+		   std::forward_iterator_tag)
+      {
+	// NB: Not required, but considered best practice.
+	if (__is_null_pointer(__beg) && __beg != __end)
+	  std::__throw_logic_error(__N("__sso_string_base::"
+				       "_M_construct null not valid"));
+
+	size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
+
+	if (__dnew > size_type(_S_local_capacity))
+	  {
+	    _M_data(_M_create(__dnew, size_type(0)));
+	    _M_capacity(__dnew);
+	  }
+
+	// Check for out_of_range and length_error exceptions.
+	__try
+	  { this->_S_copy_chars(_M_data(), __beg, __end); }
+	__catch(...)
+	  {
+	    _M_dispose();
+	    __throw_exception_again;
+	  }
+
+	_M_set_length(__dnew);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    _M_construct(size_type __n, _CharT __c)
+    {
+      if (__n > size_type(_S_local_capacity))
+	{
+	  _M_data(_M_create(__n, size_type(0)));
+	  _M_capacity(__n);
+	}
+
+      if (__n)
+	this->_S_assign(_M_data(), __n, __c);
+
+      _M_set_length(__n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    _M_assign(const __sso_string_base& __rcs)
+    {
+      if (this != &__rcs)
+	{
+	  const size_type __rsize = __rcs._M_length();
+	  const size_type __capacity = _M_capacity();
+
+	  if (__rsize > __capacity)
+	    {
+	      size_type __new_capacity = __rsize;
+	      _CharT* __tmp = _M_create(__new_capacity, __capacity);
+	      _M_dispose();
+	      _M_data(__tmp);
+	      _M_capacity(__new_capacity);
+	    }
+
+	  if (__rsize)
+	    this->_S_copy(_M_data(), __rcs._M_data(), __rsize);
+
+	  _M_set_length(__rsize);
+	}
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    _M_reserve(size_type __res)
+    {
+      // Make sure we don't shrink below the current size.
+      if (__res < _M_length())
+	__res = _M_length();
+
+      const size_type __capacity = _M_capacity();
+      if (__res != __capacity)
+	{
+	  if (__res > __capacity
+	      || __res > size_type(_S_local_capacity))
+	    {
+	      _CharT* __tmp = _M_create(__res, __capacity);
+	      this->_S_copy(__tmp, _M_data(), _M_length() + 1);
+	      _M_dispose();
+	      _M_data(__tmp);
+	      _M_capacity(__res);
+	    }
+	  else if (!_M_is_local())
+	    {
+	      this->_S_copy(_M_local_data, _M_data(), _M_length() + 1);
+	      _M_destroy(__capacity);
+	      _M_data(_M_local_data);
+	    }
+	}
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+	      size_type __len2)
+    {
+      const size_type __how_much = _M_length() - __pos - __len1;
+      
+      size_type __new_capacity = _M_length() + __len2 - __len1;
+      _CharT* __r = _M_create(__new_capacity, _M_capacity());
+
+      if (__pos)
+	this->_S_copy(__r, _M_data(), __pos);
+      if (__s && __len2)
+	this->_S_copy(__r + __pos, __s, __len2);
+      if (__how_much)
+	this->_S_copy(__r + __pos + __len2,
+		      _M_data() + __pos + __len1, __how_much);
+      
+      _M_dispose();
+      _M_data(__r);
+      _M_capacity(__new_capacity);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    __sso_string_base<_CharT, _Traits, _Alloc>::
+    _M_erase(size_type __pos, size_type __n)
+    {
+      const size_type __how_much = _M_length() - __pos - __n;
+
+      if (__how_much && __n)
+	this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
+
+      _M_set_length(_M_length() - __n);
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _SSO_STRING_BASE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/stdio_filebuf.h b/gcc-4.9/libstdc++-v3/include/ext/stdio_filebuf.h
new file mode 100644
index 0000000..2874163
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/stdio_filebuf.h
@@ -0,0 +1,162 @@
+// File descriptor layer for filebuf -*- C++ -*-
+
+// Copyright (C) 2002-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/stdio_filebuf.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _STDIO_FILEBUF_H
+#define _STDIO_FILEBUF_H 1
+
+#pragma GCC system_header
+
+#include <fstream>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief Provides a layer of compatibility for C/POSIX.
+   *  @ingroup io
+   *
+   *  This GNU extension provides extensions for working with standard C
+   *  FILE*'s and POSIX file descriptors.  It must be instantiated by the
+   *  user with the type of character used in the file stream, e.g.,
+   *  stdio_filebuf<char>.
+  */
+  template<typename _CharT, typename _Traits = std::char_traits<_CharT> >
+    class stdio_filebuf : public std::basic_filebuf<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT				        char_type;
+      typedef _Traits				        traits_type;
+      typedef typename traits_type::int_type		int_type;
+      typedef typename traits_type::pos_type		pos_type;
+      typedef typename traits_type::off_type		off_type;
+      typedef std::size_t                               size_t;
+
+    public:
+      /**
+       * deferred initialization
+      */
+      stdio_filebuf() : std::basic_filebuf<_CharT, _Traits>() {}
+
+      /**
+       *  @param  __fd  An open file descriptor.
+       *  @param  __mode  Same meaning as in a standard filebuf.
+       *  @param  __size Optimal or preferred size of internal buffer,
+       *                 in chars.
+       *
+       *  This constructor associates a file stream buffer with an open
+       *  POSIX file descriptor. The file descriptor will be automatically
+       *  closed when the stdio_filebuf is closed/destroyed.
+      */
+      stdio_filebuf(int __fd, std::ios_base::openmode __mode,
+		    size_t __size = static_cast<size_t>(BUFSIZ));
+
+      /**
+       *  @param  __f  An open @c FILE*.
+       *  @param  __mode  Same meaning as in a standard filebuf.
+       *  @param  __size Optimal or preferred size of internal buffer,
+       *                 in chars.  Defaults to system's @c BUFSIZ.
+       *
+       *  This constructor associates a file stream buffer with an open
+       *  C @c FILE*.  The @c FILE* will not be automatically closed when the
+       *  stdio_filebuf is closed/destroyed.
+      */
+      stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode,
+		    size_t __size = static_cast<size_t>(BUFSIZ));
+
+      /**
+       *  Closes the external data stream if the file descriptor constructor
+       *  was used.
+      */
+      virtual
+      ~stdio_filebuf();
+
+      /**
+       *  @return  The underlying file descriptor.
+       *
+       *  Once associated with an external data stream, this function can be
+       *  used to access the underlying POSIX file descriptor.  Note that
+       *  there is no way for the library to track what you do with the
+       *  descriptor, so be careful.
+      */
+      int
+      fd() { return this->_M_file.fd(); }
+
+      /**
+       *  @return  The underlying FILE*.
+       *
+       *  This function can be used to access the underlying "C" file pointer.
+       *  Note that there is no way for the library to track what you do
+       *  with the file, so be careful.
+       */
+      std::__c_file*
+      file() { return this->_M_file.file(); }
+    };
+
+  template<typename _CharT, typename _Traits>
+    stdio_filebuf<_CharT, _Traits>::~stdio_filebuf()
+    { }
+
+  template<typename _CharT, typename _Traits>
+    stdio_filebuf<_CharT, _Traits>::
+    stdio_filebuf(int __fd, std::ios_base::openmode __mode, size_t __size)
+    {
+      this->_M_file.sys_open(__fd, __mode);
+      if (this->is_open())
+	{
+	  this->_M_mode = __mode;
+	  this->_M_buf_size = __size;
+	  this->_M_allocate_internal_buffer();
+	  this->_M_reading = false;
+	  this->_M_writing = false;
+	  this->_M_set_buffer(-1);
+	}
+    }
+
+  template<typename _CharT, typename _Traits>
+    stdio_filebuf<_CharT, _Traits>::
+    stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode,
+		  size_t __size)
+    {
+      this->_M_file.sys_open(__f, __mode);
+      if (this->is_open())
+	{
+	  this->_M_mode = __mode;
+	  this->_M_buf_size = __size;
+	  this->_M_allocate_internal_buffer();
+	  this->_M_reading = false;
+	  this->_M_writing = false;
+	  this->_M_set_buffer(-1);
+	}
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/stdio_sync_filebuf.h b/gcc-4.9/libstdc++-v3/include/ext/stdio_sync_filebuf.h
new file mode 100644
index 0000000..5ca16eb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/stdio_sync_filebuf.h
@@ -0,0 +1,289 @@
+// Iostreams wrapper for stdio FILE* -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/stdio_sync_filebuf.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _STDIO_SYNC_FILEBUF_H
+#define _STDIO_SYNC_FILEBUF_H 1
+
+#pragma GCC system_header
+
+#include <streambuf>
+#include <unistd.h>
+#include <cstdio>
+#include <bits/c++io.h>  // For __c_file
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+#include <cwchar>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief Provides a layer of compatibility for C.
+   *  @ingroup io
+   *
+   *  This GNU extension provides extensions for working with standard
+   *  C FILE*'s.  It must be instantiated by the user with the type of
+   *  character used in the file stream, e.g., stdio_filebuf<char>.
+  */
+  template<typename _CharT, typename _Traits = std::char_traits<_CharT> >
+    class stdio_sync_filebuf : public std::basic_streambuf<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT					char_type;
+      typedef _Traits					traits_type;
+      typedef typename traits_type::int_type		int_type;
+      typedef typename traits_type::pos_type		pos_type;
+      typedef typename traits_type::off_type		off_type;
+
+    private:
+      // Underlying stdio FILE
+      std::__c_file* const _M_file;
+
+      // Last character gotten. This is used when pbackfail is
+      // called from basic_streambuf::sungetc()
+      int_type _M_unget_buf;
+
+    public:
+      explicit
+      stdio_sync_filebuf(std::__c_file* __f)
+      : _M_file(__f), _M_unget_buf(traits_type::eof())
+      { }
+
+      /**
+       *  @return  The underlying FILE*.
+       *
+       *  This function can be used to access the underlying C file pointer.
+       *  Note that there is no way for the library to track what you do
+       *  with the file, so be careful.
+       */
+      std::__c_file* const
+      file() { return this->_M_file; }
+
+    protected:
+      int_type
+      syncgetc();
+
+      int_type
+      syncungetc(int_type __c);
+
+      int_type
+      syncputc(int_type __c);
+
+      virtual int_type
+      underflow()
+      {
+	int_type __c = this->syncgetc();
+	return this->syncungetc(__c);
+      }
+
+      virtual int_type
+      uflow()
+      {
+	// Store the gotten character in case we need to unget it.
+	_M_unget_buf = this->syncgetc();
+	return _M_unget_buf;
+      }
+
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof())
+      {
+	int_type __ret;
+	const int_type __eof = traits_type::eof();
+
+	// Check if the unget or putback was requested
+	if (traits_type::eq_int_type(__c, __eof)) // unget
+	  {
+	    if (!traits_type::eq_int_type(_M_unget_buf, __eof))
+	      __ret = this->syncungetc(_M_unget_buf);
+	    else // buffer invalid, fail.
+	      __ret = __eof;
+	  }
+	else // putback
+	  __ret = this->syncungetc(__c);
+
+	// The buffered character is no longer valid, discard it.
+	_M_unget_buf = __eof;
+	return __ret;
+      }
+
+      virtual std::streamsize
+      xsgetn(char_type* __s, std::streamsize __n);
+
+      virtual int_type
+      overflow(int_type __c = traits_type::eof())
+      {
+	int_type __ret;
+	if (traits_type::eq_int_type(__c, traits_type::eof()))
+	  {
+	    if (std::fflush(_M_file))
+	      __ret = traits_type::eof();
+	    else
+	      __ret = traits_type::not_eof(__c);
+	  }
+	else
+	  __ret = this->syncputc(__c);
+	return __ret;
+      }
+
+      virtual std::streamsize
+      xsputn(const char_type* __s, std::streamsize __n);
+
+      virtual int
+      sync()
+      { return std::fflush(_M_file); }
+
+      virtual std::streampos
+      seekoff(std::streamoff __off, std::ios_base::seekdir __dir,
+	      std::ios_base::openmode = std::ios_base::in | std::ios_base::out)
+      {
+	std::streampos __ret(std::streamoff(-1));
+	int __whence;
+	if (__dir == std::ios_base::beg)
+	  __whence = SEEK_SET;
+	else if (__dir == std::ios_base::cur)
+	  __whence = SEEK_CUR;
+	else
+	  __whence = SEEK_END;
+#ifdef _GLIBCXX_USE_LFS
+	if (!fseeko64(_M_file, __off, __whence))
+	  __ret = std::streampos(ftello64(_M_file));
+#else
+	if (!fseek(_M_file, __off, __whence))
+	  __ret = std::streampos(std::ftell(_M_file));
+#endif
+	return __ret;
+      }
+
+      virtual std::streampos
+      seekpos(std::streampos __pos,
+	      std::ios_base::openmode __mode =
+	      std::ios_base::in | std::ios_base::out)
+      { return seekoff(std::streamoff(__pos), std::ios_base::beg, __mode); }
+    };
+
+  template<>
+    inline stdio_sync_filebuf<char>::int_type
+    stdio_sync_filebuf<char>::syncgetc()
+    { return std::getc(_M_file); }
+
+  template<>
+    inline stdio_sync_filebuf<char>::int_type
+    stdio_sync_filebuf<char>::syncungetc(int_type __c)
+    { return std::ungetc(__c, _M_file); }
+
+  template<>
+    inline stdio_sync_filebuf<char>::int_type
+    stdio_sync_filebuf<char>::syncputc(int_type __c)
+    { return std::putc(__c, _M_file); }
+
+  template<>
+    inline std::streamsize
+    stdio_sync_filebuf<char>::xsgetn(char* __s, std::streamsize __n)
+    {
+      std::streamsize __ret = std::fread(__s, 1, __n, _M_file);
+      if (__ret > 0)
+	_M_unget_buf = traits_type::to_int_type(__s[__ret - 1]);
+      else
+	_M_unget_buf = traits_type::eof();
+      return __ret;
+    }
+
+  template<>
+    inline std::streamsize
+    stdio_sync_filebuf<char>::xsputn(const char* __s, std::streamsize __n)
+    { return std::fwrite(__s, 1, __n, _M_file); }
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    inline stdio_sync_filebuf<wchar_t>::int_type
+    stdio_sync_filebuf<wchar_t>::syncgetc()
+    { return std::getwc(_M_file); }
+
+  template<>
+    inline stdio_sync_filebuf<wchar_t>::int_type
+    stdio_sync_filebuf<wchar_t>::syncungetc(int_type __c)
+    { return std::ungetwc(__c, _M_file); }
+
+  template<>
+    inline stdio_sync_filebuf<wchar_t>::int_type
+    stdio_sync_filebuf<wchar_t>::syncputc(int_type __c)
+    { return std::putwc(__c, _M_file); }
+
+  template<>
+    inline std::streamsize
+    stdio_sync_filebuf<wchar_t>::xsgetn(wchar_t* __s, std::streamsize __n)
+    {
+      std::streamsize __ret = 0;
+      const int_type __eof = traits_type::eof();
+      while (__n--)
+	{
+	  int_type __c = this->syncgetc();
+	  if (traits_type::eq_int_type(__c, __eof))
+	    break;
+	  __s[__ret] = traits_type::to_char_type(__c);
+	  ++__ret;
+	}
+
+      if (__ret > 0)
+	_M_unget_buf = traits_type::to_int_type(__s[__ret - 1]);
+      else
+	_M_unget_buf = traits_type::eof();
+      return __ret;
+    }
+
+  template<>
+    inline std::streamsize
+    stdio_sync_filebuf<wchar_t>::xsputn(const wchar_t* __s,
+					std::streamsize __n)
+    {
+      std::streamsize __ret = 0;
+      const int_type __eof = traits_type::eof();
+      while (__n--)
+	{
+	  if (traits_type::eq_int_type(this->syncputc(*__s++), __eof))
+	    break;
+	  ++__ret;
+	}
+      return __ret;
+    }
+#endif
+
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class stdio_sync_filebuf<char>;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class stdio_sync_filebuf<wchar_t>;
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/string_conversions.h b/gcc-4.9/libstdc++-v3/include/ext/string_conversions.h
new file mode 100644
index 0000000..92ba913
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/string_conversions.h
@@ -0,0 +1,107 @@
+// String Conversions -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/string_conversions.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _STRING_CONVERSIONS_H
+#define _STRING_CONVERSIONS_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <bits/c++config.h>
+#include <ext/numeric_traits.h>
+#include <bits/functexcept.h>
+#include <cstdlib>
+#include <cwchar>
+#include <cstdio>
+#include <cerrno>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Helper for all the sto* functions.
+  template<typename _TRet, typename _Ret = _TRet, typename _CharT,
+	   typename... _Base>
+    _Ret
+    __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
+	   const char* __name, const _CharT* __str, std::size_t* __idx,
+	   _Base... __base)
+    {
+      _Ret __ret;
+
+      _CharT* __endptr;
+      errno = 0;
+      const _TRet __tmp = __convf(__str, &__endptr, __base...);
+
+      if (__endptr == __str)
+	std::__throw_invalid_argument(__name);
+      else if (errno == ERANGE
+	       || (std::__are_same<_Ret, int>::__value
+		   && (__tmp < __numeric_traits<int>::__min
+		       || __tmp > __numeric_traits<int>::__max)))
+	std::__throw_out_of_range(__name);
+      else
+	__ret = __tmp;
+
+      if (__idx)
+	*__idx = __endptr - __str;
+
+      return __ret;
+    }
+
+  // Helper for the to_string / to_wstring functions.
+  template<typename _String, typename _CharT = typename _String::value_type>
+    _String
+    __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
+				 __builtin_va_list), std::size_t __n,
+		 const _CharT* __fmt, ...)
+    {
+      // XXX Eventually the result will be constructed in place in
+      // the C++0x string, likely with the help of internal hooks.
+      _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+							  * __n));
+
+      __builtin_va_list __args;
+      __builtin_va_start(__args, __fmt);
+
+      const int __len = __convf(__s, __n, __fmt, __args);
+
+      __builtin_va_end(__args);
+
+      return _String(__s, __s + __len);
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // C++11
+
+#endif // _STRING_CONVERSIONS_H
diff --git a/gcc-4.9/libstdc++-v3/include/ext/throw_allocator.h b/gcc-4.9/libstdc++-v3/include/ext/throw_allocator.h
new file mode 100644
index 0000000..30b6c47
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/throw_allocator.h
@@ -0,0 +1,980 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/** @file ext/throw_allocator.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ *
+ *  Contains two exception-generating types (throw_value, throw_allocator)
+ *  intended to be used as value and allocator types while testing
+ *  exception safety in templatized containers and algorithms. The
+ *  allocator has additional log and debug features. The exception
+ *  generated is of type forced_exception_error.
+ */
+
+#ifndef _THROW_ALLOCATOR_H
+#define _THROW_ALLOCATOR_H 1
+
+#include <cmath>
+#include <ctime>
+#include <map>
+#include <string>
+#include <ostream>
+#include <stdexcept>
+#include <utility>
+#include <bits/functexcept.h>
+#include <bits/move.h>
+#if __cplusplus >= 201103L
+# include <functional>
+# include <random>
+#else
+# include <tr1/functional>
+# include <tr1/random>
+#endif
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief Thown by exception safety machinery.
+   *  @ingroup exceptions
+   */
+  struct forced_error : public std::exception
+  { };
+
+  // Substitute for forced_error object when -fno-exceptions.
+  inline void
+  __throw_forced_error()
+  { _GLIBCXX_THROW_OR_ABORT(forced_error()); }
+
+  /**
+   *  @brief Base class for checking address and label information
+   *  about allocations. Create a std::map between the allocated
+   *  address (void*) and a datum for annotations, which are a pair of
+   *  numbers corresponding to label and allocated size.
+   */
+  struct annotate_base
+  {
+    annotate_base()
+    {
+      label();
+      map_alloc();
+    }
+
+    static void
+    set_label(size_t l)
+    { label() = l; }
+
+    static size_t
+    get_label()
+    { return label(); }
+
+    void
+    insert(void* p, size_t size)
+    {
+      if (!p)
+	{
+	  std::string error("annotate_base::insert null insert!\n");
+	  log_to_string(error, make_entry(p, size));
+	  std::__throw_logic_error(error.c_str());
+	}
+
+      const_iterator found = map_alloc().find(p);
+      if (found != map_alloc().end())
+	{
+	  std::string error("annotate_base::insert double insert!\n");
+	  log_to_string(error, make_entry(p, size));
+	  log_to_string(error, *found);
+	  std::__throw_logic_error(error.c_str());
+	}
+
+      map_alloc().insert(make_entry(p, size));
+    }
+
+    void
+    erase(void* p, size_t size)
+    {
+      check_allocated(p, size);
+      map_alloc().erase(p);
+    }
+
+#if __cplusplus >= 201103L
+    void
+    insert_construct(void* p)
+    {
+      if (!p)
+	{
+	  std::string error("annotate_base::insert_construct null!\n");
+	  std::__throw_logic_error(error.c_str());
+	}
+
+      auto found = map_construct().find(p);
+      if (found != map_construct().end())
+	{
+	  std::string error("annotate_base::insert_construct double insert!\n");
+	  log_to_string(error, std::make_pair(p, get_label()));
+	  log_to_string(error, *found);
+	  std::__throw_logic_error(error.c_str());
+	}
+
+      map_construct().insert(std::make_pair(p, get_label()));
+    }
+
+    void
+    erase_construct(void* p)
+    {
+      check_constructed(p);
+      map_construct().erase(p);
+    }
+#endif
+
+    // See if a particular address and allocation size has been saved.
+    inline void
+    check_allocated(void* p, size_t size)
+    {
+      const_iterator found = map_alloc().find(p);
+      if (found == map_alloc().end())
+	{
+	  std::string error("annotate_base::check_allocated by value "
+			    "null erase!\n");
+	  log_to_string(error, make_entry(p, size));
+	  std::__throw_logic_error(error.c_str());
+	}
+
+      if (found->second.second != size)
+	{
+	  std::string error("annotate_base::check_allocated by value "
+			    "wrong-size erase!\n");
+	  log_to_string(error, make_entry(p, size));
+	  log_to_string(error, *found);
+	  std::__throw_logic_error(error.c_str());
+	}
+    }
+
+    // See if a given label has been allocated.
+    inline void
+    check(size_t label)
+    {
+      std::string found;
+      {
+	const_iterator beg = map_alloc().begin();
+	const_iterator end = map_alloc().end();
+	while (beg != end)
+	  {
+	    if (beg->second.first == label)
+	      log_to_string(found, *beg);
+	    ++beg;
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      {
+	auto beg = map_construct().begin();
+	auto end = map_construct().end();
+	while (beg != end)
+	  {
+	    if (beg->second == label)
+	      log_to_string(found, *beg);
+	    ++beg;
+	  }
+      }
+#endif
+
+      if (!found.empty())
+	{
+	  std::string error("annotate_base::check by label\n");
+	  error += found;
+	  std::__throw_logic_error(error.c_str());
+	}
+    }
+
+    // See if there is anything left allocated or constructed.
+    inline static void
+    check()
+    {
+      std::string found;
+      {
+	const_iterator beg = map_alloc().begin();
+	const_iterator end = map_alloc().end();
+	while (beg != end)
+	  {
+	    log_to_string(found, *beg);
+	    ++beg;
+	  }
+      }
+
+#if __cplusplus >= 201103L
+      {
+	auto beg = map_construct().begin();
+	auto end = map_construct().end();
+	while (beg != end)
+	  {
+	    log_to_string(found, *beg);
+	    ++beg;
+	  }
+      }
+#endif
+
+      if (!found.empty())
+	{
+	  std::string error("annotate_base::check \n");
+	  error += found;
+	  std::__throw_logic_error(error.c_str());
+	}
+    }
+
+#if __cplusplus >= 201103L
+    inline void
+    check_constructed(void* p)
+    {
+      auto found = map_construct().find(p);
+      if (found == map_construct().end())
+	{
+	  std::string error("annotate_base::check_constructed not "
+			    "constructed!\n");
+	  log_to_string(error, std::make_pair(p, get_label()));
+	  std::__throw_logic_error(error.c_str());
+	}
+    }
+
+    inline void
+    check_constructed(size_t label)
+    {
+      auto beg = map_construct().begin();
+      auto end = map_construct().end();
+      std::string found;
+      while (beg != end)
+	{
+	  if (beg->second == label)
+	    log_to_string(found, *beg);
+	  ++beg;
+	}
+
+      if (!found.empty())
+	{
+	  std::string error("annotate_base::check_constructed by label\n");
+	  error += found;
+	  std::__throw_logic_error(error.c_str());
+	}
+    }
+#endif
+
+  private:
+    typedef std::pair<size_t, size_t>		data_type;
+    typedef std::map<void*, data_type> 		map_alloc_type;
+    typedef map_alloc_type::value_type 		entry_type;
+    typedef map_alloc_type::const_iterator 		const_iterator;
+    typedef map_alloc_type::const_reference 		const_reference;
+#if __cplusplus >= 201103L
+    typedef std::map<void*, size_t>		map_construct_type;
+#endif
+
+    friend std::ostream&
+    operator<<(std::ostream&, const annotate_base&);
+
+    entry_type
+    make_entry(void* p, size_t size)
+    { return std::make_pair(p, data_type(get_label(), size)); }
+
+    static void
+    log_to_string(std::string& s, const_reference ref)
+    {
+      char buf[40];
+      const char tab('\t');
+      s += "label: ";
+      unsigned long l = static_cast<unsigned long>(ref.second.first);
+      __builtin_sprintf(buf, "%lu", l);
+      s += buf;
+      s += tab;
+      s += "size: ";
+      l = static_cast<unsigned long>(ref.second.second);
+      __builtin_sprintf(buf, "%lu", l);
+      s += buf;
+      s += tab;
+      s += "address: ";
+      __builtin_sprintf(buf, "%p", ref.first);
+      s += buf;
+      s += '\n';
+    }
+
+#if __cplusplus >= 201103L
+    static void
+    log_to_string(std::string& s, const std::pair<const void*, size_t>& ref)
+    {
+      char buf[40];
+      const char tab('\t');
+      s += "label: ";
+      unsigned long l = static_cast<unsigned long>(ref.second);
+      __builtin_sprintf(buf, "%lu", l);
+      s += buf;
+      s += tab;
+      s += "address: ";
+      __builtin_sprintf(buf, "%p", ref.first);
+      s += buf;
+      s += '\n';
+    }
+#endif
+
+    static size_t&
+    label()
+    {
+      static size_t _S_label(std::numeric_limits<size_t>::max());
+      return _S_label;
+    }
+
+    static map_alloc_type&
+    map_alloc()
+    {
+      static map_alloc_type _S_map;
+      return _S_map;
+    }
+
+#if __cplusplus >= 201103L
+    static map_construct_type&
+    map_construct()
+    {
+      static map_construct_type _S_map;
+      return _S_map;
+    }
+#endif
+  };
+
+  inline std::ostream&
+  operator<<(std::ostream& os, const annotate_base& __b)
+  {
+    std::string error;
+    typedef annotate_base base_type;
+    {
+      base_type::const_iterator beg = __b.map_alloc().begin();
+      base_type::const_iterator end = __b.map_alloc().end();
+      for (; beg != end; ++beg)
+	__b.log_to_string(error, *beg);
+    }
+#if __cplusplus >= 201103L
+    {
+      auto beg = __b.map_construct().begin();
+      auto end = __b.map_construct().end();
+      for (; beg != end; ++beg)
+	__b.log_to_string(error, *beg);      
+    }
+#endif
+    return os << error;
+  }
+
+
+  /**
+   *  @brief Base struct for condition policy.
+   *
+   * Requires a public member function with the signature
+   * void throw_conditionally()
+   */
+  struct condition_base
+  {
+    virtual ~condition_base() { };
+  };
+
+
+  /**
+   *  @brief Base class for incremental control and throw.
+   */
+  struct limit_condition : public condition_base
+  {
+    // Scope-level adjustor objects: set limit for throw at the
+    // beginning of a scope block, and restores to previous limit when
+    // object is destroyed on exiting the block.
+    struct adjustor_base
+    {
+    private:
+      const size_t _M_orig;
+
+    public:
+      adjustor_base() : _M_orig(limit()) { }
+
+      virtual
+      ~adjustor_base() { set_limit(_M_orig); }
+    };
+
+    /// Never enter the condition.
+    struct never_adjustor : public adjustor_base
+    {
+      never_adjustor() { set_limit(std::numeric_limits<size_t>::max()); }
+    };
+
+    /// Always enter the condition.
+    struct always_adjustor : public adjustor_base
+    {
+      always_adjustor() { set_limit(count()); }
+    };
+
+    /// Enter the nth condition.
+    struct limit_adjustor : public adjustor_base
+    {
+      limit_adjustor(const size_t __l) { set_limit(__l); }
+    };
+
+    // Increment _S_count every time called.
+    // If _S_count matches the limit count, throw.
+    static void
+    throw_conditionally()
+    {
+      if (count() == limit())
+	__throw_forced_error();
+      ++count();
+    }
+
+    static size_t&
+    count()
+    {
+      static size_t _S_count(0);
+      return _S_count;
+    }
+
+    static size_t&
+    limit()
+    {
+      static size_t _S_limit(std::numeric_limits<size_t>::max());
+      return _S_limit;
+    }
+
+    // Zero the throw counter, set limit to argument.
+    static void
+    set_limit(const size_t __l)
+    {
+      limit() = __l;
+      count() = 0;
+    }
+  };
+
+
+  /**
+   *  @brief Base class for random probability control and throw.
+   */
+  struct random_condition : public condition_base
+  {
+    // Scope-level adjustor objects: set probability for throw at the
+    // beginning of a scope block, and restores to previous
+    // probability when object is destroyed on exiting the block.
+    struct adjustor_base
+    {
+    private:
+      const double _M_orig;
+
+    public:
+      adjustor_base() : _M_orig(probability()) { }
+
+      virtual ~adjustor_base()
+      { set_probability(_M_orig); }
+    };
+
+    /// Group condition.
+    struct group_adjustor : public adjustor_base
+    {
+      group_adjustor(size_t size)
+      { set_probability(1 - std::pow(double(1 - probability()),
+				     double(0.5 / (size + 1))));
+      }
+    };
+
+    /// Never enter the condition.
+    struct never_adjustor : public adjustor_base
+    {
+      never_adjustor() { set_probability(0); }
+    };
+
+    /// Always enter the condition.
+    struct always_adjustor : public adjustor_base
+    {
+      always_adjustor() { set_probability(1); }
+    };
+
+    random_condition()
+    {
+      probability();
+      engine();
+    }
+
+    static void
+    set_probability(double __p)
+    { probability() = __p; }
+
+    static void
+    throw_conditionally()
+    {
+      if (generate() < probability())
+	__throw_forced_error();
+    }
+
+    void
+    seed(unsigned long __s)
+    { engine().seed(__s); }
+
+  private:
+#if __cplusplus >= 201103L
+    typedef std::uniform_real_distribution<double> 	distribution_type;
+    typedef std::mt19937 				engine_type;
+#else
+    typedef std::tr1::uniform_real<double> 		distribution_type;
+    typedef std::tr1::mt19937 				engine_type;
+#endif
+
+    static double
+    generate()
+    {
+#if __cplusplus >= 201103L
+      const distribution_type distribution(0, 1);
+      static auto generator = std::bind(distribution, engine());
+#else
+      // Use variate_generator to get normalized results.
+      typedef std::tr1::variate_generator<engine_type, distribution_type> gen_t;
+      distribution_type distribution(0, 1);
+      static gen_t generator(engine(), distribution);
+#endif
+
+      double random = generator();
+      if (random < distribution.min() || random > distribution.max())
+	{
+	  std::string __s("random_condition::generate");
+	  __s += "\n";
+	  __s += "random number generated is: ";
+	  char buf[40];
+	  __builtin_sprintf(buf, "%f", random);
+	  __s += buf;
+	  std::__throw_out_of_range(__s.c_str());
+	}
+
+      return random;
+    }
+
+    static double&
+    probability()
+    {
+      static double _S_p;
+      return _S_p;
+    }
+
+    static engine_type&
+    engine()
+    {
+      static engine_type _S_e;
+      return _S_e;
+    }
+  };
+
+
+  /**
+   *  @brief Class with exception generation control. Intended to be
+   *  used as a value_type in templatized code.
+   *
+   *  Note: Destructor not allowed to throw.
+   */
+  template<typename _Cond>
+    struct throw_value_base : public _Cond
+    {
+      typedef _Cond  				condition_type;
+
+      using condition_type::throw_conditionally;
+
+      std::size_t			       	_M_i;
+
+#ifndef _GLIBCXX_IS_AGGREGATE
+      throw_value_base() : _M_i(0)
+      { throw_conditionally(); }
+
+      throw_value_base(const throw_value_base& __v) : _M_i(__v._M_i)
+      { throw_conditionally(); }
+
+#if __cplusplus >= 201103L
+      // Shall not throw.
+      throw_value_base(throw_value_base&&) = default;
+#endif
+
+      explicit throw_value_base(const std::size_t __i) : _M_i(__i)
+      { throw_conditionally(); }
+#endif
+
+      throw_value_base&
+      operator=(const throw_value_base& __v)
+      {
+	throw_conditionally();
+	_M_i = __v._M_i;
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      // Shall not throw.
+      throw_value_base&
+      operator=(throw_value_base&&) = default;
+#endif
+
+      throw_value_base&
+      operator++()
+      {
+	throw_conditionally();
+	++_M_i;
+	return *this;
+      }
+    };
+
+  template<typename _Cond>
+    inline void
+    swap(throw_value_base<_Cond>& __a, throw_value_base<_Cond>& __b)
+    {
+      typedef throw_value_base<_Cond> throw_value;
+      throw_value::throw_conditionally();
+      throw_value orig(__a);
+      __a = __b;
+      __b = orig;
+    }
+
+  // General instantiable types requirements.
+  template<typename _Cond>
+    inline bool
+    operator==(const throw_value_base<_Cond>& __a,
+	       const throw_value_base<_Cond>& __b)
+    {
+      typedef throw_value_base<_Cond> throw_value;
+      throw_value::throw_conditionally();
+      bool __ret = __a._M_i == __b._M_i;
+      return __ret;
+    }
+
+  template<typename _Cond>
+    inline bool
+    operator<(const throw_value_base<_Cond>& __a,
+	      const throw_value_base<_Cond>& __b)
+    {
+      typedef throw_value_base<_Cond> throw_value;
+      throw_value::throw_conditionally();
+      bool __ret = __a._M_i < __b._M_i;
+      return __ret;
+    }
+
+  // Numeric algorithms instantiable types requirements.
+  template<typename _Cond>
+    inline throw_value_base<_Cond>
+    operator+(const throw_value_base<_Cond>& __a,
+	      const throw_value_base<_Cond>& __b)
+    {
+      typedef throw_value_base<_Cond> throw_value;
+      throw_value::throw_conditionally();
+      throw_value __ret(__a._M_i + __b._M_i);
+      return __ret;
+    }
+
+  template<typename _Cond>
+    inline throw_value_base<_Cond>
+    operator-(const throw_value_base<_Cond>& __a,
+	      const throw_value_base<_Cond>& __b)
+    {
+      typedef throw_value_base<_Cond> throw_value;
+      throw_value::throw_conditionally();
+      throw_value __ret(__a._M_i - __b._M_i);
+      return __ret;
+    }
+
+  template<typename _Cond>
+    inline throw_value_base<_Cond>
+    operator*(const throw_value_base<_Cond>& __a,
+	      const throw_value_base<_Cond>& __b)
+    {
+      typedef throw_value_base<_Cond> throw_value;
+      throw_value::throw_conditionally();
+      throw_value __ret(__a._M_i * __b._M_i);
+      return __ret;
+    }
+
+
+  /// Type throwing via limit condition.
+  struct throw_value_limit : public throw_value_base<limit_condition>
+  {
+    typedef throw_value_base<limit_condition> base_type;
+
+#ifndef _GLIBCXX_IS_AGGREGATE
+    throw_value_limit() { }
+
+    throw_value_limit(const throw_value_limit& __other)
+    : base_type(__other._M_i) { }
+
+#if __cplusplus >= 201103L
+    throw_value_limit(throw_value_limit&&) = default;
+#endif
+
+    explicit throw_value_limit(const std::size_t __i) : base_type(__i) { }
+#endif
+
+    throw_value_limit&
+    operator=(const throw_value_limit& __other)
+    {
+      base_type::operator=(__other);
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+    throw_value_limit&
+    operator=(throw_value_limit&&) = default;
+#endif
+  };
+
+  /// Type throwing via random condition.
+  struct throw_value_random : public throw_value_base<random_condition>
+  {
+    typedef throw_value_base<random_condition> base_type;
+
+#ifndef _GLIBCXX_IS_AGGREGATE
+    throw_value_random() { }
+
+    throw_value_random(const throw_value_random& __other)
+    : base_type(__other._M_i) { }
+
+#if __cplusplus >= 201103L
+    throw_value_random(throw_value_random&&) = default;
+#endif
+
+    explicit throw_value_random(const std::size_t __i) : base_type(__i) { }
+#endif
+
+    throw_value_random&
+    operator=(const throw_value_random& __other)
+    {
+      base_type::operator=(__other);
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+    throw_value_random&
+    operator=(throw_value_random&&) = default;
+#endif
+  };
+
+
+  /**
+   *  @brief Allocator class with logging and exception generation control.
+   * Intended to be used as an allocator_type in templatized code.
+   *  @ingroup allocators
+   *
+   *  Note: Deallocate not allowed to throw.
+   */
+  template<typename _Tp, typename _Cond>
+    class throw_allocator_base
+    : public annotate_base, public _Cond
+    {
+    public:
+      typedef size_t 				size_type;
+      typedef ptrdiff_t 			difference_type;
+      typedef _Tp 				value_type;
+      typedef value_type* 			pointer;
+      typedef const value_type* 		const_pointer;
+      typedef value_type& 			reference;
+      typedef const value_type& 		const_reference;
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2103. std::allocator propagate_on_container_move_assignment
+      typedef std::true_type propagate_on_container_move_assignment;
+#endif
+
+    private:
+      typedef _Cond				condition_type;
+
+      std::allocator<value_type> 		_M_allocator;
+
+      using condition_type::throw_conditionally;
+
+    public:
+      size_type
+      max_size() const _GLIBCXX_USE_NOEXCEPT
+      { return _M_allocator.max_size(); }
+
+      pointer
+      address(reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      const_pointer
+      address(const_reference __x) const _GLIBCXX_NOEXCEPT
+      { return std::__addressof(__x); }
+
+      pointer
+      allocate(size_type __n, std::allocator<void>::const_pointer hint = 0)
+      {
+	if (__n > this->max_size())
+	  std::__throw_bad_alloc();
+
+	throw_conditionally();
+	pointer const a = _M_allocator.allocate(__n, hint);
+	insert(a, sizeof(value_type) * __n);
+	return a;
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+	{
+	  _M_allocator.construct(__p, std::forward<_Args>(__args)...);
+	  insert_construct(__p);
+	}
+
+      template<typename _Up>
+        void 
+        destroy(_Up* __p)
+        {
+	  erase_construct(__p);
+	  _M_allocator.destroy(__p);
+	}
+#else
+      void
+      construct(pointer __p, const value_type& val)
+      { return _M_allocator.construct(__p, val); }
+
+      void
+      destroy(pointer __p)
+      { _M_allocator.destroy(__p); }
+#endif
+
+      void
+      deallocate(pointer __p, size_type __n)
+      {
+	erase(__p, sizeof(value_type) * __n);
+	_M_allocator.deallocate(__p, __n);
+      }
+
+      void
+      check_allocated(pointer __p, size_type __n)
+      {
+	size_type __t = sizeof(value_type) * __n;
+	annotate_base::check_allocated(__p, __t);
+      }
+
+      void
+      check(size_type __n)
+      { annotate_base::check(__n); }
+  };
+
+  template<typename _Tp, typename _Cond>
+    inline bool
+    operator==(const throw_allocator_base<_Tp, _Cond>&,
+	       const throw_allocator_base<_Tp, _Cond>&)
+    { return true; }
+
+  template<typename _Tp, typename _Cond>
+    inline bool
+    operator!=(const throw_allocator_base<_Tp, _Cond>&,
+	       const throw_allocator_base<_Tp, _Cond>&)
+    { return false; }
+
+  /// Allocator throwing via limit condition.
+  template<typename _Tp>
+    struct throw_allocator_limit
+    : public throw_allocator_base<_Tp, limit_condition>
+    {
+      template<typename _Tp1>
+	struct rebind
+	{ typedef throw_allocator_limit<_Tp1> other; };
+
+      throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { }
+
+      throw_allocator_limit(const throw_allocator_limit&)
+      _GLIBCXX_USE_NOEXCEPT { }
+
+      template<typename _Tp1>
+	throw_allocator_limit(const throw_allocator_limit<_Tp1>&)
+	_GLIBCXX_USE_NOEXCEPT { }
+
+      ~throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { }
+    };
+
+  /// Allocator throwing via random condition.
+  template<typename _Tp>
+    struct throw_allocator_random
+    : public throw_allocator_base<_Tp, random_condition>
+    {
+      template<typename _Tp1>
+	struct rebind
+	{ typedef throw_allocator_random<_Tp1> other; };
+
+      throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { }
+
+      throw_allocator_random(const throw_allocator_random&)
+      _GLIBCXX_USE_NOEXCEPT { }
+
+      template<typename _Tp1>
+	throw_allocator_random(const throw_allocator_random<_Tp1>&)
+	_GLIBCXX_USE_NOEXCEPT { }
+
+      ~throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if __cplusplus >= 201103L
+
+# include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  /// Explicit specialization of std::hash for __gnu_cxx::throw_value_limit.
+  template<>
+    struct hash<__gnu_cxx::throw_value_limit>
+    : public std::unary_function<__gnu_cxx::throw_value_limit, size_t>
+    {
+      size_t
+      operator()(const __gnu_cxx::throw_value_limit& __val) const
+      {
+	__gnu_cxx::throw_value_limit::throw_conditionally();
+	std::hash<std::size_t> __h;
+	size_t __result = __h(__val._M_i);
+	return __result;
+      }
+    };
+
+  /// Explicit specialization of std::hash for __gnu_cxx::throw_value_random.
+  template<>
+    struct hash<__gnu_cxx::throw_value_random>
+    : public std::unary_function<__gnu_cxx::throw_value_random, size_t>
+    {
+      size_t
+      operator()(const __gnu_cxx::throw_value_random& __val) const
+      {
+	__gnu_cxx::throw_value_random::throw_conditionally();
+	std::hash<std::size_t> __h;
+	size_t __result = __h(__val._M_i);
+	return __result;
+      }
+    };
+} // end namespace std
+#endif
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/type_traits.h b/gcc-4.9/libstdc++-v3/include/ext/type_traits.h
new file mode 100644
index 0000000..c9af8ff
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/type_traits.h
@@ -0,0 +1,218 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/type_traits.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _EXT_TYPE_TRAITS
+#define _EXT_TYPE_TRAITS 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/cpp_type_traits.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Define a nested type if some predicate holds.
+  template<bool, typename>
+    struct __enable_if 
+    { };
+
+  template<typename _Tp>
+    struct __enable_if<true, _Tp>
+    { typedef _Tp __type; };
+
+
+  // Conditional expression for types. If true, first, if false, second.
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct __conditional_type
+    { typedef _Iftrue __type; };
+
+  template<typename _Iftrue, typename _Iffalse>
+    struct __conditional_type<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse __type; };
+
+
+  // Given an integral builtin type, return the corresponding unsigned type.
+  template<typename _Tp>
+    struct __add_unsigned
+    { 
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+      
+    public:
+      typedef typename __if_type::__type __type; 
+    };
+
+  template<>
+    struct __add_unsigned<char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __add_unsigned<signed char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __add_unsigned<short>
+    { typedef unsigned short __type; };
+
+  template<>
+    struct __add_unsigned<int>
+    { typedef unsigned int __type; };
+
+  template<>
+    struct __add_unsigned<long>
+    { typedef unsigned long __type; };
+
+  template<>
+    struct __add_unsigned<long long>
+    { typedef unsigned long long __type; };
+
+  // Declare but don't define.
+  template<>
+    struct __add_unsigned<bool>;
+
+  template<>
+    struct __add_unsigned<wchar_t>;
+
+
+  // Given an integral builtin type, return the corresponding signed type.
+  template<typename _Tp>
+    struct __remove_unsigned
+    { 
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+      
+    public:
+      typedef typename __if_type::__type __type; 
+    };
+
+  template<>
+    struct __remove_unsigned<char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned short>
+    { typedef short __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned int>
+    { typedef int __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned long>
+    { typedef long __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned long long>
+    { typedef long long __type; };
+
+  // Declare but don't define.
+  template<>
+    struct __remove_unsigned<bool>;
+
+  template<>
+    struct __remove_unsigned<wchar_t>;
+
+
+  // For use in string and vstring.
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type* __ptr)
+    { return __ptr == 0; }
+
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type)
+    { return false; }
+
+#if __cplusplus >= 201103L
+  inline bool
+  __is_null_pointer(std::nullptr_t)
+  { return true; }
+#endif
+
+  // For complex and cmath
+  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+    struct __promote
+    { typedef double __type; };
+
+  // No nested __type member for non-integer non-floating point types,
+  // allows this type to be used for SFINAE to constrain overloads in
+  // <cmath> and <complex> to only the intended types.
+  template<typename _Tp>
+    struct __promote<_Tp, false>
+    { };
+
+  template<>
+    struct __promote<long double>
+    { typedef long double __type; };
+
+  template<>
+    struct __promote<double>
+    { typedef double __type; };
+
+  template<>
+    struct __promote<float>
+    { typedef float __type; };
+
+  template<typename _Tp, typename _Up,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type>
+    struct __promote_2
+    {
+      typedef __typeof__(_Tp2() + _Up2()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type>
+    struct __promote_3
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type,
+           typename _Wp2 = typename __promote<_Wp>::__type>
+    struct __promote_4
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif 
diff --git a/gcc-4.9/libstdc++-v3/include/ext/typelist.h b/gcc-4.9/libstdc++-v3/include/ext/typelist.h
new file mode 100644
index 0000000..626e1c7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/typelist.h
@@ -0,0 +1,559 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice and
+// this permission notice appear in supporting documentation. None of
+// the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied warranty.
+
+/**
+ *  @file ext/typelist.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ *
+ *  Contains typelist_chain definitions.
+ *  Typelists are an idea by Andrei Alexandrescu.
+ */
+
+#ifndef _TYPELIST_H
+#define _TYPELIST_H 1
+
+#include <ext/type_traits.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+/** @namespace __gnu_cxx::typelist
+ *  @brief GNU typelist extensions for public compile-time use.
+*/
+namespace typelist
+{
+  struct null_type { };
+
+  template<typename Root>
+    struct node
+    {
+      typedef Root 	root;
+    };
+
+  // Forward declarations of functors.
+  template<typename Hd, typename Typelist>
+    struct chain
+    {
+      typedef Hd 	head;
+      typedef Typelist 	tail;
+    };
+
+  // Apply all typelist types to unary functor.
+  template<typename Fn, typename Typelist>
+    void
+    apply(Fn&, Typelist);
+
+  /// Apply all typelist types to generator functor.
+  template<typename Gn, typename Typelist>
+    void
+    apply_generator(Gn&, Typelist);
+
+  // Apply all typelist types and values to generator functor.
+  template<typename Gn, typename TypelistT, typename TypelistV>
+    void
+    apply_generator(Gn&, TypelistT, TypelistV);
+
+  template<typename Typelist0, typename Typelist1>
+    struct append;
+
+  template<typename Typelist_Typelist>
+    struct append_typelist;
+
+  template<typename Typelist, typename T>
+    struct contains;
+
+  template<typename Typelist, template<typename T> class Pred>
+    struct filter;
+
+  template<typename Typelist, int i>
+    struct at_index;
+
+  template<typename Typelist, template<typename T> class Transform>
+    struct transform;
+
+  template<typename Typelist_Typelist>
+    struct flatten;
+
+  template<typename Typelist>
+    struct from_first;
+
+  template<typename T1>
+    struct create1;
+
+  template<typename T1, typename T2>
+    struct create2;
+
+  template<typename T1, typename T2, typename T3>
+    struct create3;
+
+  template<typename T1, typename T2, typename T3, typename T4>
+    struct create4;
+
+  template<typename T1, typename T2, typename T3, typename T4, typename T5>
+    struct create5;
+
+  template<typename T1, typename T2, typename T3,
+	   typename T4, typename T5, typename T6>
+    struct create6;
+} // namespace typelist
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+namespace typelist
+{
+namespace detail
+{
+  template<typename Fn, typename Typelist_Chain>
+    struct apply_;
+
+  template<typename Fn, typename Hd, typename Tl>
+    struct apply_<Fn, chain<Hd, Tl> >
+    {
+      void
+      operator()(Fn& f)
+      {
+	f.operator()(Hd());
+	apply_<Fn, Tl> next;
+	next(f);
+      }
+    };
+
+  template<typename Fn>
+    struct apply_<Fn, null_type>
+    {
+      void
+      operator()(Fn&) { }
+    };
+
+  template<typename Gn, typename Typelist_Chain>
+    struct apply_generator1_;
+
+  template<typename Gn, typename Hd, typename Tl>
+    struct apply_generator1_<Gn, chain<Hd, Tl> >
+    {
+      void
+      operator()(Gn& g)
+      {
+	g.template operator()<Hd>();
+	apply_generator1_<Gn, Tl> next;
+	next(g);
+      }
+    };
+
+  template<typename Gn>
+    struct apply_generator1_<Gn, null_type>
+    {
+      void
+      operator()(Gn&) { }
+    };
+
+  template<typename Gn, typename TypelistT_Chain, typename TypelistV_Chain>
+    struct apply_generator2_;
+
+  template<typename Gn, typename Hd1, typename TlT, typename Hd2, typename TlV>
+    struct apply_generator2_<Gn, chain<Hd1, TlT>, chain<Hd2, TlV> >
+    {
+      void
+      operator()(Gn& g)
+      {
+	g.template operator()<Hd1, Hd2>();
+	apply_generator2_<Gn, TlT, TlV> next;
+	next(g);
+      }
+    };
+
+  template<typename Gn>
+    struct apply_generator2_<Gn, null_type, null_type>
+    {
+      void
+      operator()(Gn&) { }
+    };
+
+  template<typename Typelist_Chain0, typename Typelist_Chain1>
+    struct append_;
+
+  template<typename Hd, typename Tl, typename Typelist_Chain>
+    struct append_<chain<Hd, Tl>, Typelist_Chain>
+    {
+    private:
+      typedef append_<Tl, Typelist_Chain> 			append_type;
+
+    public:
+      typedef chain<Hd, typename append_type::type> 		type;
+    };
+
+  template<typename Typelist_Chain>
+    struct append_<null_type, Typelist_Chain>
+    {
+      typedef Typelist_Chain 			      		type;
+    };
+
+  template<typename Typelist_Chain>
+    struct append_<Typelist_Chain, null_type>
+    {
+      typedef Typelist_Chain 					type;
+    };
+
+  template<>
+    struct append_<null_type, null_type>
+    {
+      typedef null_type 					type;
+    };
+
+  template<typename Typelist_Typelist_Chain>
+    struct append_typelist_;
+
+  template<typename Hd>
+    struct append_typelist_<chain<Hd, null_type> >
+    {
+      typedef chain<Hd, null_type> 				type;
+    };
+
+  template<typename Hd, typename Tl>
+    struct append_typelist_<chain< Hd, Tl> >
+    {
+    private:
+      typedef typename append_typelist_<Tl>::type 		rest_type;
+
+    public:
+      typedef typename append<Hd, node<rest_type> >::type::root	type;
+    };
+
+  template<typename Typelist_Chain, typename T>
+    struct contains_;
+
+  template<typename T>
+    struct contains_<null_type, T>
+    {
+      enum
+	{
+	  value = false
+	};
+    };
+
+  template<typename Hd, typename Tl, typename T>
+    struct contains_<chain<Hd, Tl>, T>
+    {
+      enum
+	{
+	  value = contains_<Tl, T>::value
+	};
+    };
+
+  template<typename Tl, typename T>
+    struct contains_<chain<T, Tl>, T>
+    {
+      enum
+	{
+	  value = true
+	};
+    };
+
+  template<typename Typelist_Chain, template<typename T> class Pred>
+    struct chain_filter_;
+
+  template<template<typename T> class Pred>
+    struct chain_filter_<null_type, Pred>
+    {
+      typedef null_type 					type;
+  };
+
+  template<typename Hd, typename Tl, template<typename T> class Pred>
+    struct chain_filter_<chain<Hd, Tl>, Pred>
+    {
+    private:
+      enum
+	{
+	  include_hd = Pred<Hd>::value
+	};
+
+      typedef typename chain_filter_<Tl, Pred>::type 		rest_type;
+      typedef chain<Hd, rest_type> 				chain_type;
+
+    public:
+      typedef typename __conditional_type<include_hd, chain_type, rest_type>::__type type;
+  };
+
+  template<typename Typelist_Chain, int i>
+    struct chain_at_index_;
+
+  template<typename Hd, typename Tl>
+    struct chain_at_index_<chain<Hd, Tl>, 0>
+    {
+      typedef Hd 						type;
+    };
+
+  template<typename Hd, typename Tl, int i>
+    struct chain_at_index_<chain<Hd, Tl>, i>
+    {
+      typedef typename chain_at_index_<Tl, i - 1>::type 	type;
+    };
+
+  template<class Typelist_Chain, template<typename T> class Transform>
+    struct chain_transform_;
+
+  template<template<typename T> class Transform>
+    struct chain_transform_<null_type, Transform>
+    {
+      typedef null_type 					type;
+    };
+
+  template<class Hd, class Tl, template<typename T> class Transform>
+    struct chain_transform_<chain<Hd, Tl>, Transform>
+    {
+    private:
+      typedef typename chain_transform_<Tl, Transform>::type 	rest_type;
+      typedef typename Transform<Hd>::type 			transform_type;
+
+    public:
+      typedef chain<transform_type, rest_type> 			type;
+    };
+
+  template<typename Typelist_Typelist_Chain>
+    struct chain_flatten_;
+
+  template<typename Hd_Tl>
+    struct chain_flatten_<chain<Hd_Tl, null_type> >
+    {
+      typedef typename Hd_Tl::root 				type;
+    };
+
+  template<typename Hd_Typelist, class Tl_Typelist>
+    struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> >
+    {
+    private:
+      typedef typename chain_flatten_<Tl_Typelist>::type 	rest_type;
+      typedef append<Hd_Typelist, node<rest_type> >		append_type;
+    public:
+      typedef typename append_type::type::root 			type;
+    };
+} // namespace detail
+} // namespace typelist
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type>
+#define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) >
+#define _GLIBCXX_TYPELIST_CHAIN3(X0, X1, X2) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN2(X1, X2) >
+#define _GLIBCXX_TYPELIST_CHAIN4(X0, X1, X2, X3) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN3(X1, X2, X3) >
+#define _GLIBCXX_TYPELIST_CHAIN5(X0, X1, X2, X3, X4) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN4(X1, X2, X3, X4) >
+#define _GLIBCXX_TYPELIST_CHAIN6(X0, X1, X2, X3, X4, X5) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN5(X1, X2, X3, X4, X5) >
+#define _GLIBCXX_TYPELIST_CHAIN7(X0, X1, X2, X3, X4, X5, X6) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN6(X1, X2, X3, X4, X5, X6) >
+#define _GLIBCXX_TYPELIST_CHAIN8(X0, X1, X2, X3, X4, X5, X6, X7) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN7(X1, X2, X3, X4, X5, X6, X7) >
+#define _GLIBCXX_TYPELIST_CHAIN9(X0, X1, X2, X3, X4, X5, X6, X7, X8) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN8(X1, X2, X3, X4, X5, X6, X7, X8) >
+#define _GLIBCXX_TYPELIST_CHAIN10(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN9(X1, X2, X3, X4, X5, X6, X7, X8, X9) >
+#define _GLIBCXX_TYPELIST_CHAIN11(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN10(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) >
+#define _GLIBCXX_TYPELIST_CHAIN12(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN11(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) >
+#define _GLIBCXX_TYPELIST_CHAIN13(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN12(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) >
+#define _GLIBCXX_TYPELIST_CHAIN14(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN13(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) >
+#define _GLIBCXX_TYPELIST_CHAIN15(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN14(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) >
+#define _GLIBCXX_TYPELIST_CHAIN16(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN15(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) >
+#define _GLIBCXX_TYPELIST_CHAIN17(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN16(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) >
+#define _GLIBCXX_TYPELIST_CHAIN18(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN17(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) >
+#define _GLIBCXX_TYPELIST_CHAIN19(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN18(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) >
+#define _GLIBCXX_TYPELIST_CHAIN20(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN19(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) >
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+namespace typelist
+{
+  template<typename Fn, typename Typelist>
+    void
+    apply(Fn& fn, Typelist)
+    {
+      detail::apply_<Fn, typename Typelist::root> a;
+      a(fn);
+    }
+
+  template<typename Fn, typename Typelist>
+    void
+    apply_generator(Fn& fn, Typelist)
+    {
+      detail::apply_generator1_<Fn, typename Typelist::root> a;
+      a(fn);
+    }
+
+  template<typename Fn, typename TypelistT, typename TypelistV>
+    void
+    apply_generator(Fn& fn, TypelistT, TypelistV)
+    {
+      typedef typename TypelistT::root rootT;
+      typedef typename TypelistV::root rootV;
+      detail::apply_generator2_<Fn, rootT, rootV> a;
+      a(fn);
+    }
+
+  template<typename Typelist0, typename Typelist1>
+    struct append
+    {
+    private:
+      typedef typename Typelist0::root 				root0_type;
+      typedef typename Typelist1::root 				root1_type;
+      typedef detail::append_<root0_type, root1_type> 		append_type;
+
+    public:
+      typedef node<typename append_type::type> 			type;
+    };
+
+  template<typename Typelist_Typelist>
+    struct append_typelist
+    {
+    private:
+      typedef typename Typelist_Typelist::root 		      	root_type;
+      typedef detail::append_typelist_<root_type> 		append_type;
+
+    public:
+      typedef node<typename append_type::type> 			type;
+    };
+
+  template<typename Typelist, typename T>
+    struct contains
+    {
+    private:
+      typedef typename Typelist::root 				root_type;
+
+    public:
+      enum
+	{
+	  value = detail::contains_<root_type, T>::value
+	};
+    };
+
+  template<typename Typelist, template<typename T> class Pred>
+    struct filter
+    {
+    private:
+      typedef typename Typelist::root 				root_type;
+      typedef detail::chain_filter_<root_type, Pred> 		filter_type;
+
+    public:
+      typedef node<typename filter_type::type> 	       		type;
+    };
+
+  template<typename Typelist, int i>
+    struct at_index
+    {
+    private:
+      typedef typename Typelist::root 				root_type;
+      typedef detail::chain_at_index_<root_type, i> 		index_type;
+
+    public:
+      typedef typename index_type::type 			type;
+    };
+
+  template<typename Typelist, template<typename T> class Transform>
+    struct transform
+    {
+    private:
+      typedef typename Typelist::root 				root_type;
+      typedef detail::chain_transform_<root_type, Transform> 	transform_type;
+
+    public:
+      typedef node<typename transform_type::type> 		type;
+    };
+
+  template<typename Typelist_Typelist>
+    struct flatten
+    {
+    private:
+      typedef typename Typelist_Typelist::root 		      	root_type;
+      typedef typename detail::chain_flatten_<root_type>::type 	flatten_type;
+
+    public:
+      typedef node<flatten_type> 				type;
+    };
+
+  template<typename Typelist>
+    struct from_first
+    {
+    private:
+      typedef typename at_index<Typelist, 0>::type 		first_type;
+
+    public:
+      typedef node<chain<first_type, null_type> > 		type;
+    };
+
+  template<typename T1>
+    struct create1
+    {
+      typedef node<_GLIBCXX_TYPELIST_CHAIN1(T1)> 		type;
+    };
+
+  template<typename T1, typename T2>
+    struct create2
+    {
+      typedef node<_GLIBCXX_TYPELIST_CHAIN2(T1,T2)> 		type;
+    };
+
+  template<typename T1, typename T2, typename T3>
+    struct create3
+    {
+      typedef node<_GLIBCXX_TYPELIST_CHAIN3(T1,T2,T3)>		type;
+    };
+
+  template<typename T1, typename T2, typename T3, typename T4>
+    struct create4
+    {
+      typedef node<_GLIBCXX_TYPELIST_CHAIN4(T1,T2,T3,T4)>	type;
+    };
+
+  template<typename T1, typename T2, typename T3,
+	   typename T4, typename T5>
+    struct create5
+    {
+      typedef node<_GLIBCXX_TYPELIST_CHAIN5(T1,T2,T3,T4,T5)>	type;
+    };
+
+  template<typename T1, typename T2, typename T3,
+	   typename T4, typename T5, typename T6>
+    struct create6
+    {
+      typedef node<_GLIBCXX_TYPELIST_CHAIN6(T1,T2,T3,T4,T5,T6)>	type;
+    };
+} // namespace typelist
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/ext/vstring.h b/gcc-4.9/libstdc++-v3/include/ext/vstring.h
new file mode 100644
index 0000000..749d370
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/vstring.h
@@ -0,0 +1,2963 @@
+// Versatile string -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/vstring.h
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _VSTRING_H
+#define _VSTRING_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+#include <ext/vstring_util.h>
+#include <ext/rc_string_base.h>
+#include <ext/sso_string_base.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @class __versa_string vstring.h
+   *  @brief  Template class __versa_string. 
+   *  @ingroup extensions
+   *
+   *  Data structure managing sequences of characters and
+   *  character-like objects. 
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    class __versa_string
+    : private _Base<_CharT, _Traits, _Alloc>
+    {
+      typedef _Base<_CharT, _Traits, _Alloc>                __vstring_base;    
+      typedef typename __vstring_base::_CharT_alloc_type    _CharT_alloc_type;
+
+      // Types:
+    public:
+      typedef _Traits					    traits_type;
+      typedef typename _Traits::char_type		    value_type;
+      typedef _Alloc					    allocator_type;
+      typedef typename _CharT_alloc_type::size_type	    size_type;
+      typedef typename _CharT_alloc_type::difference_type   difference_type;
+      typedef value_type&               	            reference;
+      typedef const value_type&                             const_reference;
+      typedef typename _CharT_alloc_type::pointer	    pointer;
+      typedef typename _CharT_alloc_type::const_pointer	    const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, __versa_string>  iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, __versa_string>
+                                                            const_iterator;
+      typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
+      typedef std::reverse_iterator<iterator>		    reverse_iterator;
+
+      // Data Member (public):
+      ///  Value returned by various member functions when they fail.
+      static const size_type	npos = static_cast<size_type>(-1);
+
+    private:
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+	if (__pos > this->size())
+	  std::__throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
+					    "this->size() (which is %zu)"),
+					__s, __pos, this->size());
+	return __pos;
+      }
+
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+	if (this->max_size() - (this->size() - __n1) < __n2)
+	  std::__throw_length_error(__N(__s));
+      }
+
+      // NB: _M_limit doesn't check for a bad __pos value.
+      size_type
+      _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
+      {
+	const bool __testoff =  __off < this->size() - __pos;
+	return __testoff ? __off : this->size() - __pos;
+      }
+
+      // True if _Rep and source do not overlap.
+      bool
+      _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
+      {
+	return (std::less<const _CharT*>()(__s, this->_M_data())
+		|| std::less<const _CharT*>()(this->_M_data()
+					      + this->size(), __s));
+      }
+
+      // For the internal use we have functions similar to `begin'/`end'
+      // but they do not call _M_leak.
+      iterator
+      _M_ibegin() const _GLIBCXX_NOEXCEPT
+      { return iterator(this->_M_data()); }
+
+      iterator
+      _M_iend() const _GLIBCXX_NOEXCEPT
+      { return iterator(this->_M_data() + this->_M_length()); }
+
+    public:
+      // Construct/copy/destroy:
+      // NB: We overload ctors in some cases instead of using default
+      // arguments, per 17.4.4.4 para. 2 item 2.
+
+      /**
+       *  @brief  Construct an empty string using allocator @a a.
+       */
+      explicit
+      __versa_string(const _Alloc& __a = _Alloc()) _GLIBCXX_NOEXCEPT
+      : __vstring_base(__a) { }
+
+      // NB: per LWG issue 42, semantics different from IS:
+      /**
+       *  @brief  Construct string with copy of value of @a __str.
+       *  @param  __str  Source string.
+       */
+      __versa_string(const __versa_string& __str)
+      : __vstring_base(__str) { }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  String move constructor.
+       *  @param  __str  Source string.
+       *
+       *  The newly-constructed %string contains the exact contents of
+       *  @a __str.  The contents of @a __str are a valid, but unspecified
+       *  string.
+       */
+      __versa_string(__versa_string&& __str) noexcept
+      : __vstring_base(std::move(__str)) { }
+
+      /**
+       *  @brief  Construct string from an initializer list.
+       *  @param  __l  std::initializer_list of characters.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+      __versa_string(std::initializer_list<_CharT> __l,
+		     const _Alloc& __a = _Alloc())
+      : __vstring_base(__l.begin(), __l.end(), __a) { }
+#endif
+
+      /**
+       *  @brief  Construct string as copy of a substring.
+       *  @param  __str  Source string.
+       *  @param  __pos  Index of first character to copy from.
+       *  @param  __n  Number of characters to copy (default remainder).
+       */
+      __versa_string(const __versa_string& __str, size_type __pos,
+		     size_type __n = npos)
+      : __vstring_base(__str._M_data()
+		       + __str._M_check(__pos,
+					"__versa_string::__versa_string"),
+		       __str._M_data() + __str._M_limit(__pos, __n)
+		       + __pos, _Alloc()) { }
+
+      /**
+       *  @brief  Construct string as copy of a substring.
+       *  @param  __str  Source string.
+       *  @param  __pos  Index of first character to copy from.
+       *  @param  __n  Number of characters to copy.
+       *  @param  __a  Allocator to use.
+       */
+      __versa_string(const __versa_string& __str, size_type __pos,
+		     size_type __n, const _Alloc& __a)
+      : __vstring_base(__str._M_data()
+		       + __str._M_check(__pos,
+					"__versa_string::__versa_string"),
+		       __str._M_data() + __str._M_limit(__pos, __n)
+		       + __pos, __a) { }
+
+      /**
+       *  @brief  Construct string initialized by a character array.
+       *  @param  __s  Source character array.
+       *  @param  __n  Number of characters to copy.
+       *  @param  __a  Allocator to use (default is default allocator).
+       *
+       *  NB: @a __s must have at least @a __n characters, '\\0' has no special
+       *  meaning.
+       */
+      __versa_string(const _CharT* __s, size_type __n,
+		     const _Alloc& __a = _Alloc())
+      : __vstring_base(__s, __s + __n, __a) { }
+
+      /**
+       *  @brief  Construct string as copy of a C string.
+       *  @param  __s  Source C string.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+      __versa_string(const _CharT* __s, const _Alloc& __a = _Alloc())
+      : __vstring_base(__s, __s ? __s + traits_type::length(__s) :
+		       __s + npos, __a) { }
+
+      /**
+       *  @brief  Construct string as multiple characters.
+       *  @param  __n  Number of characters.
+       *  @param  __c  Character to use.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+      __versa_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
+      : __vstring_base(__n, __c, __a) { }
+
+      /**
+       *  @brief  Construct string as copy of a range.
+       *  @param  __beg  Start of range.
+       *  @param  __end  End of range.
+       *  @param  __a  Allocator to use (default is default allocator).
+       */
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        __versa_string(_InputIterator __beg, _InputIterator __end,
+		       const _Alloc& __a = _Alloc())
+	: __vstring_base(__beg, __end, __a) { }
+
+      /**
+       *  @brief  Destroy the string instance.
+       */
+      ~__versa_string() _GLIBCXX_NOEXCEPT { }	
+
+      /**
+       *  @brief  Assign the value of @a str to this string.
+       *  @param  __str  Source string.
+       */
+      __versa_string&
+      operator=(const __versa_string& __str) 
+      { return this->assign(__str); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  String move assignment operator.
+       *  @param  __str  Source string.
+       *
+       *  The contents of @a __str are moved into this string (without
+       *  copying).  @a __str is a valid, but unspecified string.
+       */
+      __versa_string&
+      operator=(__versa_string&& __str) noexcept
+      {
+	// NB: DR 1204.
+	this->swap(__str);
+	return *this;
+      }
+
+      /**
+       *  @brief  Set value to string constructed from initializer list.
+       *  @param  __l  std::initializer_list.
+       */
+      __versa_string&
+      operator=(std::initializer_list<_CharT> __l)
+      {
+	this->assign(__l.begin(), __l.end());
+	return *this;
+      }
+#endif
+
+      /**
+       *  @brief  Copy contents of @a __s into this string.
+       *  @param  __s  Source null-terminated string.
+       */
+      __versa_string&
+      operator=(const _CharT* __s) 
+      { return this->assign(__s); }
+
+      /**
+       *  @brief  Set value to string of length 1.
+       *  @param  __c  Source character.
+       *
+       *  Assigning to a character makes this string length 1 and
+       *  (*this)[0] == @a __c.
+       */
+      __versa_string&
+      operator=(_CharT __c) 
+      { 
+	this->assign(1, __c); 
+	return *this;
+      }
+
+      // Iterators:
+      /**
+       *  Returns a read/write iterator that points to the first character in
+       *  the %string.  Unshares the string.
+       */
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_leak();
+	return iterator(this->_M_data());
+      }
+
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  character in the %string.
+       */
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(this->_M_data()); }
+
+      /**
+       *  Returns a read/write iterator that points one past the last
+       *  character in the %string.  Unshares the string.
+       */
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_leak();
+	return iterator(this->_M_data() + this->size());
+      }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the
+       *  last character in the %string.
+       */
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(this->_M_data() + this->size()); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to the last
+       *  character in the %string.  Iteration is done in reverse element
+       *  order.  Unshares the string.
+       */
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(this->end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last character in the %string.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(this->end()); }
+
+      /**
+       *  Returns a read/write reverse iterator that points to one before the
+       *  first character in the %string.  Iteration is done in reverse
+       *  element order.  Unshares the string.
+       */
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(this->begin()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first character in the %string.  Iteration
+       *  is done in reverse element order.
+       */
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(this->begin()); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read-only (constant) iterator that points to the first
+       *  character in the %string.
+       */
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_data()); }
+
+      /**
+       *  Returns a read-only (constant) iterator that points one past the
+       *  last character in the %string.
+       */
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_data() + this->size()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to the last character in the %string.  Iteration is done in
+       *  reverse element order.
+       */
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+      /**
+       *  Returns a read-only (constant) reverse iterator that points
+       *  to one before the first character in the %string.  Iteration
+       *  is done in reverse element order.
+       */
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+#endif
+
+    public:
+      // Capacity:
+      ///  Returns the number of characters in the string, not including any
+      ///  null-termination.
+      size_type
+      size() const _GLIBCXX_NOEXCEPT
+      { return this->_M_length(); }
+
+      ///  Returns the number of characters in the string, not including any
+      ///  null-termination.
+      size_type
+      length() const _GLIBCXX_NOEXCEPT
+      { return this->_M_length(); }
+
+      /// Returns the size() of the largest possible %string.
+      size_type
+      max_size() const _GLIBCXX_NOEXCEPT
+      { return this->_M_max_size(); }
+
+      /**
+       *  @brief  Resizes the %string to the specified number of characters.
+       *  @param  __n  Number of characters the %string should contain.
+       *  @param  __c  Character to fill any new elements.
+       *
+       *  This function will %resize the %string to the specified
+       *  number of characters.  If the number is smaller than the
+       *  %string's current size the %string is truncated, otherwise
+       *  the %string is extended and new elements are set to @a __c.
+       */
+      void
+      resize(size_type __n, _CharT __c);
+
+      /**
+       *  @brief  Resizes the %string to the specified number of characters.
+       *  @param  __n  Number of characters the %string should contain.
+       *
+       *  This function will resize the %string to the specified
+       *  length.  If the new size is smaller than the %string's
+       *  current size the %string is truncated, otherwise the %string
+       *  is extended and new characters are default-constructed.  For
+       *  basic types such as char, this means setting them to 0.
+       */
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+
+#if __cplusplus >= 201103L
+      /// A non-binding request to reduce capacity() to size().
+      void
+      shrink_to_fit() noexcept
+      {
+	if (capacity() > size())
+	  {
+	    __try
+	      { this->reserve(0); }
+	    __catch(...)
+	      { }
+	  }
+      }
+#endif
+
+      /**
+       *  Returns the total number of characters that the %string can
+       *  hold before needing to allocate more memory.
+       */
+      size_type
+      capacity() const _GLIBCXX_NOEXCEPT
+      { return this->_M_capacity(); }
+
+      /**
+       *  @brief  Attempt to preallocate enough memory for specified number of
+       *          characters.
+       *  @param  __res_arg  Number of characters required.
+       *  @throw  std::length_error  If @a __res_arg exceeds @c max_size().
+       *
+       *  This function attempts to reserve enough memory for the
+       *  %string to hold the specified number of characters.  If the
+       *  number requested is more than max_size(), length_error is
+       *  thrown.
+       *
+       *  The advantage of this function is that if optimal code is a
+       *  necessity and the user can determine the string length that
+       *  will be required, the user can reserve the memory in
+       *  %advance, and thus prevent a possible reallocation of memory
+       *  and copying of %string data.
+       */
+      void
+      reserve(size_type __res_arg = 0)
+      { this->_M_reserve(__res_arg); }
+
+      /**
+       *  Erases the string, making it empty.
+       */
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { this->_M_clear(); }
+
+      /**
+       *  Returns true if the %string is empty.  Equivalent to 
+       *  <code>*this == ""</code>.
+       */
+      bool
+      empty() const _GLIBCXX_NOEXCEPT
+      { return this->size() == 0; }
+
+      // Element access:
+      /**
+       *  @brief  Subscript access to the data contained in the %string.
+       *  @param  __pos  The index of the character to access.
+       *  @return  Read-only (constant) reference to the character.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)
+       */
+      const_reference
+      operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
+      {
+	_GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
+	return this->_M_data()[__pos];
+      }
+
+      /**
+       *  @brief  Subscript access to the data contained in the %string.
+       *  @param  __pos  The index of the character to access.
+       *  @return  Read/write reference to the character.
+       *
+       *  This operator allows for easy, array-style, data access.
+       *  Note that data access with this operator is unchecked and
+       *  out_of_range lookups are not defined. (For checked lookups
+       *  see at().)  Unshares the string.
+       */
+      reference
+      operator[](size_type __pos) _GLIBCXX_NOEXCEPT
+      {
+        // Allow pos == size() both in C++98 mode, as v3 extension,
+	// and in C++11 mode.
+	_GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
+        // In pedantic mode be strict in C++98 mode.
+	_GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L
+				 || __pos < this->size());
+	this->_M_leak();
+	return this->_M_data()[__pos];
+      }
+
+      /**
+       *  @brief  Provides access to the data contained in the %string.
+       *  @param __n The index of the character to access.
+       *  @return  Read-only (const) reference to the character.
+       *  @throw  std::out_of_range  If @a __n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter
+       *  is first checked that it is in the range of the string.  The
+       *  function throws out_of_range if the check fails.
+       */
+      const_reference
+      at(size_type __n) const
+      {
+	if (__n >= this->size())
+	  std::__throw_out_of_range_fmt(__N("__versa_string::at: __n "
+					    "(which is %zu) >= this->size() "
+					    "(which is %zu)"),
+					__n, this->size());
+	return this->_M_data()[__n];
+      }
+
+      /**
+       *  @brief  Provides access to the data contained in the %string.
+       *  @param __n The index of the character to access.
+       *  @return  Read/write reference to the character.
+       *  @throw  std::out_of_range  If @a __n is an invalid index.
+       *
+       *  This function provides for safer data access.  The parameter
+       *  is first checked that it is in the range of the string.  The
+       *  function throws out_of_range if the check fails.  Success
+       *  results in unsharing the string.
+       */
+      reference
+      at(size_type __n)
+      {
+	if (__n >= this->size())
+	  std::__throw_out_of_range_fmt(__N("__versa_string::at: __n "
+					    "(which is %zu) >= this->size() "
+					    "(which is %zu)"),
+					__n, this->size());
+	this->_M_leak();
+	return this->_M_data()[__n];
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  Returns a read/write reference to the data at the first
+       *  element of the %string.
+       */
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      { return operator[](0); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the first
+       *  element of the %string.
+       */
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      { return operator[](0); }
+
+      /**
+       *  Returns a read/write reference to the data at the last
+       *  element of the %string.
+       */
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      { return operator[](this->size() - 1); }
+
+      /**
+       *  Returns a read-only (constant) reference to the data at the
+       *  last element of the %string.
+       */
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      { return operator[](this->size() - 1); }
+#endif
+
+      // Modifiers:
+      /**
+       *  @brief  Append a string to this string.
+       *  @param __str  The string to append.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      operator+=(const __versa_string& __str)
+      { return this->append(__str); }
+
+      /**
+       *  @brief  Append a C string.
+       *  @param __s  The C string to append.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+
+      /**
+       *  @brief  Append a character.
+       *  @param __c  The character to append.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      operator+=(_CharT __c)
+      { 
+	this->push_back(__c);
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Append an initializer_list of characters.
+       *  @param __l  The initializer_list of characters to be appended.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      operator+=(std::initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.end()); }
+#endif // C++11
+
+      /**
+       *  @brief  Append a string to this string.
+       *  @param __str  The string to append.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      append(const __versa_string& __str)
+      { return _M_append(__str._M_data(), __str.size()); }
+
+      /**
+       *  @brief  Append a substring.
+       *  @param __str  The string to append.
+       *  @param __pos  Index of the first character of str to append.
+       *  @param __n  The number of characters to append.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range if @a pos is not a valid index.
+       *
+       *  This function appends @a __n characters from @a __str
+       *  starting at @a __pos to this string.  If @a __n is is larger
+       *  than the number of available characters in @a __str, the
+       *  remainder of @a __str is appended.
+       */
+      __versa_string&
+      append(const __versa_string& __str, size_type __pos, size_type __n)
+      { return _M_append(__str._M_data()
+			 + __str._M_check(__pos, "__versa_string::append"),
+			 __str._M_limit(__pos, __n)); }
+
+      /**
+       *  @brief  Append a C substring.
+       *  @param __s  The C string to append.
+       *  @param __n  The number of characters to append.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      append(const _CharT* __s, size_type __n)
+      {
+	__glibcxx_requires_string_len(__s, __n);
+	_M_check_length(size_type(0), __n, "__versa_string::append");
+	return _M_append(__s, __n);
+      }
+
+      /**
+       *  @brief  Append a C string.
+       *  @param __s  The C string to append.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      append(const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	const size_type __n = traits_type::length(__s);
+	_M_check_length(size_type(0), __n, "__versa_string::append");
+	return _M_append(__s, __n);
+      }
+
+      /**
+       *  @brief  Append multiple characters.
+       *  @param __n  The number of characters to append.
+       *  @param __c  The character to use.
+       *  @return  Reference to this string.
+       *
+       *  Appends n copies of c to this string.
+       */
+      __versa_string&
+      append(size_type __n, _CharT __c)
+      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Append an initializer_list of characters.
+       *  @param __l  The initializer_list of characters to append.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      append(std::initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.end()); }
+#endif // C++11
+
+      /**
+       *  @brief  Append a range of characters.
+       *  @param __first  Iterator referencing the first character to append.
+       *  @param __last  Iterator marking the end of the range.
+       *  @return  Reference to this string.
+       *
+       *  Appends characters in the range [first,last) to this string.
+       */
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        __versa_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_iend(), _M_iend(), __first, __last); }
+
+      /**
+       *  @brief  Append a single character.
+       *  @param __c  Character to append.
+       */
+      void
+      push_back(_CharT __c)
+      { 
+	const size_type __size = this->size();
+	if (__size + 1 > this->capacity() || this->_M_is_shared())
+	  this->_M_mutate(__size, size_type(0), 0, size_type(1));
+	traits_type::assign(this->_M_data()[__size], __c);
+	this->_M_set_length(__size + 1);
+      }
+
+      /**
+       *  @brief  Set value to contents of another string.
+       *  @param  __str  Source string to use.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      assign(const __versa_string& __str)
+      {
+	this->_M_assign(__str);
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Set value to contents of another string.
+       *  @param  __str  Source string to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets this string to the exact contents of @a __str.
+       *  @a __str is a valid, but unspecified string.
+       */
+      __versa_string&
+      assign(__versa_string&& __str) noexcept
+      {
+	this->swap(__str);
+	return *this;
+      }
+#endif // C++11
+
+      /**
+       *  @brief  Set value to a substring of a string.
+       *  @param __str  The string to use.
+       *  @param __pos  Index of the first character of str.
+       *  @param __n  Number of characters to use.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range if @a __pos is not a valid index.
+       *
+       *  This function sets this string to the substring of @a __str
+       *  consisting of @a __n characters at @a __pos.  If @a __n is
+       *  is larger than the number of available characters in @a
+       *  __str, the remainder of @a __str is used.
+       */
+      __versa_string&
+      assign(const __versa_string& __str, size_type __pos, size_type __n)
+      { return _M_replace(size_type(0), this->size(), __str._M_data()
+			  + __str._M_check(__pos, "__versa_string::assign"),
+			  __str._M_limit(__pos, __n)); }
+
+      /**
+       *  @brief  Set value to a C substring.
+       *  @param __s  The C string to use.
+       *  @param __n  Number of characters to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets the value of this string to the first @a
+       *  __n characters of @a __s.  If @a __n is is larger than the
+       *  number of available characters in @a __s, the remainder of
+       *  @a __s is used.
+       */
+      __versa_string&
+      assign(const _CharT* __s, size_type __n)
+      {
+	__glibcxx_requires_string_len(__s, __n);
+	return _M_replace(size_type(0), this->size(), __s, __n);
+      }
+
+      /**
+       *  @brief  Set value to contents of a C string.
+       *  @param __s  The C string to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets the value of this string to the value of
+       *  @a __s.  The data is copied, so there is no dependence on @a
+       *  __s once the function returns.
+       */
+      __versa_string&
+      assign(const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return _M_replace(size_type(0), this->size(), __s,
+			  traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Set value to multiple characters.
+       *  @param __n  Length of the resulting string.
+       *  @param __c  The character to use.
+       *  @return  Reference to this string.
+       *
+       *  This function sets the value of this string to @a __n copies of
+       *  character @a __c.
+       */
+      __versa_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+
+      /**
+       *  @brief  Set value to a range of characters.
+       *  @param __first  Iterator referencing the first character to append.
+       *  @param __last  Iterator marking the end of the range.
+       *  @return  Reference to this string.
+       *
+       *  Sets value of string to characters in the range
+       *  [first,last).
+      */
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        __versa_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Set value to an initializer_list of characters.
+       *  @param __l  The initializer_list of characters to assign.
+       *  @return  Reference to this string.
+       */
+      __versa_string&
+      assign(std::initializer_list<_CharT> __l)
+      { return this->assign(__l.begin(), __l.end()); }
+#endif // C++11
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert multiple characters.
+       *  @param __p  Const_iterator referencing location in string to
+       *              insert at.
+       *  @param __n  Number of characters to insert
+       *  @param __c  The character to insert.
+       *  @return  Iterator referencing the first inserted char.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts @a __n copies of character @a __c starting at the
+       *  position referenced by iterator @a __p.  If adding
+       *  characters causes the length to exceed max_size(),
+       *  length_error is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      iterator
+      insert(const_iterator __p, size_type __n, _CharT __c)
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
+	const size_type __pos = __p - _M_ibegin();
+	this->replace(__p, __p, __n, __c);
+	return iterator(this->_M_data() + __pos); 
+      }
+#else
+      /**
+       *  @brief  Insert multiple characters.
+       *  @param __p  Iterator referencing location in string to insert at.
+       *  @param __n  Number of characters to insert
+       *  @param __c  The character to insert.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts @a __n copies of character @a __c starting at the
+       *  position referenced by iterator @a __p.  If adding
+       *  characters causes the length to exceed max_size(),
+       *  length_error is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      void
+      insert(iterator __p, size_type __n, _CharT __c)
+      {	this->replace(__p, __p, __n, __c);  }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert a range of characters.
+       *  @param __p  Const_iterator referencing location in string to
+       *              insert at.
+       *  @param __beg  Start of range.
+       *  @param __end  End of range.
+       *  @return  Iterator referencing the first inserted char.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts characters in range [beg,end).  If adding characters
+       *  causes the length to exceed max_size(), length_error is
+       *  thrown.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	iterator
+        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
+        {
+	  _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
+	  const size_type __pos = __p - _M_ibegin();
+	  this->replace(__p, __p, __beg, __end);
+	  return iterator(this->_M_data() + __pos);
+	}
+#else
+      /**
+       *  @brief  Insert a range of characters.
+       *  @param __p  Iterator referencing location in string to insert at.
+       *  @param __beg  Start of range.
+       *  @param __end  End of range.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts characters in range [beg,end).  If adding characters
+       *  causes the length to exceed max_size(), length_error is
+       *  thrown.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      template<class _InputIterator>
+        void
+        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
+        { this->replace(__p, __p, __beg, __end); }
+#endif
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Insert an initializer_list of characters.
+       *  @param __p  Const_iterator referencing location in string to
+       *              insert at.
+       *  @param __l  The initializer_list of characters to insert.
+       *  @return  Iterator referencing the first inserted char.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       */
+      iterator
+      insert(const_iterator __p, std::initializer_list<_CharT> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+#endif // C++11
+
+      /**
+       *  @brief  Insert value of a string.
+       *  @param __pos1  Iterator referencing location in string to insert at.
+       *  @param __str  The string to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts value of @a __str starting at @a __pos1.  If adding
+       *  characters causes the length to exceed max_size(),
+       *  length_error is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      __versa_string&
+      insert(size_type __pos1, const __versa_string& __str)
+      { return this->replace(__pos1, size_type(0),
+			     __str._M_data(), __str.size()); }
+
+      /**
+       *  @brief  Insert a substring.
+       *  @param __pos1  Iterator referencing location in string to insert at.
+       *  @param __str  The string to insert.
+       *  @param __pos2  Start of characters in str to insert.
+       *  @param __n  Number of characters to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a __pos1 > size() or
+       *  @a __pos2 > @a __str.size().
+       *
+       *  Starting at @a __pos1, insert @a __n character of @a __str
+       *  beginning with @a __pos2.  If adding characters causes the
+       *  length to exceed max_size(), length_error is thrown.  If @a
+       *  __pos1 is beyond the end of this string or @a __pos2 is
+       *  beyond the end of @a __str, out_of_range is thrown.  The
+       *  value of the string doesn't change if an error is thrown.
+      */
+      __versa_string&
+      insert(size_type __pos1, const __versa_string& __str,
+	     size_type __pos2, size_type __n)
+      { return this->replace(__pos1, size_type(0), __str._M_data()
+			     + __str._M_check(__pos2, "__versa_string::insert"),
+			     __str._M_limit(__pos2, __n)); }
+
+      /**
+       *  @brief  Insert a C substring.
+       *  @param __pos  Iterator referencing location in string to insert at.
+       *  @param __s  The C string to insert.
+       *  @param __n  The number of characters to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a __pos is beyond the end of this
+       *  string.
+       *
+       *  Inserts the first @a __n characters of @a __s starting at @a
+       *  __pos.  If adding characters causes the length to exceed
+       *  max_size(), length_error is thrown.  If @a __pos is beyond
+       *  end(), out_of_range is thrown.  The value of the string
+       *  doesn't change if an error is thrown.
+      */
+      __versa_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n)
+      { return this->replace(__pos, size_type(0), __s, __n); }
+
+      /**
+       *  @brief  Insert a C string.
+       *  @param __pos  Iterator referencing location in string to insert at.
+       *  @param __s  The C string to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a __pos is beyond the end of this
+       *  string.
+       *
+       *  Inserts the first @a __n characters of @a __s starting at @a
+       *  __pos.  If adding characters causes the length to exceed
+       *  max_size(), length_error is thrown.  If @a __pos is beyond
+       *  end(), out_of_range is thrown.  The value of the string
+       *  doesn't change if an error is thrown.
+      */
+      __versa_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return this->replace(__pos, size_type(0), __s,
+			     traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Insert multiple characters.
+       *  @param __pos  Index in string to insert at.
+       *  @param __n  Number of characters to insert
+       *  @param __c  The character to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *  @throw  std::out_of_range  If @a __pos is beyond the end of this
+       *  string.
+       *
+       *  Inserts @a __n copies of character @a __c starting at index
+       *  @a __pos.  If adding characters causes the length to exceed
+       *  max_size(), length_error is thrown.  If @a __pos > length(),
+       *  out_of_range is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      __versa_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "__versa_string::insert"),
+			      size_type(0), __n, __c); }
+
+      /**
+       *  @brief  Insert one character.
+       *  @param __p  Iterator referencing position in string to insert at.
+       *  @param __c  The character to insert.
+       *  @return  Iterator referencing newly inserted char.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Inserts character @a __c at position referenced by @a __p.
+       *  If adding character causes the length to exceed max_size(),
+       *  length_error is thrown.  If @a __p is beyond end of string,
+       *  out_of_range is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __p, _CharT __c)
+#else
+      insert(iterator __p, _CharT __c)	
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
+	const size_type __pos = __p - _M_ibegin();
+	_M_replace_aux(__pos, size_type(0), size_type(1), __c);
+	this->_M_set_leaked();
+	return iterator(this->_M_data() + __pos);
+      }
+
+      /**
+       *  @brief  Remove characters.
+       *  @param __pos  Index of first character to remove (default 0).
+       *  @param __n  Number of characters to remove (default remainder).
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos is beyond the end of this
+       *  string.
+       *
+       *  Removes @a __n characters from this string starting at @a
+       *  __pos.  The length of the string is reduced by @a __n.  If
+       *  there are < @a __n characters to remove, the remainder of
+       *  the string is truncated.  If @a __p is beyond end of string,
+       *  out_of_range is thrown.  The value of the string doesn't
+       *  change if an error is thrown.
+      */
+      __versa_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      { 
+	this->_M_erase(_M_check(__pos, "__versa_string::erase"),
+		       _M_limit(__pos, __n));
+	return *this;
+      }
+
+      /**
+       *  @brief  Remove one character.
+       *  @param __position  Iterator referencing the character to remove.
+       *  @return  iterator referencing same location after removal.
+       *
+       *  Removes the character at @a __position from this string. The
+       *  value of the string doesn't change if an error is thrown.
+      */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position)
+#else
+      erase(iterator __position)	
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
+				 && __position < _M_iend());
+	const size_type __pos = __position - _M_ibegin();
+	this->_M_erase(__pos, size_type(1));
+	this->_M_set_leaked();
+	return iterator(this->_M_data() + __pos);
+      }
+
+      /**
+       *  @brief  Remove a range of characters.
+       *  @param __first  Iterator referencing the first character to remove.
+       *  @param __last  Iterator referencing the end of the range.
+       *  @return  Iterator referencing location of first after removal.
+       *
+       *  Removes the characters in the range [first,last) from this
+       *  string.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last)
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
+				 && __last <= _M_iend());
+        const size_type __pos = __first - _M_ibegin();
+	this->_M_erase(__pos, __last - __first);
+	this->_M_set_leaked();
+	return iterator(this->_M_data() + __pos);
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Remove the last character.
+       *
+       *  The string must be non-empty.
+       */
+      void
+      pop_back()
+      { this->_M_erase(size()-1, 1); }
+#endif // C++11
+
+      /**
+       *  @brief  Replace characters with value from another string.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n  Number of characters to be replaced.
+       *  @param __str  String to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos is beyond the end of this
+       *  string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [pos,pos+n) from this
+       *  string.  In place, the value of @a __str is inserted.  If @a
+       *  __pos is beyond end of string, out_of_range is thrown.  If
+       *  the length of the result exceeds max_size(), length_error is
+       *  thrown.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      __versa_string&
+      replace(size_type __pos, size_type __n, const __versa_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+
+      /**
+       *  @brief  Replace characters with value from another string.
+       *  @param __pos1  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __str  String to insert.
+       *  @param __pos2  Index of first character of str to use.
+       *  @param __n2  Number of characters from str to use.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos1 > size() or @a __pos2 >
+       *  str.size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [pos1,pos1 + n) from
+       *  this string.  In place, the value of @a __str is inserted.
+       *  If @a __pos is beyond end of string, out_of_range is thrown.
+       *  If the length of the result exceeds max_size(), length_error
+       *  is thrown.  The value of the string doesn't change if an
+       *  error is thrown.
+      */
+      __versa_string&
+      replace(size_type __pos1, size_type __n1, const __versa_string& __str,
+	      size_type __pos2, size_type __n2)
+      {
+	return this->replace(__pos1, __n1, __str._M_data()
+			     + __str._M_check(__pos2,
+					      "__versa_string::replace"),
+			     __str._M_limit(__pos2, __n2));
+      }
+
+      /**
+       *  @brief  Replace characters with value of a C substring.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __s  C string to insert.
+       *  @param __n2  Number of characters from @a __s to use.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos1 > size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [pos,pos + n1) from this
+       *  string.  In place, the first @a __n2 characters of @a __s
+       *  are inserted, or all of @a __s if @a __n2 is too large.  If
+       *  @a __pos is beyond end of string, out_of_range is thrown.
+       *  If the length of result exceeds max_size(), length_error is
+       *  thrown.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      __versa_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+	      size_type __n2)
+      {
+	__glibcxx_requires_string_len(__s, __n2);
+	return _M_replace(_M_check(__pos, "__versa_string::replace"),
+			  _M_limit(__pos, __n1), __s, __n2);
+      }
+
+      /**
+       *  @brief  Replace characters with value of a C string.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __s  C string to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos > size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [pos,pos + n1) from this
+       *  string.  In place, the characters of @a __s are inserted.  If
+       *  @a pos is beyond end of string, out_of_range is thrown.  If
+       *  the length of result exceeds max_size(), length_error is thrown.  
+       *  The value of the string doesn't change if an error is thrown.
+      */
+      __versa_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+	__glibcxx_requires_string(__s);
+	return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Replace characters with multiple characters.
+       *  @param __pos  Index of first character to replace.
+       *  @param __n1  Number of characters to be replaced.
+       *  @param __n2  Number of characters to insert.
+       *  @param __c  Character to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::out_of_range  If @a __pos > size().
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [pos,pos + n1) from this
+       *  string.  In place, @a __n2 copies of @a __c are inserted.
+       *  If @a __pos is beyond end of string, out_of_range is thrown.
+       *  If the length of result exceeds max_size(), length_error is
+       *  thrown.  The value of the string doesn't change if an error
+       *  is thrown.
+      */
+      __versa_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "__versa_string::replace"),
+			      _M_limit(__pos, __n1), __n2, __c); }
+
+      /**
+       *  @brief  Replace range of characters with string.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __str  String value to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [i1,i2).  In place, the
+       *  value of @a __str is inserted.  If the length of result
+       *  exceeds max_size(), length_error is thrown.  The value of
+       *  the string doesn't change if an error is thrown.
+      */
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2,
+	      const __versa_string& __str)
+#else
+      replace(iterator __i1, iterator __i2, const __versa_string& __str)
+#endif
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+
+      /**
+       *  @brief  Replace range of characters with C substring.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __s  C string value to insert.
+       *  @param __n  Number of characters from s to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [i1,i2).  In place, the
+       *  first @a n characters of @a __s are inserted.  If the length
+       *  of result exceeds max_size(), length_error is thrown.  The
+       *  value of the string doesn't change if an error is thrown.
+      */
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2,
+	      const _CharT* __s, size_type __n)
+#else
+      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
+      }
+
+      /**
+       *  @brief  Replace range of characters with C string.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __s  C string value to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [i1,i2).  In place, the
+       *  characters of @a __s are inserted.  If the length of result
+       *  exceeds max_size(), length_error is thrown.  The value of
+       *  the string doesn't change if an error is thrown.
+      */
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2, const _CharT* __s)
+#else
+      replace(iterator __i1, iterator __i2, const _CharT* __s)	
+#endif
+      {
+	__glibcxx_requires_string(__s);
+	return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Replace range of characters with multiple characters
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __n  Number of characters to insert.
+       *  @param __c  Character to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [i1,i2).  In place, @a
+       *  __n copies of @a __c are inserted.  If the length of result
+       *  exceeds max_size(), length_error is thrown.  The value of
+       *  the string doesn't change if an error is thrown.
+      */
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2, size_type __n,
+	      _CharT __c)
+#else
+      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
+      }
+
+      /**
+       *  @brief  Replace range of characters with range.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __k1  Iterator referencing start of range to insert.
+       *  @param __k2  Iterator referencing end of range to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [i1,i2).  In place,
+       *  characters in the range [k1,k2) are inserted.  If the length
+       *  of result exceeds max_size(), length_error is thrown.  The
+       *  value of the string doesn't change if an error is thrown.
+      */
+#if __cplusplus >= 201103L
+      template<class _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        __versa_string&
+        replace(const_iterator __i1, const_iterator __i2,
+		_InputIterator __k1, _InputIterator __k2)
+        {
+	  _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				   && __i2 <= _M_iend());
+	  __glibcxx_requires_valid_range(__k1, __k2);
+	  return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
+					   std::__false_type());
+	}
+#else
+      template<class _InputIterator>
+        __versa_string&
+        replace(iterator __i1, iterator __i2,
+		_InputIterator __k1, _InputIterator __k2)
+        {
+	  _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				   && __i2 <= _M_iend());
+	  __glibcxx_requires_valid_range(__k1, __k2);
+	  typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+	  return this->_M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
+	}
+#endif
+
+      // Specializations for the common case of pointer and iterator:
+      // useful to avoid the overhead of temporary buffering in _M_replace.
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2,
+	      _CharT* __k1, _CharT* __k2)
+#else
+      replace(iterator __i1, iterator __i2,
+	      _CharT* __k1, _CharT* __k2)
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1, __k2 - __k1);
+      }
+
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2,
+	      const _CharT* __k1, const _CharT* __k2)
+#else
+      replace(iterator __i1, iterator __i2,
+	      const _CharT* __k1, const _CharT* __k2)
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1, __k2 - __k1);
+      }
+
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2,
+	      iterator __k1, iterator __k2)
+#else
+      replace(iterator __i1, iterator __i2,
+	      iterator __k1, iterator __k2)
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1.base(), __k2 - __k1);
+      }
+
+      __versa_string&
+#if __cplusplus >= 201103L
+      replace(const_iterator __i1, const_iterator __i2,
+	      const_iterator __k1, const_iterator __k2)
+#else
+      replace(iterator __i1, iterator __i2,
+	      const_iterator __k1, const_iterator __k2)
+#endif
+      {
+	_GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+				 && __i2 <= _M_iend());
+	__glibcxx_requires_valid_range(__k1, __k2);
+	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+			     __k1.base(), __k2 - __k1);
+      }
+      
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Replace range of characters with initializer_list.
+       *  @param __i1  Iterator referencing start of range to replace.
+       *  @param __i2  Iterator referencing end of range to replace.
+       *  @param __l  The initializer_list of characters to insert.
+       *  @return  Reference to this string.
+       *  @throw  std::length_error  If new length exceeds @c max_size().
+       *
+       *  Removes the characters in the range [i1,i2).  In place,
+       *  characters in the range [k1,k2) are inserted.  If the length
+       *  of result exceeds max_size(), length_error is thrown.  The
+       *  value of the string doesn't change if an error is thrown.
+      */
+      __versa_string&
+      replace(const_iterator __i1, const_iterator __i2,
+	      std::initializer_list<_CharT> __l)
+      { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
+#endif // C++11
+
+    private:
+      template<class _Integer>
+	__versa_string&
+	_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+			    _Integer __n, _Integer __val, std::__true_type)
+        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
+
+      template<class _InputIterator>
+	__versa_string&
+	_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+			    _InputIterator __k1, _InputIterator __k2,
+			    std::__false_type);
+
+      __versa_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+		     _CharT __c);
+
+      __versa_string&
+      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+		 const size_type __len2);
+
+      __versa_string&
+      _M_append(const _CharT* __s, size_type __n);
+
+    public:
+
+      /**
+       *  @brief  Copy substring into C string.
+       *  @param __s  C string to copy value into.
+       *  @param __n  Number of characters to copy.
+       *  @param __pos  Index of first character to copy.
+       *  @return  Number of characters actually copied
+       *  @throw  std::out_of_range  If pos > size().
+       *
+       *  Copies up to @a __n characters starting at @a __pos into the
+       *  C string @a s.  If @a __pos is greater than size(),
+       *  out_of_range is thrown.
+      */
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+
+      /**
+       *  @brief  Swap contents with another string.
+       *  @param __s  String to swap with.
+       *
+       *  Exchanges the contents of this string with that of @a __s in
+       *  constant time.
+      */
+      void
+      swap(__versa_string& __s) _GLIBCXX_NOEXCEPT
+      { this->_M_swap(__s); }
+
+      // String operations:
+      /**
+       *  @brief  Return const pointer to null-terminated contents.
+       *
+       *  This is a handle to internal data.  Do not modify or dire things may
+       *  happen.
+      */
+      const _CharT*
+      c_str() const _GLIBCXX_NOEXCEPT
+      { return this->_M_data(); }
+
+      /**
+       *  @brief  Return const pointer to contents.
+       *
+       *  This is a handle to internal data.  Do not modify or dire things may
+       *  happen.
+      */
+      const _CharT*
+      data() const _GLIBCXX_NOEXCEPT
+      { return this->_M_data(); }
+
+      /**
+       *  @brief  Return copy of allocator used to construct this string.
+      */
+      allocator_type
+      get_allocator() const _GLIBCXX_NOEXCEPT
+      { return allocator_type(this->_M_get_allocator()); }
+
+      /**
+       *  @brief  Find position of a C substring.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to search from.
+       *  @param __n  Number of characters from @a __s to search for.
+       *  @return  Index of start of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for the first @a
+       *  __n characters in @a __s within this string.  If found,
+       *  returns the index where it begins.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find position of a string.
+       *  @param __str  String to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of start of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for value of @a
+       *  __str within this string.  If found, returns the index where
+       *  it begins.  If not found, returns npos.
+      */
+      size_type
+      find(const __versa_string& __str, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find position of a C string.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of start of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for the value of @a
+       *  __s within this string.  If found, returns the index where
+       *  it begins.  If not found, returns npos.
+      */
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for @a __c within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Find last position of a string.
+       *  @param __str  String to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of start of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for value of @a
+       *  __str within this string.  If found, returns the index where
+       *  it begins.  If not found, returns npos.
+      */
+      size_type
+      rfind(const __versa_string& __str, size_type __pos = npos) const
+	_GLIBCXX_NOEXCEPT
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find last position of a C substring.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to search back from.
+       *  @param __n  Number of characters from s to search for.
+       *  @return  Index of start of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for the first @a
+       *  __n characters in @a __s within this string.  If found,
+       *  returns the index where it begins.  If not found, returns
+       *  npos.
+      */
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find last position of a C string.
+       *  @param __s  C string to locate.
+       *  @param __pos  Index of character to start search at (default end).
+       *  @return  Index of start of  last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for the value of
+       *  @a __s within this string.  If found, returns the index
+       *  where it begins.  If not found, returns npos.
+      */
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find last position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for @a __c within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Find position of a character of string.
+       *  @param __str  String containing characters to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for one of the characters of
+       *  @a __str within this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      find_first_of(const __versa_string& __str, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find position of a character of C substring.
+       *  @param __s  String containing characters to locate.
+       *  @param __pos  Index of character to search from.
+       *  @param __n  Number of characters from s to search for.
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for one of the
+       *  first @a __n characters of @a __s within this string.  If
+       *  found, returns the index where it was found.  If not found,
+       *  returns npos.
+      */
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find position of a character of C string.
+       *  @param __s  String containing characters to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for one of the
+       *  characters of @a __s within this string.  If found, returns
+       *  the index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for the character
+       *  @a __c within this string.  If found, returns the index
+       *  where it was found.  If not found, returns npos.
+       *
+       *  Note: equivalent to find(c, pos).
+      */
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
+      { return this->find(__c, __pos); }
+
+      /**
+       *  @brief  Find last position of a character of string.
+       *  @param __str  String containing characters to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for one of the
+       *  characters of @a __str within this string.  If found,
+       *  returns the index where it was found.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find_last_of(const __versa_string& __str, size_type __pos = npos) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find last position of a character of C substring.
+       *  @param __s  C string containing characters to locate.
+       *  @param __pos  Index of character to search back from.
+       *  @param __n  Number of characters from s to search for.
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for one of the
+       *  first @a __n characters of @a __s within this string.  If
+       *  found, returns the index where it was found.  If not found,
+       *  returns npos.
+      */
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+      /**
+       *  @brief  Find last position of a character of C string.
+       *  @param __s  C string containing characters to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for one of the
+       *  characters of @a __s within this string.  If found, returns
+       *  the index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find last position of a character.
+       *  @param __c  Character to locate.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for @a __c within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+       *
+       *  Note: equivalent to rfind(c, pos).
+      */
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
+      { return this->rfind(__c, __pos); }
+
+      /**
+       *  @brief  Find position of a character not in string.
+       *  @param __str  String containing characters to avoid.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character not
+       *  contained in @a __str within this string.  If found, returns
+       *  the index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(const __versa_string& __str, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find position of a character not in C substring.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search from.
+       *  @param __n  Number of characters from s to consider.
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character not
+       *  contained in the first @a __n characters of @a __s within
+       *  this string.  If found, returns the index where it was
+       *  found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+			size_type __n) const;
+
+      /**
+       *  @brief  Find position of a character not in C string.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character not
+       *  contained in @a __s within this string.  If found, returns
+       *  the index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find position of a different character.
+       *  @param __c  Character to avoid.
+       *  @param __pos  Index of character to search from (default 0).
+       *  @return  Index of first occurrence.
+       *
+       *  Starting from @a __pos, searches forward for a character
+       *  other than @a __c within this string.  If found, returns the
+       *  index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const
+	_GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Find last position of a character not in string.
+       *  @param __str  String containing characters to avoid.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character
+       *  not contained in @a __str within this string.  If found,
+       *  returns the index where it was found.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find_last_not_of(const __versa_string& __str,
+		       size_type __pos = npos) const _GLIBCXX_NOEXCEPT
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+
+      /**
+       *  @brief  Find last position of a character not in C substring.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search back from.
+       *  @param __n  Number of characters from s to consider.
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character
+       *  not contained in the first @a __n characters of @a __s
+       *  within this string.  If found, returns the index where it
+       *  was found.  If not found, returns npos.
+      */
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+		       size_type __n) const;
+      /**
+       *  @brief  Find last position of a character not in C string.
+       *  @param __s  C string containing characters to avoid.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character
+       *  not contained in @a __s within this string.  If found,
+       *  returns the index where it was found.  If not found, returns
+       *  npos.
+      */
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      {
+	__glibcxx_requires_string(__s);
+	return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+
+      /**
+       *  @brief  Find last position of a different character.
+       *  @param __c  Character to avoid.
+       *  @param __pos  Index of character to search back from (default end).
+       *  @return  Index of last occurrence.
+       *
+       *  Starting from @a __pos, searches backward for a character
+       *  other than @a __c within this string.  If found, returns the
+       *  index where it was found.  If not found, returns npos.
+      */
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const
+	_GLIBCXX_NOEXCEPT;
+
+      /**
+       *  @brief  Get a substring.
+       *  @param __pos  Index of first character (default 0).
+       *  @param __n  Number of characters in substring (default remainder).
+       *  @return  The new string.
+       *  @throw  std::out_of_range  If pos > size().
+       *
+       *  Construct and return a new string using the @a __n
+       *  characters starting at @a __pos.  If the string is too
+       *  short, use the remainder of the characters.  If @a __pos is
+       *  beyond the end of the string, out_of_range is thrown.
+      */
+      __versa_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      {
+	return __versa_string(*this, _M_check(__pos, "__versa_string::substr"),
+			      __n);
+      }
+
+      /**
+       *  @brief  Compare to a string.
+       *  @param __str  String to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Returns an integer < 0 if this string is ordered before @a
+       *  __str, 0 if their values are equivalent, or > 0 if this
+       *  string is ordered after @a __str.  Determines the effective
+       *  length rlen of the strings to compare as the smallest of
+       *  size() and str.size().  The function then compares the two
+       *  strings by calling traits::compare(data(), str.data(),rlen).
+       *  If the result of the comparison is nonzero returns it,
+       *  otherwise the shorter one is ordered first.
+      */
+      int
+      compare(const __versa_string& __str) const
+      {
+	if (this->_M_compare(__str))
+	  return 0;
+
+	const size_type __size = this->size();
+	const size_type __osize = __str.size();
+	const size_type __len = std::min(__size, __osize);
+
+	int __r = traits_type::compare(this->_M_data(), __str.data(), __len);
+	if (!__r)
+	  __r = this->_S_compare(__size, __osize);
+	return __r;
+      }
+
+      /**
+       *  @brief  Compare substring to a string.
+       *  @param __pos  Index of first character of substring.
+       *  @param __n  Number of characters in substring.
+       *  @param __str  String to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n characters
+       *  starting at @a __pos.  Returns an integer < 0 if the
+       *  substring is ordered before @a __str, 0 if their values are
+       *  equivalent, or > 0 if the substring is ordered after @a
+       *  __str.  Determines the effective length rlen of the strings
+       *  to compare as the smallest of the length of the substring
+       *  and @a __str.size().  The function then compares the two
+       *  strings by calling
+       *  traits::compare(substring.data(),str.data(),rlen).  If the
+       *  result of the comparison is nonzero returns it, otherwise
+       *  the shorter one is ordered first.
+      */
+      int
+      compare(size_type __pos, size_type __n,
+	      const __versa_string& __str) const;
+
+      /**
+       *  @brief  Compare substring to a substring.
+       *  @param __pos1  Index of first character of substring.
+       *  @param __n1  Number of characters in substring.
+       *  @param __str  String to compare against.
+       *  @param __pos2  Index of first character of substring of str.
+       *  @param __n2  Number of characters in substring of str.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n1
+       *  characters starting at @a __pos1.  Form the substring of @a
+       *  __str from the @a __n2 characters starting at @a __pos2.
+       *  Returns an integer < 0 if this substring is ordered before
+       *  the substring of @a __str, 0 if their values are equivalent,
+       *  or > 0 if this substring is ordered after the substring of
+       *  @a __str.  Determines the effective length rlen of the
+       *  strings to compare as the smallest of the lengths of the
+       *  substrings.  The function then compares the two strings by
+       *  calling
+       *  traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
+       *  If the result of the comparison is nonzero returns it,
+       *  otherwise the shorter one is ordered first.
+      */
+      int
+      compare(size_type __pos1, size_type __n1, const __versa_string& __str,
+	      size_type __pos2, size_type __n2) const;
+
+      /**
+       *  @brief  Compare to a C string.
+       *  @param __s  C string to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Returns an integer < 0 if this string is ordered before @a
+       *  __s, 0 if their values are equivalent, or > 0 if this string
+       *  is ordered after @a __s.  Determines the effective length
+       *  rlen of the strings to compare as the smallest of size() and
+       *  the length of a string constructed from @a __s.  The
+       *  function then compares the two strings by calling
+       *  traits::compare(data(),s,rlen).  If the result of the
+       *  comparison is nonzero returns it, otherwise the shorter one
+       *  is ordered first.
+      */
+      int
+      compare(const _CharT* __s) const;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 5 String::compare specification questionable
+      /**
+       *  @brief  Compare substring to a C string.
+       *  @param __pos  Index of first character of substring.
+       *  @param __n1  Number of characters in substring.
+       *  @param __s  C string to compare against.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n1
+       *  characters starting at @a __pos.  Returns an integer < 0 if
+       *  the substring is ordered before @a __s, 0 if their values
+       *  are equivalent, or > 0 if the substring is ordered after @a
+       *  __s.  Determines the effective length rlen of the strings to
+       *  compare as the smallest of the length of the substring and
+       *  the length of a string constructed from @a __s.  The
+       *  function then compares the two string by calling
+       *  traits::compare(substring.data(),s,rlen).  If the result of
+       *  the comparison is nonzero returns it, otherwise the shorter
+       *  one is ordered first.
+      */
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+
+      /**
+       *  @brief  Compare substring against a character array.
+       *  @param __pos  Index of first character of substring.
+       *  @param __n1  Number of characters in substring.
+       *  @param __s  character array to compare against.
+       *  @param __n2  Number of characters of s.
+       *  @return  Integer < 0, 0, or > 0.
+       *
+       *  Form the substring of this string from the @a __n1
+       *  characters starting at @a __pos.  Form a string from the
+       *  first @a __n2 characters of @a __s.  Returns an integer < 0
+       *  if this substring is ordered before the string from @a __s,
+       *  0 if their values are equivalent, or > 0 if this substring
+       *  is ordered after the string from @a __s.  Determines the
+       *  effective length rlen of the strings to compare as the
+       *  smallest of the length of the substring and @a __n2.  The
+       *  function then compares the two strings by calling
+       *  traits::compare(substring.data(),__s,rlen).  If the result of
+       *  the comparison is nonzero returns it, otherwise the shorter
+       *  one is ordered first.
+       *
+       *  NB: __s must have at least n2 characters, <em>\\0</em> has no special
+       *  meaning.
+      */
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+	      size_type __n2) const;
+    };
+
+  // operator+
+  /**
+   *  @brief  Concatenate two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with value of @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
+
+  /**
+   *  @brief  Concatenate C string and string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with value of @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const _CharT* __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
+
+  /**
+   *  @brief  Concatenate character and string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(_CharT __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
+
+  /**
+   *  @brief  Concatenate string and C string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const _CharT* __rhs);
+
+  /**
+   *  @brief  Concatenate string and character.
+   *  @param __lhs  First string.
+   *  @param __rhs  Last string.
+   *  @return  New string with @a __lhs followed by @a __rhs.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      _CharT __rhs);
+
+#if __cplusplus >= 201103L
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(__versa_string<_CharT, _Traits, _Alloc, _Base>&& __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      __versa_string<_CharT, _Traits, _Alloc, _Base>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(__versa_string<_CharT, _Traits, _Alloc, _Base>&& __lhs,
+	      __versa_string<_CharT, _Traits, _Alloc, _Base>&& __rhs)
+    {
+      const auto __size = __lhs.size() + __rhs.size();
+      const bool __cond = (__size > __lhs.capacity()
+			   && __size <= __rhs.capacity());
+      return __cond ? std::move(__rhs.insert(0, __lhs))
+	            : std::move(__lhs.append(__rhs));
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const _CharT* __lhs,
+	      __versa_string<_CharT, _Traits, _Alloc, _Base>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(_CharT __lhs,
+	      __versa_string<_CharT, _Traits, _Alloc, _Base>&& __rhs)
+    { return std::move(__rhs.insert(0, 1, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(__versa_string<_CharT, _Traits, _Alloc, _Base>&& __lhs,
+	      const _CharT* __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(__versa_string<_CharT, _Traits, _Alloc, _Base>&& __lhs,
+	      _CharT __rhs)
+    { return std::move(__lhs.append(1, __rhs)); }
+#endif
+
+  // operator ==
+  /**
+   *  @brief  Test equivalence of two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator==(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  template<typename _CharT,
+	   template <typename, typename, typename> class _Base>
+    inline typename __enable_if<std::__is_char<_CharT>::__value, bool>::__type
+    operator==(const __versa_string<_CharT, std::char_traits<_CharT>,
+	       std::allocator<_CharT>, _Base>& __lhs,
+	       const __versa_string<_CharT, std::char_traits<_CharT>,
+	       std::allocator<_CharT>, _Base>& __rhs)
+    { return (__lhs.size() == __rhs.size()
+	      && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+						    __lhs.size())); }
+
+  /**
+   *  @brief  Test equivalence of C string and string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __rhs.compare(@a __lhs) == 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator==(const _CharT* __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+
+  /**
+   *  @brief  Test equivalence of string and C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator==(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  // operator !=
+  /**
+   *  @brief  Test difference of two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs.compare(@a __rhs) != 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator!=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   *  @brief  Test difference of C string and string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __rhs.compare(@a __lhs) != 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator!=(const _CharT* __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  /**
+   *  @brief  Test difference of string and C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs.compare(@a __rhs) != 0.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator!=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+
+  // operator <
+  /**
+   *  @brief  Test if string precedes string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator<(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   *  @brief  Test if string precedes C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator<(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   *  @brief  Test if C string precedes string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator<(const _CharT* __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+
+  // operator >
+  /**
+   *  @brief  Test if string follows string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator>(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+  /**
+   *  @brief  Test if string follows C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator>(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+  /**
+   *  @brief  Test if C string follows string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator>(const _CharT* __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+
+  // operator <=
+  /**
+   *  @brief  Test if string doesn't follow string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator<=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+  /**
+   *  @brief  Test if string doesn't follow C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator<=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+  /**
+   *  @brief  Test if C string doesn't follow string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator<=(const _CharT* __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+
+  // operator >=
+  /**
+   *  @brief  Test if string doesn't precede string.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator>=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+  /**
+   *  @brief  Test if string doesn't precede C string.
+   *  @param __lhs  String.
+   *  @param __rhs  C string.
+   *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator>=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+  /**
+   *  @brief  Test if C string doesn't precede string.
+   *  @param __lhs  C string.
+   *  @param __rhs  String.
+   *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline bool
+    operator>=(const _CharT* __lhs,
+	       const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+
+  /**
+   *  @brief  Swap contents of two strings.
+   *  @param __lhs  First string.
+   *  @param __rhs  Second string.
+   *
+   *  Exchanges the contents of @a __lhs and @a __rhs in constant time.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline void
+    swap(__versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	 __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    { __lhs.swap(__rhs); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Read stream into a string.
+   *  @param __is  Input stream.
+   *  @param __str  Buffer to store into.
+   *  @return  Reference to the input stream.
+   *
+   *  Stores characters from @a __is into @a __str until whitespace is
+   *  found, the end of the stream is encountered, or str.max_size()
+   *  is reached.  If is.width() is non-zero, that is the limit on the
+   *  number of characters stored into @a __str.  Any previous
+   *  contents of @a __str are erased.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+           template <typename, typename, typename> class _Base>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+	       __gnu_cxx::__versa_string<_CharT, _Traits,
+	                                 _Alloc, _Base>& __str);
+
+  /**
+   *  @brief  Write string to a stream.
+   *  @param __os  Output stream.
+   *  @param __str  String to write out.
+   *  @return  Reference to the output stream.
+   *
+   *  Output characters of @a __str into os following the same rules as for
+   *  writing a C string.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+	       const __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc,
+	       _Base>& __str)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 586. string inserter not a formatted function
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+
+  /**
+   *  @brief  Read a line from stream into a string.
+   *  @param __is  Input stream.
+   *  @param __str  Buffer to store into.
+   *  @param __delim  Character marking end of line.
+   *  @return  Reference to the input stream.
+   *
+   *  Stores characters from @a __is into @a __str until @a __delim is
+   *  found, the end of the stream is encountered, or str.max_size()
+   *  is reached.  If is.width() is non-zero, that is the limit on the
+   *  number of characters stored into @a __str.  Any previous
+   *  contents of @a __str are erased.  If @a delim was encountered,
+   *  it is extracted but not stored into @a __str.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+           template <typename, typename, typename> class _Base>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+	    __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str,
+	    _CharT __delim);
+
+  /**
+   *  @brief  Read a line from stream into a string.
+   *  @param __is  Input stream.
+   *  @param __str  Buffer to store into.
+   *  @return  Reference to the input stream.
+   *
+   *  Stores characters from is into @a __str until &apos;\n&apos; is
+   *  found, the end of the stream is encountered, or str.max_size()
+   *  is reached.  If is.width() is non-zero, that is the limit on the
+   *  number of characters stored into @a __str.  Any previous
+   *  contents of @a __str are erased.  If end of line was
+   *  encountered, it is extracted but not stored into @a __str.
+   */
+  template<typename _CharT, typename _Traits, typename _Alloc,
+           template <typename, typename, typename> class _Base>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+	    __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str)
+    { return getline(__is, __str, __is.widen('\n')); }      
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if ((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99))
+
+#include <ext/string_conversions.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 21.4 Numeric Conversions [string.conversions].
+  inline int
+  stoi(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
+					__idx, __base); }
+
+  inline long
+  stol(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long
+  stoul(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
+			     __idx, __base); }
+
+  inline long long
+  stoll(const __vstring& __str, std::size_t* __idx = 0,	int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long long
+  stoull(const __vstring& __str, std::size_t* __idx, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
+			     __idx, __base); }
+
+  // NB: strtof vs strtod.
+  inline float
+  stof(const __vstring& __str, std::size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const __vstring& __str, std::size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const __vstring& __str, std::size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
+
+  // NB: (v)snprintf vs sprintf.
+
+  // DR 1261.
+  inline __vstring
+  to_string(int __val)
+  { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, 4 * sizeof(int),
+					      "%d", __val); }
+
+  inline __vstring
+  to_string(unsigned __val)
+  { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
+					      4 * sizeof(unsigned),
+					      "%u", __val); }
+
+  inline __vstring
+  to_string(long __val)
+  { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
+					      4 * sizeof(long),
+					      "%ld", __val); }
+
+  inline __vstring
+  to_string(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
+					      4 * sizeof(unsigned long),
+					      "%lu", __val); }
+
+
+  inline __vstring
+  to_string(long long __val)
+  { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
+					      4 * sizeof(long long),
+					      "%lld", __val); }
+
+  inline __vstring
+  to_string(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
+					      4 * sizeof(unsigned long long),
+					      "%llu", __val); }
+
+  inline __vstring
+  to_string(float __val)
+  {
+    const int __n = __numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
+					      "%f", __val);
+  }
+
+  inline __vstring
+  to_string(double __val)
+  {
+    const int __n = __numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
+					      "%f", __val);
+  }
+
+  inline __vstring
+  to_string(long double __val)
+  {
+    const int __n = __numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
+					      "%Lf", __val);
+  }
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  inline int 
+  stoi(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
+					__idx, __base); }
+
+  inline long 
+  stol(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long
+  stoul(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
+			     __idx, __base); }
+
+  inline long long
+  stoll(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
+			     __idx, __base); }
+
+  inline unsigned long long
+  stoull(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
+			     __idx, __base); }
+
+  // NB: wcstof vs wcstod.
+  inline float
+  stof(const __wvstring& __str, std::size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const __wvstring& __str, std::size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const __wvstring& __str, std::size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
+
+#ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
+  // DR 1261.
+  inline __wvstring
+  to_wstring(int __val)
+  { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
+					       4 * sizeof(int),
+					       L"%d", __val); }
+
+  inline __wvstring
+  to_wstring(unsigned __val)
+  { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
+					       4 * sizeof(unsigned),
+					       L"%u", __val); }
+
+  inline __wvstring
+  to_wstring(long __val)
+  { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
+					       4 * sizeof(long),
+					       L"%ld", __val); }
+
+  inline __wvstring
+  to_wstring(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
+					       4 * sizeof(unsigned long),
+					       L"%lu", __val); }
+
+  inline __wvstring
+  to_wstring(long long __val)
+  { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
+					       4 * sizeof(long long),
+					       L"%lld", __val); }
+
+  inline __wvstring
+  to_wstring(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
+					       4 * sizeof(unsigned long long),
+					       L"%llu", __val); }
+
+  inline __wvstring
+  to_wstring(float __val)
+  {
+    const int __n = __numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
+					       L"%f", __val);
+  }
+
+  inline __wvstring
+  to_wstring(double __val)
+  {
+    const int __n = __numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
+					       L"%f", __val);
+  }
+
+  inline __wvstring
+  to_wstring(long double __val)
+  {
+    const int __n = __numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
+					       L"%Lf", __val);
+  }
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
+
+#if __cplusplus >= 201103L
+
+#include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// std::hash specialization for __vstring.
+  template<>
+    struct hash<__gnu_cxx::__vstring>
+    : public __hash_base<size_t, __gnu_cxx::__vstring>
+    {
+      size_t
+      operator()(const __gnu_cxx::__vstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
+    };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /// std::hash specialization for __wvstring.
+  template<>
+    struct hash<__gnu_cxx::__wvstring>
+    : public __hash_base<size_t, __gnu_cxx::__wvstring>
+    {
+      size_t
+      operator()(const __gnu_cxx::__wvstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+#endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+  /// std::hash specialization for __u16vstring.
+  template<>
+    struct hash<__gnu_cxx::__u16vstring>
+    : public __hash_base<size_t, __gnu_cxx::__u16vstring>
+    {
+      size_t
+      operator()(const __gnu_cxx::__u16vstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+
+  /// std::hash specialization for __u32vstring.
+  template<>
+    struct hash<__gnu_cxx::__u32vstring>
+    : public __hash_base<size_t, __gnu_cxx::__u32vstring>
+    {
+      size_t
+      operator()(const __gnu_cxx::__u32vstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // C++11
+
+#include "vstring.tcc" 
+
+#endif /* _VSTRING_H */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/vstring.tcc b/gcc-4.9/libstdc++-v3/include/ext/vstring.tcc
new file mode 100644
index 0000000..ebc610d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/vstring.tcc
@@ -0,0 +1,702 @@
+// Versatile string -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/vstring.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/vstring.h}
+ */
+
+#ifndef _VSTRING_TCC
+#define _VSTRING_TCC 1
+
+#pragma GCC system_header
+
+#include <bits/cxxabi_forced.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    const typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::npos;
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    void
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      if (__size < __n)
+	this->append(__n - __size, __c);
+      else if (__n < __size)
+	this->_M_erase(__n, __size - __n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>&
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    _M_append(const _CharT* __s, size_type __n)
+    {
+      const size_type __len = __n + this->size();
+
+      if (__len <= this->capacity() && !this->_M_is_shared())
+	{
+	  if (__n)
+	    this->_S_copy(this->_M_data() + this->size(), __s, __n);
+	}
+      else
+	this->_M_mutate(this->size(), size_type(0), __s, __n);
+
+      this->_M_set_length(__len);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    template<typename _InputIterator>
+      __versa_string<_CharT, _Traits, _Alloc, _Base>&
+      __versa_string<_CharT, _Traits, _Alloc, _Base>::
+      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+			  _InputIterator __k1, _InputIterator __k2,
+			  std::__false_type)
+      {
+	const __versa_string __s(__k1, __k2);
+	const size_type __n1 = __i2 - __i1;
+	return _M_replace(__i1 - _M_ibegin(), __n1, __s._M_data(),
+			  __s.size());
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>&
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+		   _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "__versa_string::_M_replace_aux");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __n2 - __n1;
+
+      if (__new_size <= this->capacity() && !this->_M_is_shared())
+	{
+	  _CharT* __p = this->_M_data() + __pos1;
+
+	  const size_type __how_much = __old_size - __pos1 - __n1;
+	  if (__how_much && __n1 != __n2)
+	    this->_S_move(__p + __n2, __p + __n1, __how_much);
+	}
+      else
+	this->_M_mutate(__pos1, __n1, 0, __n2);
+
+      if (__n2)
+	this->_S_assign(this->_M_data() + __pos1, __n2, __c);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>&
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+	       const size_type __len2)
+    {
+      _M_check_length(__len1, __len2, "__versa_string::_M_replace");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+      
+      if (__new_size <= this->capacity() && !this->_M_is_shared())
+	{
+	  _CharT* __p = this->_M_data() + __pos;
+
+	  const size_type __how_much = __old_size - __pos - __len1;
+	  if (_M_disjunct(__s))
+	    {
+	      if (__how_much && __len1 != __len2)
+		this->_S_move(__p + __len2, __p + __len1, __how_much);
+	      if (__len2)
+		this->_S_copy(__p, __s, __len2);
+	    }
+	  else
+	    {
+	      // Work in-place.
+	      if (__len2 && __len2 <= __len1)
+		this->_S_move(__p, __s, __len2);
+	      if (__how_much && __len1 != __len2)
+		this->_S_move(__p + __len2, __p + __len1, __how_much);
+	      if (__len2 > __len1)
+		{
+		  if (__s + __len2 <= __p + __len1)
+		    this->_S_move(__p, __s, __len2);
+		  else if (__s >= __p + __len1)
+		    this->_S_copy(__p, __s + __len2 - __len1, __len2);
+		  else
+		    {
+		      const size_type __nleft = (__p + __len1) - __s;
+		      this->_S_move(__p, __s, __nleft);
+		      this->_S_copy(__p + __nleft, __p + __len2,
+				    __len2 - __nleft);
+		    }
+		}
+	    }
+	}
+      else
+	this->_M_mutate(__pos, __len1, __s, __len2);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+  
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    {
+      __versa_string<_CharT, _Traits, _Alloc, _Base> __str;
+      __str.reserve(__lhs.size() + __rhs.size());
+      __str.append(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const _CharT* __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    {
+      __glibcxx_requires_string(__lhs);
+      typedef __versa_string<_CharT, _Traits, _Alloc, _Base> __string_type;
+      typedef typename __string_type::size_type	  __size_type;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str;
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(_CharT __lhs,
+	      const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
+    {
+      __versa_string<_CharT, _Traits, _Alloc, _Base> __str;
+      __str.reserve(__rhs.size() + 1);
+      __str.push_back(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      const _CharT* __rhs)
+    {
+      __glibcxx_requires_string(__rhs);
+      typedef __versa_string<_CharT, _Traits, _Alloc, _Base> __string_type;
+      typedef typename __string_type::size_type	  __size_type;
+      const __size_type __len = _Traits::length(__rhs);
+      __string_type __str;
+      __str.reserve(__lhs.size() + __len);
+      __str.append(__lhs);
+      __str.append(__rhs, __len);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    __versa_string<_CharT, _Traits, _Alloc, _Base>
+    operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
+	      _CharT __rhs)
+    {
+      __versa_string<_CharT, _Traits, _Alloc, _Base> __str;
+      __str.reserve(__lhs.size() + 1);
+      __str.append(__lhs);
+      __str.push_back(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "__versa_string::copy");
+      __n = _M_limit(__pos, __n);
+      __glibcxx_requires_string_len(__s, __n);
+      if (__n)
+	this->_S_copy(__s, this->_M_data() + __pos, __n);
+      // 21.3.5.7 par 3: do not append null.  (good.)
+      return __n;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      const size_type __size = this->size();
+      const _CharT* __data = this->_M_data();
+
+      if (__n == 0)
+	return __pos <= __size ? __pos : npos;
+
+      if (__n <= __size)
+	{
+	  for (; __pos <= __size - __n; ++__pos)
+	    if (traits_type::eq(__data[__pos], __s[0])
+		&& traits_type::compare(__data + __pos + 1,
+					__s + 1, __n - 1) == 0)
+	      return __pos;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      size_type __ret = npos;
+      const size_type __size = this->size();
+      if (__pos < __size)
+	{
+	  const _CharT* __data = this->_M_data();
+	  const size_type __n = __size - __pos;
+	  const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
+	  if (__p)
+	    __ret = __p - __data;
+	}
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      const size_type __size = this->size();
+      if (__n <= __size)
+	{
+	  __pos = std::min(size_type(__size - __n), __pos);
+	  const _CharT* __data = this->_M_data();
+	  do
+	    {
+	      if (traits_type::compare(__data + __pos, __s, __n) == 0)
+		return __pos;
+	    }
+	  while (__pos-- > 0);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    rfind(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      size_type __size = this->size();
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  for (++__size; __size-- > 0; )
+	    if (traits_type::eq(this->_M_data()[__size], __c))
+	      return __size;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      for (; __n && __pos < this->size(); ++__pos)
+	{
+	  const _CharT* __p = traits_type::find(__s, __n,
+						this->_M_data()[__pos]);
+	  if (__p)
+	    return __pos;
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      size_type __size = this->size();
+      if (__size && __n)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (traits_type::find(__s, __n, this->_M_data()[__size]))
+		return __size;
+	    }
+	  while (__size-- != 0);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      for (; __pos < this->size(); ++__pos)
+	if (!traits_type::find(__s, __n, this->_M_data()[__pos]))
+	  return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find_first_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      for (; __pos < this->size(); ++__pos)
+	if (!traits_type::eq(this->_M_data()[__pos], __c))
+	  return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      size_type __size = this->size();
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (!traits_type::find(__s, __n, this->_M_data()[__size]))
+		return __size;
+	    }
+	  while (__size--);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    typename __versa_string<_CharT, _Traits, _Alloc, _Base>::size_type
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    find_last_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
+    {
+      size_type __size = this->size();
+      if (__size)
+	{
+	  if (--__size > __pos)
+	    __size = __pos;
+	  do
+	    {
+	      if (!traits_type::eq(this->_M_data()[__size], __c))
+		return __size;
+	    }
+	  while (__size--);
+	}
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    int
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    compare(size_type __pos, size_type __n, const __versa_string& __str) const
+    {
+      _M_check(__pos, "__versa_string::compare");
+      __n = _M_limit(__pos, __n);
+      const size_type __osize = __str.size();
+      const size_type __len = std::min(__n, __osize);
+      int __r = traits_type::compare(this->_M_data() + __pos,
+				     __str.data(), __len);
+      if (!__r)
+	__r = this->_S_compare(__n, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    int
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    compare(size_type __pos1, size_type __n1, const __versa_string& __str,
+	    size_type __pos2, size_type __n2) const
+    {
+      _M_check(__pos1, "__versa_string::compare");
+      __str._M_check(__pos2, "__versa_string::compare");
+      __n1 = _M_limit(__pos1, __n1);
+      __n2 = __str._M_limit(__pos2, __n2);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(this->_M_data() + __pos1,
+				     __str.data() + __pos2, __len);
+      if (!__r)
+	__r = this->_S_compare(__n1, __n2);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    int
+    __versa_string<_CharT, _Traits, _Alloc, _Base>::
+    compare(const _CharT* __s) const
+    {
+      __glibcxx_requires_string(__s);
+      const size_type __size = this->size();
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__size, __osize);
+      int __r = traits_type::compare(this->_M_data(), __s, __len);
+      if (!__r)
+	__r = this->_S_compare(__size, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    int
+    __versa_string <_CharT, _Traits, _Alloc, _Base>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s) const
+    {
+      __glibcxx_requires_string(__s);
+      _M_check(__pos, "__versa_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__n1, __osize);
+      int __r = traits_type::compare(this->_M_data() + __pos, __s, __len);
+      if (!__r)
+	__r = this->_S_compare(__n1, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+	   template <typename, typename, typename> class _Base>
+    int
+    __versa_string <_CharT, _Traits, _Alloc, _Base>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
+	    size_type __n2) const
+    {
+      __glibcxx_requires_string_len(__s, __n2);
+      _M_check(__pos, "__versa_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(this->_M_data() + __pos, __s, __len);
+      if (!__r)
+	__r = this->_S_compare(__n1, __n2);
+      return __r;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+           template <typename, typename, typename> class _Base>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in,
+	       __gnu_cxx::__versa_string<_CharT, _Traits,
+	                                 _Alloc, _Base>& __str)
+    {
+      typedef basic_istream<_CharT, _Traits>            __istream_type;
+      typedef typename __istream_type::ios_base         __ios_base;
+      typedef __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>
+	                                                __string_type;
+      typedef typename __istream_type::int_type		__int_type;
+      typedef typename __string_type::size_type		__size_type;
+      typedef ctype<_CharT>				__ctype_type;
+      typedef typename __ctype_type::ctype_base         __ctype_base;
+
+      __size_type __extracted = 0;
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      // Avoid reallocation for common case.
+	      __str.erase();
+	      _CharT __buf[128];
+	      __size_type __len = 0;
+	      const streamsize __w = __in.width();
+	      const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
+		                              : __str.max_size();
+	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+	      const __int_type __eof = _Traits::eof();
+	      __int_type __c = __in.rdbuf()->sgetc();
+
+	      while (__extracted < __n
+		     && !_Traits::eq_int_type(__c, __eof)
+		     && !__ct.is(__ctype_base::space,
+				 _Traits::to_char_type(__c)))
+		{
+		  if (__len == sizeof(__buf) / sizeof(_CharT))
+		    {
+		      __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+		      __len = 0;
+		    }
+		  __buf[__len++] = _Traits::to_char_type(__c);
+		  ++__extracted;
+		  __c = __in.rdbuf()->snextc();
+		}
+	      __str.append(__buf, __len);
+
+	      if (_Traits::eq_int_type(__c, __eof))
+		__err |= __ios_base::eofbit;
+	      __in.width(0);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __in._M_setstate(__ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 91. Description of operator>> and getline() for string<>
+	      // might cause endless loop
+	      __in._M_setstate(__ios_base::badbit);
+	    }
+	}
+      // 211.  operator>>(istream&, string&) doesn't set failbit
+      if (!__extracted)
+	__err |= __ios_base::failbit;
+      if (__err)
+	__in.setstate(__err);
+      return __in;
+    }      
+
+  template<typename _CharT, typename _Traits, typename _Alloc,
+           template <typename, typename, typename> class _Base>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __in,
+	    __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str,
+	    _CharT __delim)
+    {
+      typedef basic_istream<_CharT, _Traits>	        __istream_type;
+      typedef typename __istream_type::ios_base         __ios_base;
+      typedef __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>
+	                                                __string_type;
+      typedef typename __istream_type::int_type		__int_type;
+      typedef typename __string_type::size_type		__size_type;
+
+      __size_type __extracted = 0;
+      const __size_type __n = __str.max_size();
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, true);
+      if (__cerb)
+	{
+	  __try
+	    {
+	      // Avoid reallocation for common case.
+	      __str.erase();
+	      _CharT __buf[128];
+	      __size_type __len = 0;
+	      const __int_type __idelim = _Traits::to_int_type(__delim);
+	      const __int_type __eof = _Traits::eof();
+	      __int_type __c = __in.rdbuf()->sgetc();
+
+	      while (__extracted < __n
+		     && !_Traits::eq_int_type(__c, __eof)
+		     && !_Traits::eq_int_type(__c, __idelim))
+		{
+		  if (__len == sizeof(__buf) / sizeof(_CharT))
+		    {
+		      __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+		      __len = 0;
+		    }
+		  __buf[__len++] = _Traits::to_char_type(__c);
+		  ++__extracted;
+		  __c = __in.rdbuf()->snextc();
+		}
+	      __str.append(__buf, __len);
+
+	      if (_Traits::eq_int_type(__c, __eof))
+		__err |= __ios_base::eofbit;
+	      else if (_Traits::eq_int_type(__c, __idelim))
+		{
+		  ++__extracted;		  
+		  __in.rdbuf()->sbumpc();
+		}
+	      else
+		__err |= __ios_base::failbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __in._M_setstate(__ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 91. Description of operator>> and getline() for string<>
+	      // might cause endless loop
+	      __in._M_setstate(__ios_base::badbit);
+	    }
+	}
+      if (!__extracted)
+	__err |= __ios_base::failbit;
+      if (__err)
+	__in.setstate(__err);
+      return __in;
+    }      
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _VSTRING_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/ext/vstring_fwd.h b/gcc-4.9/libstdc++-v3/include/ext/vstring_fwd.h
new file mode 100644
index 0000000..666a51e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/vstring_fwd.h
@@ -0,0 +1,89 @@
+// <vstring.h> Forward declarations -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/vstring_fwd.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/vstring.h}
+ */
+
+#ifndef _VSTRING_FWD_H
+#define _VSTRING_FWD_H 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/char_traits.h>
+#include <bits/allocator.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class __sso_string_base;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class __rc_string_base;
+
+  template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
+           typename _Alloc = std::allocator<_CharT>,
+	   template
+	   <typename, typename, typename> class _Base = __sso_string_base>
+    class __versa_string;
+
+  typedef __versa_string<char>                              __vstring;
+  typedef __vstring                                         __sso_string;
+  typedef 
+  __versa_string<char, std::char_traits<char>,
+		 std::allocator<char>, __rc_string_base>    __rc_string;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef __versa_string<wchar_t>                           __wvstring;
+  typedef __wvstring                                        __wsso_string;
+  typedef
+  __versa_string<wchar_t, std::char_traits<wchar_t>,
+		 std::allocator<wchar_t>, __rc_string_base> __wrc_string;
+#endif  
+
+#if ((__cplusplus >= 201103L) \
+     && defined(_GLIBCXX_USE_C99_STDINT_TR1))
+
+  typedef __versa_string<char16_t>                          __u16vstring;
+  typedef __u16vstring                                      __u16sso_string;
+  typedef 
+  __versa_string<char16_t, std::char_traits<char16_t>,
+		 std::allocator<char16_t>, __rc_string_base> __u16rc_string;
+
+  typedef __versa_string<char32_t>                          __u32vstring;
+  typedef __u32vstring                                      __u32sso_string;
+  typedef 
+  __versa_string<char32_t, std::char_traits<char32_t>,
+		 std::allocator<char32_t>, __rc_string_base> __u32rc_string;
+
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _VSTRING_FWD_H */
diff --git a/gcc-4.9/libstdc++-v3/include/ext/vstring_util.h b/gcc-4.9/libstdc++-v3/include/ext/vstring_util.h
new file mode 100644
index 0000000..2363f16
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/ext/vstring_util.h
@@ -0,0 +1,183 @@
+// Versatile string utility -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file ext/vstring_util.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{ext/vstring.h}
+ */
+
+#ifndef _VSTRING_UTIL_H
+#define _VSTRING_UTIL_H 1
+
+#pragma GCC system_header
+
+#include <ext/vstring_fwd.h>
+#include <debug/debug.h>
+#include <bits/stl_function.h>  // For less
+#include <bits/functexcept.h>
+#include <bits/localefwd.h>
+#include <bits/ostream_insert.h>
+#include <bits/stl_iterator.h>
+#include <ext/numeric_traits.h>
+#include <bits/move.h>
+#include <bits/range_access.h>
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    struct __vstring_utility
+    {
+      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
+
+      typedef _Traits					    traits_type;
+      typedef typename _Traits::char_type		    value_type;
+      typedef typename _CharT_alloc_type::size_type	    size_type;
+      typedef typename _CharT_alloc_type::difference_type   difference_type;
+      typedef typename _CharT_alloc_type::pointer	    pointer;
+      typedef typename _CharT_alloc_type::const_pointer	    const_pointer;
+
+      // For __sso_string.
+      typedef __gnu_cxx::
+      __normal_iterator<pointer, __gnu_cxx::
+			__versa_string<_CharT, _Traits, _Alloc,
+				       __sso_string_base> >
+	__sso_iterator;
+      typedef __gnu_cxx::
+      __normal_iterator<const_pointer, __gnu_cxx::
+			__versa_string<_CharT, _Traits, _Alloc,
+				       __sso_string_base> >
+	__const_sso_iterator;
+
+      // For __rc_string.
+      typedef __gnu_cxx::
+      __normal_iterator<pointer, __gnu_cxx::
+			__versa_string<_CharT, _Traits, _Alloc,
+				       __rc_string_base> >
+	__rc_iterator;
+      typedef __gnu_cxx::
+      __normal_iterator<const_pointer, __gnu_cxx::
+			__versa_string<_CharT, _Traits, _Alloc,
+				       __rc_string_base> >
+	__const_rc_iterator;
+
+      // NB:  When the allocator is empty, deriving from it saves space
+      // (http://www.cantrip.org/emptyopt.html).
+      template<typename _Alloc1>
+	struct _Alloc_hider
+	: public _Alloc1
+	{
+	  _Alloc_hider(_CharT* __ptr)
+	  : _Alloc1(), _M_p(__ptr) { }
+
+	  _Alloc_hider(const _Alloc1& __a, _CharT* __ptr)
+	  : _Alloc1(__a), _M_p(__ptr) { }
+
+	  _CharT*  _M_p; // The actual data.
+	};
+
+      // When __n = 1 way faster than the general multichar
+      // traits_type::copy/move/assign.
+      static void
+      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+	if (__n == 1)
+	  traits_type::assign(*__d, *__s);
+	else
+	  traits_type::copy(__d, __s, __n);
+      }
+
+      static void
+      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+	if (__n == 1)
+	  traits_type::assign(*__d, *__s);
+	else
+	  traits_type::move(__d, __s, __n);
+      }
+
+      static void
+      _S_assign(_CharT* __d, size_type __n, _CharT __c)
+      {
+	if (__n == 1)
+	  traits_type::assign(*__d, __c);
+	else
+	  traits_type::assign(__d, __n, __c);
+      }
+
+      // _S_copy_chars is a separate template to permit specialization
+      // to optimize for the common case of pointers as iterators.
+      template<typename _Iterator>
+	static void
+	_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+	{
+	  for (; __k1 != __k2; ++__k1, ++__p)
+	    traits_type::assign(*__p, *__k1); // These types are off.
+	}
+
+      static void
+      _S_copy_chars(_CharT* __p, __sso_iterator __k1, __sso_iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, __const_sso_iterator __k1,
+		    __const_sso_iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, __rc_iterator __k1, __rc_iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, __const_rc_iterator __k1,
+		    __const_rc_iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static int
+      _S_compare(size_type __n1, size_type __n2)
+      {
+	const difference_type __d = difference_type(__n1 - __n2);
+
+	if (__d > __numeric_traits_integer<int>::__max)
+	  return __numeric_traits_integer<int>::__max;
+	else if (__d < __numeric_traits_integer<int>::__min)
+	  return __numeric_traits_integer<int>::__min;
+	else
+	  return int(__d);
+      }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _VSTRING_UTIL_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/algo.h b/gcc-4.9/libstdc++-v3/include/parallel/algo.h
new file mode 100644
index 0000000..2c1f9eb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/algo.h
@@ -0,0 +1,2365 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/algo.h
+ *  @brief Parallel STL function calls corresponding to the stl_algo.h header.
+ *
+ *  The functions defined here mainly do case switches and
+ *  call the actual parallelized versions in other files.
+ *  Inlining policy: Functions that basically only contain one function call,
+ *  are declared inline.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler and Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_ALGO_H
+#define _GLIBCXX_PARALLEL_ALGO_H 1
+
+#include <parallel/algorithmfwd.h>
+#include <bits/stl_algobase.h>
+#include <bits/stl_algo.h>
+#include <parallel/iterator.h>
+#include <parallel/base.h>
+#include <parallel/sort.h>
+#include <parallel/workstealing.h>
+#include <parallel/par_loop.h>
+#include <parallel/omp_loop.h>
+#include <parallel/omp_loop_static.h>
+#include <parallel/for_each_selectors.h>
+#include <parallel/for_each.h>
+#include <parallel/find.h>
+#include <parallel/find_selectors.h>
+#include <parallel/search.h>
+#include <parallel/random_shuffle.h>
+#include <parallel/partition.h>
+#include <parallel/merge.h>
+#include <parallel/unique_copy.h>
+#include <parallel/set_operations.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __parallel
+{
+  // Sequential fallback
+  template<typename _IIter, typename _Function>
+    inline _Function
+    for_each(_IIter __begin, _IIter __end, _Function __f, 
+             __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::for_each(__begin, __end, __f); }
+
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter, typename _Function, typename _IteratorTag>
+    inline _Function
+    __for_each_switch(_IIter __begin, _IIter __end, _Function __f, 
+                    _IteratorTag)
+    { return for_each(__begin, __end, __f, __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators
+  template<typename _RAIter, typename _Function>
+    _Function
+    __for_each_switch(_RAIter __begin, _RAIter __end, 
+                    _Function __f, random_access_iterator_tag, 
+                    __gnu_parallel::_Parallelism __parallelism_tag
+                    = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().for_each_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          bool __dummy;
+    __gnu_parallel::__for_each_selector<_RAIter> __functionality;
+
+          return __gnu_parallel::
+            __for_each_template_random_access(
+              __begin, __end, __f, __functionality,
+              __gnu_parallel::_DummyReduct(), true, __dummy, -1,
+              __parallelism_tag);
+        }
+      else
+        return for_each(__begin, __end, __f, __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface
+  template<typename _Iterator, typename _Function>
+    inline _Function
+    for_each(_Iterator __begin, _Iterator __end, _Function __f, 
+             __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_Iterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __for_each_switch(__begin, __end, __f, _IteratorCategory(), 
+                             __parallelism_tag);
+    }
+
+  template<typename _Iterator, typename _Function>
+    inline _Function
+    for_each(_Iterator __begin, _Iterator __end, _Function __f) 
+    {
+      typedef std::iterator_traits<_Iterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __for_each_switch(__begin, __end, __f, _IteratorCategory());
+    }
+
+
+  // Sequential fallback
+  template<typename _IIter, typename _Tp>
+    inline _IIter
+    find(_IIter __begin, _IIter __end, const _Tp& __val, 
+         __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::find(__begin, __end, __val); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter, typename _Tp, typename _IteratorTag>
+    inline _IIter
+    __find_switch(_IIter __begin, _IIter __end, const _Tp& __val,
+                _IteratorTag)
+    { return _GLIBCXX_STD_A::find(__begin, __end, __val); }
+
+  // Parallel find for random access iterators
+  template<typename _RAIter, typename _Tp>
+    _RAIter
+    __find_switch(_RAIter __begin, _RAIter __end,
+                const _Tp& __val, random_access_iterator_tag)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        {
+	  __gnu_parallel::__binder2nd<__gnu_parallel::_EqualTo<_ValueType,
+							       const _Tp&>,
+				      _ValueType, const _Tp&, bool>
+            __comp(__gnu_parallel::_EqualTo<_ValueType, const _Tp&>(), __val);
+          return __gnu_parallel::__find_template(
+                   __begin, __end, __begin, __comp,
+                   __gnu_parallel::__find_if_selector()).first;
+        }
+      else
+        return _GLIBCXX_STD_A::find(__begin, __end, __val);
+    }
+
+  // Public interface
+  template<typename _IIter, typename _Tp>
+    inline _IIter
+    find(_IIter __begin, _IIter __end, const _Tp& __val)
+    {
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __find_switch(__begin, __end, __val, _IteratorCategory());
+    }
+
+  // Sequential fallback
+  template<typename _IIter, typename _Predicate>
+    inline _IIter
+    find_if(_IIter __begin, _IIter __end, _Predicate __pred, 
+            __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter, typename _Predicate, typename _IteratorTag>
+    inline _IIter
+    __find_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, 
+                   _IteratorTag)
+    { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); }
+
+  // Parallel find_if for random access iterators
+  template<typename _RAIter, typename _Predicate>
+    _RAIter
+    __find_if_switch(_RAIter __begin, _RAIter __end, 
+                   _Predicate __pred, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        return __gnu_parallel::__find_template(__begin, __end, __begin, __pred,
+                                             __gnu_parallel::
+                                             __find_if_selector()).first;
+      else
+        return _GLIBCXX_STD_A::find_if(__begin, __end, __pred);
+    }
+
+  // Public interface
+  template<typename _IIter, typename _Predicate>
+    inline _IIter
+    find_if(_IIter __begin, _IIter __end, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __find_if_switch(__begin, __end, __pred, _IteratorCategory());
+    }
+
+  // Sequential fallback
+  template<typename _IIter, typename _FIterator>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1, 
+                  _FIterator __begin2, _FIterator __end2, 
+                  __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::find_first_of(__begin1, __end1, __begin2, __end2);
+      }
+
+  // Sequential fallback
+  template<typename _IIter, typename _FIterator,
+           typename _BinaryPredicate>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1,
+                  _FIterator __begin2, _FIterator __end2,
+                  _BinaryPredicate __comp, __gnu_parallel::sequential_tag)
+  { return _GLIBCXX_STD_A::find_first_of(
+             __begin1, __end1, __begin2, __end2, __comp); }
+
+  // Sequential fallback for input iterator type
+  template<typename _IIter, typename _FIterator,
+           typename _IteratorTag1, typename _IteratorTag2>
+    inline _IIter
+    __find_first_of_switch(_IIter __begin1, _IIter __end1,
+                         _FIterator __begin2, _FIterator __end2, 
+                         _IteratorTag1, _IteratorTag2)
+    { return find_first_of(__begin1, __end1, __begin2, __end2, 
+                           __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators
+  template<typename _RAIter, typename _FIterator,
+           typename _BinaryPredicate, typename _IteratorTag>
+    inline _RAIter
+    __find_first_of_switch(_RAIter __begin1,
+                         _RAIter __end1,
+                         _FIterator __begin2, _FIterator __end2, 
+                         _BinaryPredicate __comp, random_access_iterator_tag, 
+                         _IteratorTag)
+    {
+      return __gnu_parallel::
+        __find_template(__begin1, __end1, __begin1, __comp,
+                      __gnu_parallel::__find_first_of_selector
+                      <_FIterator>(__begin2, __end2)).first;
+    }
+
+  // Sequential fallback for input iterator type
+  template<typename _IIter, typename _FIterator,
+           typename _BinaryPredicate, typename _IteratorTag1,
+           typename _IteratorTag2>
+    inline _IIter
+    __find_first_of_switch(_IIter __begin1, _IIter __end1,
+                         _FIterator __begin2, _FIterator __end2, 
+                         _BinaryPredicate __comp, _IteratorTag1, _IteratorTag2)
+    { return find_first_of(__begin1, __end1, __begin2, __end2, __comp, 
+                           __gnu_parallel::sequential_tag()); }
+
+  // Public interface
+  template<typename _IIter, typename _FIterator,
+           typename _BinaryPredicate>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1,
+                  _FIterator __begin2, _FIterator __end2, 
+                  _BinaryPredicate __comp)
+    {
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_FIterator> _FIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _FIterTraits::iterator_category _FIteratorCategory;
+
+      return __find_first_of_switch(__begin1, __end1, __begin2, __end2, __comp,
+                                  _IIteratorCategory(), _FIteratorCategory());
+    }
+
+  // Public interface, insert default comparator
+  template<typename _IIter, typename _FIterator>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1, 
+                  _FIterator __begin2, _FIterator __end2)
+    {
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_FIterator> _FIterTraits;
+      typedef typename _IIterTraits::value_type _IValueType;
+      typedef typename _FIterTraits::value_type _FValueType;
+
+      return __gnu_parallel::find_first_of(__begin1, __end1, __begin2, __end2,
+                         __gnu_parallel::_EqualTo<_IValueType, _FValueType>());
+    }
+
+  // Sequential fallback
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+                __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out); }
+
+  // Sequential fallback
+  template<typename _IIter, typename _OutputIterator,
+           typename _Predicate>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+                _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out, __pred); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter, typename _OutputIterator,
+           typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
+    inline _OutputIterator
+    __unique_copy_switch(_IIter __begin, _IIter __last, 
+                       _OutputIterator __out, _Predicate __pred, 
+                       _IteratorTag1, _IteratorTag2)
+    { return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred); }
+
+  // Parallel unique_copy for random access iterators
+  template<typename _RAIter, typename RandomAccessOutputIterator,
+           typename _Predicate>
+    RandomAccessOutputIterator
+    __unique_copy_switch(_RAIter __begin, _RAIter __last, 
+                       RandomAccessOutputIterator __out, _Predicate __pred, 
+                       random_access_iterator_tag, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__last - __begin)
+            > __gnu_parallel::_Settings::get().unique_copy_minimal_n))
+        return __gnu_parallel::__parallel_unique_copy(
+                 __begin, __last, __out, __pred);
+      else
+        return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred);
+    }
+
+  // Public interface
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _IIterTraits::value_type _ValueType;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __unique_copy_switch(
+               __begin1, __end1, __out, equal_to<_ValueType>(),
+               _IIteratorCategory(), _OIterCategory());
+    }
+
+  // Public interface
+  template<typename _IIter, typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+                _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __unique_copy_switch(
+               __begin1, __end1, __out, __pred,
+               _IIteratorCategory(), _OIterCategory());
+    }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2,
+              _OutputIterator __out, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_union(
+               __begin1, __end1, __begin2, __end2, __out); }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2,
+              _OutputIterator __out, _Predicate __pred,
+              __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_union(__begin1, __end1,
+                                       __begin2, __end2, __out, __pred); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+           typename _OutputIterator, typename _IteratorTag1,
+           typename _IteratorTag2, typename _IteratorTag3>
+    inline _OutputIterator
+    __set_union_switch(
+      _IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
+      _OutputIterator __result, _Predicate __pred,
+      _IteratorTag1, _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_A::set_union(__begin1, __end1,
+                                       __begin2, __end2, __result, __pred); }
+
+  // Parallel set_union for random access iterators
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_union_switch(_RAIter1 __begin1, _RAIter1 __end1, 
+                     _RAIter2 __begin2, _RAIter2 __end2, 
+                     _Output_RAIter __result, _Predicate __pred,
+                     random_access_iterator_tag, random_access_iterator_tag, 
+                     random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
+            >= __gnu_parallel::_Settings::get().set_union_minimal_n
+            || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
+            >= __gnu_parallel::_Settings::get().set_union_minimal_n))
+        return __gnu_parallel::__parallel_set_union(
+                 __begin1, __end1, __begin2, __end2, __result, __pred);
+      else
+        return _GLIBCXX_STD_A::set_union(__begin1, __end1,
+                                         __begin2, __end2, __result, __pred);
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator 
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_union_switch(
+               __begin1, __end1, __begin2, __end2, __out,
+               __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator 
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2,
+              _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_union_switch(
+               __begin1, __end1, __begin2, __end2, __out, __pred,
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Sequential fallback.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_intersection(_IIter1 __begin1, _IIter1 __end1,
+                     _IIter2 __begin2, _IIter2 __end2,
+                     _OutputIterator __out, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1,
+                                              __begin2, __end2, __out); }
+
+  // Sequential fallback.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_intersection(_IIter1 __begin1, _IIter1 __end1,
+                     _IIter2 __begin2, _IIter2 __end2,
+                     _OutputIterator __out, _Predicate __pred, 
+                     __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_intersection(
+               __begin1, __end1, __begin2, __end2, __out, __pred); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _OutputIterator,
+           typename _IteratorTag1, typename _IteratorTag2,
+           typename _IteratorTag3>
+    inline _OutputIterator 
+    __set_intersection_switch(_IIter1 __begin1, _IIter1 __end1,
+                              _IIter2 __begin2, _IIter2 __end2,
+                              _OutputIterator __result, _Predicate __pred,
+                              _IteratorTag1, _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1, __begin2,
+                                              __end2, __result, __pred); }
+
+  // Parallel set_intersection for random access iterators
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_intersection_switch(_RAIter1 __begin1,
+                            _RAIter1 __end1,
+                            _RAIter2 __begin2,
+                            _RAIter2 __end2,
+                            _Output_RAIter __result,
+                            _Predicate __pred,
+                            random_access_iterator_tag,
+                            random_access_iterator_tag,
+                            random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
+            >= __gnu_parallel::_Settings::get().set_union_minimal_n
+            || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
+            >= __gnu_parallel::_Settings::get().set_union_minimal_n))
+        return __gnu_parallel::__parallel_set_intersection(
+                 __begin1, __end1, __begin2, __end2, __result, __pred);
+      else
+        return _GLIBCXX_STD_A::set_intersection(
+                 __begin1, __end1, __begin2, __end2, __result, __pred);
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator 
+    set_intersection(_IIter1 __begin1, _IIter1 __end1, 
+                     _IIter2 __begin2, _IIter2 __end2, 
+                     _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_intersection_switch(
+               __begin1, __end1, __begin2, __end2, __out,
+               __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator 
+    set_intersection(_IIter1 __begin1, _IIter1 __end1,
+                     _IIter2 __begin2, _IIter2 __end2,
+                     _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_intersection_switch(
+               __begin1, __end1, __begin2, __end2, __out, __pred,
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out,
+                             __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_symmetric_difference(
+               __begin1, __end1, __begin2, __end2, __out); }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out, _Predicate __pred,
+                             __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_symmetric_difference(
+               __begin1, __end1, __begin2, __end2, __out, __pred); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _OutputIterator,
+           typename _IteratorTag1, typename _IteratorTag2,
+           typename _IteratorTag3>
+    inline _OutputIterator 
+    __set_symmetric_difference_switch(
+      _IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
+      _OutputIterator __result, _Predicate __pred,
+      _IteratorTag1, _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_A::set_symmetric_difference(
+               __begin1, __end1, __begin2, __end2, __result, __pred); }
+
+  // Parallel set_symmetric_difference for random access iterators
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_symmetric_difference_switch(_RAIter1 __begin1,
+                                    _RAIter1 __end1,
+                                    _RAIter2 __begin2,
+                                    _RAIter2 __end2,
+                                    _Output_RAIter __result,
+                                    _Predicate __pred,
+                                    random_access_iterator_tag,
+                                    random_access_iterator_tag,
+                                    random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+      static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
+      >= __gnu_parallel::_Settings::get().set_symmetric_difference_minimal_n
+      || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
+      >= __gnu_parallel::_Settings::get().set_symmetric_difference_minimal_n))
+  return __gnu_parallel::__parallel_set_symmetric_difference(
+           __begin1, __end1, __begin2, __end2, __result, __pred);
+      else
+        return _GLIBCXX_STD_A::set_symmetric_difference(
+                 __begin1, __end1, __begin2, __end2, __result, __pred);
+    }
+
+  // Public interface.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator 
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_symmetric_difference_switch(
+               __begin1, __end1, __begin2, __end2, __out,
+               __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Public interface.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator 
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_symmetric_difference_switch(
+               __begin1, __end1, __begin2, __end2, __out, __pred,
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Sequential fallback.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_difference(
+               __begin1,__end1, __begin2, __end2, __out); }
+
+  // Sequential fallback.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out, _Predicate __pred, 
+                   __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::set_difference(__begin1, __end1,
+                                            __begin2, __end2, __out, __pred); }
+
+  // Sequential fallback for input iterator case.
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+           typename _OutputIterator, typename _IteratorTag1,
+           typename _IteratorTag2, typename _IteratorTag3>
+    inline _OutputIterator
+    __set_difference_switch(_IIter1 __begin1, _IIter1 __end1, 
+                          _IIter2 __begin2, _IIter2 __end2, 
+                          _OutputIterator __result, _Predicate __pred, 
+                          _IteratorTag1, _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_A::set_difference(
+               __begin1, __end1, __begin2, __end2, __result, __pred); }
+
+  // Parallel set_difference for random access iterators
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_difference_switch(_RAIter1 __begin1,
+                          _RAIter1 __end1,
+                          _RAIter2 __begin2,
+                          _RAIter2 __end2,
+                          _Output_RAIter __result, _Predicate __pred,
+                          random_access_iterator_tag,
+                          random_access_iterator_tag,
+                          random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
+            >= __gnu_parallel::_Settings::get().set_difference_minimal_n
+            || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
+            >= __gnu_parallel::_Settings::get().set_difference_minimal_n))
+        return __gnu_parallel::__parallel_set_difference(
+                 __begin1, __end1, __begin2, __end2, __result, __pred);
+      else
+        return _GLIBCXX_STD_A::set_difference(
+                 __begin1, __end1, __begin2, __end2, __result, __pred);
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_difference_switch(
+               __begin1, __end1, __begin2, __end2, __out,
+               __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_difference_switch(
+               __begin1, __end1, __begin2, __end2, __out, __pred,
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Sequential fallback
+  template<typename _FIterator>
+    inline _FIterator
+    adjacent_find(_FIterator __begin, _FIterator __end, 
+                  __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::adjacent_find(__begin, __end); }
+
+  // Sequential fallback
+  template<typename _FIterator, typename _BinaryPredicate>
+    inline _FIterator
+    adjacent_find(_FIterator __begin, _FIterator __end, 
+                  _BinaryPredicate __binary_pred,
+                  __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::adjacent_find(__begin, __end, __binary_pred); }
+
+  // Parallel algorithm for random access iterators
+  template<typename _RAIter>
+    _RAIter
+    __adjacent_find_switch(_RAIter __begin, _RAIter __end, 
+                         random_access_iterator_tag)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        {
+          _RAIter __spot = __gnu_parallel::
+              __find_template(
+                __begin, __end - 1, __begin, equal_to<_ValueType>(),
+                __gnu_parallel::__adjacent_find_selector())
+            .first;
+          if (__spot == (__end - 1))
+            return __end;
+          else
+            return __spot;
+        }
+      else
+        return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag());
+    }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator, typename _IteratorTag>
+    inline _FIterator
+    __adjacent_find_switch(_FIterator __begin, _FIterator __end,
+                         _IteratorTag)
+    { return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag()); }
+
+  // Public interface
+  template<typename _FIterator>
+    inline _FIterator
+    adjacent_find(_FIterator __begin, _FIterator __end)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __adjacent_find_switch(__begin, __end, _IteratorCategory());
+    }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator, typename _BinaryPredicate,
+           typename _IteratorTag>
+    inline _FIterator
+    __adjacent_find_switch(_FIterator __begin, _FIterator __end, 
+                         _BinaryPredicate __pred, _IteratorTag)
+    { return adjacent_find(__begin, __end, __pred,
+                           __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators
+  template<typename _RAIter, typename _BinaryPredicate>
+    _RAIter
+    __adjacent_find_switch(_RAIter __begin, _RAIter __end, 
+                         _BinaryPredicate __pred, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        return __gnu_parallel::__find_template(__begin, __end, __begin, __pred,
+                                             __gnu_parallel::
+                                             __adjacent_find_selector()).first;
+      else
+        return adjacent_find(__begin, __end, __pred,
+                             __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface
+  template<typename _FIterator, typename _BinaryPredicate>
+    inline _FIterator
+    adjacent_find(_FIterator __begin, _FIterator __end, 
+                  _BinaryPredicate __pred)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __adjacent_find_switch(__begin, __end, __pred,
+                                    _IteratorCategory());
+    }
+
+  // Sequential fallback
+  template<typename _IIter, typename _Tp>
+    inline typename iterator_traits<_IIter>::difference_type
+    count(_IIter __begin, _IIter __end, const _Tp& __value, 
+          __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::count(__begin, __end, __value); }
+
+  // Parallel code for random access iterators
+  template<typename _RAIter, typename _Tp>
+    typename iterator_traits<_RAIter>::difference_type
+    __count_switch(_RAIter __begin, _RAIter __end, 
+                 const _Tp& __value, random_access_iterator_tag, 
+                 __gnu_parallel::_Parallelism __parallelism_tag 
+                 = __gnu_parallel::parallel_unbalanced)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef __gnu_parallel::_SequenceIndex _SequenceIndex;
+
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().count_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          __gnu_parallel::__count_selector<_RAIter, _DifferenceType>
+            __functionality;
+          _DifferenceType __res = 0;
+          __gnu_parallel::
+            __for_each_template_random_access(
+              __begin, __end, __value, __functionality,
+              std::plus<_SequenceIndex>(), __res, __res, -1,
+              __parallelism_tag);
+          return __res;
+        }
+      else
+        return count(__begin, __end, __value,
+                     __gnu_parallel::sequential_tag());
+    }
+
+  // Sequential fallback for input iterator case.
+  template<typename _IIter, typename _Tp, typename _IteratorTag>
+    inline typename iterator_traits<_IIter>::difference_type
+    __count_switch(_IIter __begin, _IIter __end, const _Tp& __value, 
+                 _IteratorTag)
+    { return count(__begin, __end, __value, __gnu_parallel::sequential_tag());
+      }
+
+  // Public interface.
+  template<typename _IIter, typename _Tp>
+    inline typename iterator_traits<_IIter>::difference_type
+    count(_IIter __begin, _IIter __end, const _Tp& __value, 
+          __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_switch(__begin, __end, __value, _IteratorCategory(),
+                            __parallelism_tag);
+    }
+
+  template<typename _IIter, typename _Tp>
+    inline typename iterator_traits<_IIter>::difference_type
+    count(_IIter __begin, _IIter __end, const _Tp& __value)
+    {
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_switch(__begin, __end, __value, _IteratorCategory());
+    }
+
+
+  // Sequential fallback.
+  template<typename _IIter, typename _Predicate>
+    inline typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter __begin, _IIter __end, _Predicate __pred, 
+             __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::count_if(__begin, __end, __pred); }
+
+  // Parallel count_if for random access iterators
+  template<typename _RAIter, typename _Predicate>
+    typename iterator_traits<_RAIter>::difference_type
+    __count_if_switch(_RAIter __begin, _RAIter __end, 
+                    _Predicate __pred, random_access_iterator_tag,
+                    __gnu_parallel::_Parallelism __parallelism_tag
+                    = __gnu_parallel::parallel_unbalanced)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef __gnu_parallel::_SequenceIndex _SequenceIndex;
+
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().count_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          _DifferenceType __res = 0;
+          __gnu_parallel::
+            __count_if_selector<_RAIter, _DifferenceType>
+            __functionality;
+          __gnu_parallel::
+            __for_each_template_random_access(
+              __begin, __end, __pred, __functionality,
+              std::plus<_SequenceIndex>(), __res, __res, -1,
+              __parallelism_tag);
+          return __res;
+        }
+      else
+        return count_if(__begin, __end, __pred,
+                        __gnu_parallel::sequential_tag());
+    }
+
+  // Sequential fallback for input iterator case.
+  template<typename _IIter, typename _Predicate, typename _IteratorTag>
+    inline typename iterator_traits<_IIter>::difference_type
+    __count_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, 
+                    _IteratorTag)
+    { return count_if(__begin, __end, __pred,
+                      __gnu_parallel::sequential_tag()); }
+
+  // Public interface.
+  template<typename _IIter, typename _Predicate>
+    inline typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter __begin, _IIter __end, _Predicate __pred, 
+             __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_if_switch(__begin, __end, __pred, _IteratorCategory(), 
+                             __parallelism_tag);
+    }
+
+  template<typename _IIter, typename _Predicate>
+    inline typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter __begin, _IIter __end, _Predicate __pred)
+    {
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_if_switch(__begin, __end, __pred, _IteratorCategory());
+    }
+
+
+  // Sequential fallback.
+  template<typename _FIterator1, typename _FIterator2>
+    inline _FIterator1
+    search(_FIterator1 __begin1, _FIterator1 __end1,
+           _FIterator2 __begin2, _FIterator2 __end2,
+           __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::search(__begin1, __end1, __begin2, __end2); }
+
+  // Parallel algorithm for random access iterator
+  template<typename _RAIter1, typename _RAIter2>
+    _RAIter1
+    __search_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                  _RAIter2 __begin2, _RAIter2 __end2,
+                  random_access_iterator_tag, random_access_iterator_tag)
+    {
+      typedef std::iterator_traits<_RAIter1> _Iterator1Traits;
+      typedef typename _Iterator1Traits::value_type _ValueType1;
+      typedef std::iterator_traits<_RAIter2> _Iterator2Traits;
+      typedef typename _Iterator2Traits::value_type _ValueType2;
+
+      if (_GLIBCXX_PARALLEL_CONDITION(
+                static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
+            >= __gnu_parallel::_Settings::get().search_minimal_n))
+        return __gnu_parallel::
+          __search_template(
+            __begin1, __end1, __begin2, __end2,
+            __gnu_parallel::_EqualTo<_ValueType1, _ValueType2>());
+      else
+        return search(__begin1, __end1, __begin2, __end2,
+                      __gnu_parallel::sequential_tag());
+    }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator1, typename _FIterator2,
+           typename _IteratorTag1, typename _IteratorTag2>
+    inline _FIterator1
+    __search_switch(_FIterator1 __begin1, _FIterator1 __end1,
+                  _FIterator2 __begin2, _FIterator2 __end2,
+                  _IteratorTag1, _IteratorTag2)
+    { return search(__begin1, __end1, __begin2, __end2,
+                    __gnu_parallel::sequential_tag()); }
+
+  // Public interface.
+  template<typename _FIterator1, typename _FIterator2>
+    inline _FIterator1
+    search(_FIterator1 __begin1, _FIterator1 __end1,
+           _FIterator2 __begin2, _FIterator2 __end2)
+    {
+      typedef std::iterator_traits<_FIterator1> _Iterator1Traits;
+      typedef typename _Iterator1Traits::iterator_category _IteratorCategory1;
+      typedef std::iterator_traits<_FIterator2> _Iterator2Traits;
+      typedef typename _Iterator2Traits::iterator_category _IteratorCategory2;
+
+      return __search_switch(__begin1, __end1, __begin2, __end2,
+                           _IteratorCategory1(), _IteratorCategory2());
+    }
+
+  // Public interface.
+  template<typename _FIterator1, typename _FIterator2,
+           typename _BinaryPredicate>
+    inline _FIterator1
+    search(_FIterator1 __begin1, _FIterator1 __end1,
+           _FIterator2 __begin2, _FIterator2 __end2,
+           _BinaryPredicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::search(
+                               __begin1, __end1, __begin2, __end2, __pred); }
+
+  // Parallel algorithm for random access iterator.
+  template<typename _RAIter1, typename _RAIter2,
+           typename _BinaryPredicate>
+    _RAIter1
+    __search_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                  _RAIter2 __begin2, _RAIter2 __end2,
+                  _BinaryPredicate __pred,
+                  random_access_iterator_tag, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+                static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
+            >= __gnu_parallel::_Settings::get().search_minimal_n))
+        return __gnu_parallel::__search_template(__begin1, __end1,
+                                               __begin2, __end2, __pred);
+      else
+        return search(__begin1, __end1, __begin2, __end2, __pred,
+                      __gnu_parallel::sequential_tag());
+    }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator1, typename _FIterator2,
+           typename _BinaryPredicate, typename _IteratorTag1,
+           typename _IteratorTag2>
+    inline _FIterator1
+    __search_switch(_FIterator1 __begin1, _FIterator1 __end1,
+                  _FIterator2 __begin2, _FIterator2 __end2,
+                  _BinaryPredicate __pred, _IteratorTag1, _IteratorTag2)
+    { return search(__begin1, __end1, __begin2, __end2, __pred,
+                    __gnu_parallel::sequential_tag()); }
+
+  // Public interface
+  template<typename _FIterator1, typename _FIterator2,
+           typename _BinaryPredicate>
+    inline _FIterator1
+    search(_FIterator1 __begin1, _FIterator1 __end1,
+           _FIterator2 __begin2, _FIterator2 __end2,
+           _BinaryPredicate  __pred)
+    {
+      typedef std::iterator_traits<_FIterator1> _Iterator1Traits;
+      typedef typename _Iterator1Traits::iterator_category _IteratorCategory1;
+      typedef std::iterator_traits<_FIterator2> _Iterator2Traits;
+      typedef typename _Iterator2Traits::iterator_category _IteratorCategory2;
+      return __search_switch(__begin1, __end1, __begin2, __end2, __pred,
+                           _IteratorCategory1(), _IteratorCategory2());
+    }
+
+  // Sequential fallback
+  template<typename _FIterator, typename _Integer, typename _Tp>
+    inline _FIterator
+    search_n(_FIterator __begin, _FIterator __end, _Integer __count,
+             const _Tp& __val, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val); }
+
+  // Sequential fallback
+  template<typename _FIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    inline _FIterator
+    search_n(_FIterator __begin, _FIterator __end, _Integer __count,
+             const _Tp& __val, _BinaryPredicate __binary_pred,
+             __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::search_n(
+               __begin, __end, __count, __val, __binary_pred); }
+
+  // Public interface.
+  template<typename _FIterator, typename _Integer, typename _Tp>
+    inline _FIterator
+    search_n(_FIterator __begin, _FIterator __end, _Integer __count,
+             const _Tp& __val)
+    {
+      typedef typename iterator_traits<_FIterator>::value_type _ValueType;
+      return __gnu_parallel::search_n(__begin, __end, __count, __val,
+                      __gnu_parallel::_EqualTo<_ValueType, _Tp>());
+    }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _RAIter, typename _Integer,
+           typename _Tp, typename _BinaryPredicate>
+    _RAIter
+    __search_n_switch(_RAIter __begin, _RAIter __end, _Integer __count,
+                      const _Tp& __val, _BinaryPredicate __binary_pred,
+                      random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+                static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().search_minimal_n))
+        {
+          __gnu_parallel::_PseudoSequence<_Tp, _Integer> __ps(__val, __count);
+          return __gnu_parallel::__search_template(
+                   __begin, __end, __ps.begin(), __ps.end(), __binary_pred);
+        }
+      else
+        return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val,
+                                        __binary_pred);
+    }
+
+  // Sequential fallback for input iterator case.
+  template<typename _FIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate, typename _IteratorTag>
+    inline _FIterator
+    __search_n_switch(_FIterator __begin, _FIterator __end, _Integer __count,
+                      const _Tp& __val, _BinaryPredicate __binary_pred,
+                      _IteratorTag)
+    { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val,
+                                      __binary_pred); }
+
+  // Public interface.
+  template<typename _FIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    inline _FIterator
+    search_n(_FIterator __begin, _FIterator __end, _Integer __count,
+             const _Tp& __val, _BinaryPredicate __binary_pred)
+    {
+      return __search_n_switch(__begin, __end, __count, __val, __binary_pred,
+                             typename std::iterator_traits<_FIterator>::
+                             iterator_category());
+    }
+
+
+  // Sequential fallback.
+  template<typename _IIter, typename _OutputIterator,
+           typename _UnaryOperation>
+    inline _OutputIterator
+    transform(_IIter __begin, _IIter __end, _OutputIterator __result, 
+              _UnaryOperation __unary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::transform(__begin, __end, __result, __unary_op); }
+
+  // Parallel unary transform for random access iterators.
+  template<typename _RAIter1, typename _RAIter2,
+           typename _UnaryOperation>
+    _RAIter2
+    __transform1_switch(_RAIter1 __begin, _RAIter1 __end,
+                      _RAIter2 __result, _UnaryOperation __unary_op,
+                      random_access_iterator_tag, random_access_iterator_tag,
+                      __gnu_parallel::_Parallelism __parallelism_tag
+                      = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().transform_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          bool __dummy = true;
+          typedef __gnu_parallel::_IteratorPair<_RAIter1,
+            _RAIter2, random_access_iterator_tag> _ItTrip;
+          _ItTrip __begin_pair(__begin, __result),
+                  __end_pair(__end, __result + (__end - __begin));
+          __gnu_parallel::__transform1_selector<_ItTrip> __functionality;
+          __gnu_parallel::
+            __for_each_template_random_access(
+              __begin_pair, __end_pair, __unary_op, __functionality,
+              __gnu_parallel::_DummyReduct(),
+              __dummy, __dummy, -1, __parallelism_tag);
+          return __functionality._M_finish_iterator;
+        }
+      else
+        return transform(__begin, __end, __result, __unary_op, 
+                         __gnu_parallel::sequential_tag());
+    }
+
+  // Sequential fallback for input iterator case.
+  template<typename _RAIter1, typename _RAIter2,
+           typename _UnaryOperation, typename _IteratorTag1,
+           typename _IteratorTag2>
+    inline _RAIter2
+    __transform1_switch(_RAIter1 __begin, _RAIter1 __end,
+                      _RAIter2 __result, _UnaryOperation __unary_op,
+                      _IteratorTag1, _IteratorTag2)
+    { return transform(__begin, __end, __result, __unary_op, 
+                       __gnu_parallel::sequential_tag()); }
+
+  // Public interface.
+  template<typename _IIter, typename _OutputIterator,
+           typename _UnaryOperation>
+    inline _OutputIterator
+    transform(_IIter __begin, _IIter __end, _OutputIterator __result,
+              _UnaryOperation __unary_op, 
+              __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __transform1_switch(__begin, __end, __result, __unary_op,
+                               _IIteratorCategory(), _OIterCategory(), 
+                               __parallelism_tag);
+    }
+
+  template<typename _IIter, typename _OutputIterator,
+           typename _UnaryOperation>
+    inline _OutputIterator
+    transform(_IIter __begin, _IIter __end, _OutputIterator __result,
+              _UnaryOperation __unary_op)
+    {
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __transform1_switch(__begin, __end, __result, __unary_op,
+                               _IIteratorCategory(), _OIterCategory());
+    }
+
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation>
+    inline _OutputIterator
+    transform(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _OutputIterator __result,
+              _BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::transform(__begin1, __end1,
+                                       __begin2, __result, __binary_op); }
+
+  // Parallel binary transform for random access iterators.
+  template<typename _RAIter1, typename _RAIter2,
+           typename _RAIter3, typename _BinaryOperation>
+    _RAIter3
+    __transform2_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                      _RAIter2 __begin2,
+                      _RAIter3 __result, _BinaryOperation __binary_op,
+                      random_access_iterator_tag, random_access_iterator_tag,
+                      random_access_iterator_tag,
+                      __gnu_parallel::_Parallelism __parallelism_tag 
+                      = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            (__end1 - __begin1) >=
+                __gnu_parallel::_Settings::get().transform_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          bool __dummy = true;
+          typedef __gnu_parallel::_IteratorTriple<_RAIter1,
+            _RAIter2, _RAIter3,
+            random_access_iterator_tag> _ItTrip;
+          _ItTrip __begin_triple(__begin1, __begin2, __result),
+            __end_triple(__end1, __begin2 + (__end1 - __begin1),
+                       __result + (__end1 - __begin1));
+          __gnu_parallel::__transform2_selector<_ItTrip> __functionality;
+          __gnu_parallel::
+            __for_each_template_random_access(__begin_triple, __end_triple,
+                                            __binary_op, __functionality,
+                                            __gnu_parallel::_DummyReduct(),
+                                            __dummy, __dummy, -1,
+                                            __parallelism_tag);
+          return __functionality._M_finish_iterator;
+        }
+      else
+        return transform(__begin1, __end1, __begin2, __result, __binary_op, 
+                         __gnu_parallel::sequential_tag());
+    }
+
+  // Sequential fallback for input iterator case.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation,
+           typename _Tag1, typename _Tag2, typename _Tag3>
+    inline _OutputIterator
+    __transform2_switch(_IIter1 __begin1, _IIter1 __end1, 
+                      _IIter2 __begin2, _OutputIterator __result, 
+                      _BinaryOperation __binary_op, _Tag1, _Tag2, _Tag3)
+    { return transform(__begin1, __end1, __begin2, __result, __binary_op,
+                       __gnu_parallel::sequential_tag()); }
+
+  // Public interface.
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation>
+    inline _OutputIterator
+    transform(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _OutputIterator __result,
+              _BinaryOperation __binary_op, 
+              __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __transform2_switch(
+               __begin1, __end1, __begin2, __result, __binary_op,
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory(),
+               __parallelism_tag);
+    }
+
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation>
+    inline _OutputIterator
+    transform(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _OutputIterator __result,
+              _BinaryOperation __binary_op)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __transform2_switch(
+               __begin1, __end1, __begin2, __result, __binary_op,
+               _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+    }
+
+  // Sequential fallback
+  template<typename _FIterator, typename _Tp>
+    inline void
+    replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value, 
+            const _Tp& __new_value, __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::replace(__begin, __end, __old_value, __new_value); }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator, typename _Tp, typename _IteratorTag>
+    inline void
+    __replace_switch(_FIterator __begin, _FIterator __end, 
+                     const _Tp& __old_value, const _Tp& __new_value,
+                     _IteratorTag)
+    { replace(__begin, __end, __old_value, __new_value, 
+              __gnu_parallel::sequential_tag()); }
+
+  // Parallel replace for random access iterators
+  template<typename _RAIter, typename _Tp>
+    inline void
+    __replace_switch(_RAIter __begin, _RAIter __end, 
+                   const _Tp& __old_value, const _Tp& __new_value, 
+                   random_access_iterator_tag, 
+                   __gnu_parallel::_Parallelism __parallelism_tag
+                   = __gnu_parallel::parallel_balanced)
+    {
+      // XXX parallel version is where?
+      replace(__begin, __end, __old_value, __new_value, 
+              __gnu_parallel::sequential_tag()); 
+    }
+
+  // Public interface
+  template<typename _FIterator, typename _Tp>
+    inline void
+    replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value, 
+            const _Tp& __new_value,
+            __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      __replace_switch(__begin, __end, __old_value, __new_value,
+                       _IteratorCategory(),
+                     __parallelism_tag);
+    }
+
+  template<typename _FIterator, typename _Tp>
+    inline void
+    replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value, 
+            const _Tp& __new_value)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      __replace_switch(__begin, __end, __old_value, __new_value,
+                       _IteratorCategory());
+    }
+
+
+  // Sequential fallback
+  template<typename _FIterator, typename _Predicate, typename _Tp>
+    inline void
+    replace_if(_FIterator __begin, _FIterator __end, _Predicate __pred, 
+               const _Tp& __new_value, __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::replace_if(__begin, __end, __pred, __new_value); }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator, typename _Predicate, typename _Tp,
+           typename _IteratorTag>
+    inline void
+    __replace_if_switch(_FIterator __begin, _FIterator __end,
+                      _Predicate __pred, const _Tp& __new_value, _IteratorTag)
+    { replace_if(__begin, __end, __pred, __new_value,
+                 __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _RAIter, typename _Predicate, typename _Tp>
+    void
+    __replace_if_switch(_RAIter __begin, _RAIter __end,
+                      _Predicate __pred, const _Tp& __new_value,
+                      random_access_iterator_tag,
+                      __gnu_parallel::_Parallelism __parallelism_tag
+                      = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().replace_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          bool __dummy;
+          __gnu_parallel::
+            __replace_if_selector<_RAIter, _Predicate, _Tp>
+            __functionality(__new_value);
+          __gnu_parallel::
+            __for_each_template_random_access(
+              __begin, __end, __pred, __functionality,
+              __gnu_parallel::_DummyReduct(),
+              true, __dummy, -1, __parallelism_tag);
+        }
+      else
+        replace_if(__begin, __end, __pred, __new_value, 
+                   __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface.
+  template<typename _FIterator, typename _Predicate, typename _Tp>
+    inline void
+    replace_if(_FIterator __begin, _FIterator __end,
+               _Predicate __pred, const _Tp& __new_value, 
+               __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_FIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __replace_if_switch(__begin, __end, __pred, __new_value,
+                          _IteratorCategory(), __parallelism_tag);
+    }
+
+  template<typename _FIterator, typename _Predicate, typename _Tp>
+    inline void
+    replace_if(_FIterator __begin, _FIterator __end,
+               _Predicate __pred, const _Tp& __new_value)
+    {
+      typedef std::iterator_traits<_FIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __replace_if_switch(__begin, __end, __pred, __new_value,
+                          _IteratorCategory());
+    }
+
+  // Sequential fallback
+  template<typename _FIterator, typename _Generator>
+    inline void
+    generate(_FIterator __begin, _FIterator __end, _Generator __gen, 
+             __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::generate(__begin, __end, __gen); }
+
+  // Sequential fallback for input iterator case.
+  template<typename _FIterator, typename _Generator, typename _IteratorTag>
+    inline void
+    __generate_switch(_FIterator __begin, _FIterator __end, _Generator __gen,
+                    _IteratorTag)
+    { generate(__begin, __end, __gen, __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _RAIter, typename _Generator>
+    void
+    __generate_switch(_RAIter __begin, _RAIter __end,
+                    _Generator __gen, random_access_iterator_tag, 
+                    __gnu_parallel::_Parallelism __parallelism_tag
+                    = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().generate_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          bool __dummy;
+          __gnu_parallel::__generate_selector<_RAIter>
+            __functionality;
+          __gnu_parallel::
+            __for_each_template_random_access(
+              __begin, __end, __gen, __functionality,
+              __gnu_parallel::_DummyReduct(),
+              true, __dummy, -1, __parallelism_tag);
+        }
+      else
+        generate(__begin, __end, __gen, __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface.
+  template<typename _FIterator, typename _Generator>
+    inline void
+    generate(_FIterator __begin, _FIterator __end,
+             _Generator __gen, __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_FIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __generate_switch(__begin, __end, __gen, _IteratorCategory(),
+                        __parallelism_tag);
+    }
+
+  template<typename _FIterator, typename _Generator>
+    inline void
+    generate(_FIterator __begin, _FIterator __end, _Generator __gen)
+    {
+      typedef std::iterator_traits<_FIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __generate_switch(__begin, __end, __gen, _IteratorCategory());
+    }
+
+
+  // Sequential fallback.
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    inline _OutputIterator
+    generate_n(_OutputIterator __begin, _Size __n, _Generator __gen, 
+               __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::generate_n(__begin, __n, __gen); }
+
+  // Sequential fallback for input iterator case.
+  template<typename _OutputIterator, typename _Size, typename _Generator,
+           typename _IteratorTag>
+    inline _OutputIterator
+    __generate_n_switch(_OutputIterator __begin, _Size __n, _Generator __gen,
+                        _IteratorTag)
+    { return generate_n(__begin, __n, __gen,
+                        __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _RAIter, typename _Size, typename _Generator>
+    inline _RAIter
+    __generate_n_switch(_RAIter __begin, _Size __n, _Generator __gen, 
+                      random_access_iterator_tag, 
+                      __gnu_parallel::_Parallelism __parallelism_tag
+                      = __gnu_parallel::parallel_balanced)
+    {
+      // XXX parallel version is where?
+      return generate_n(__begin, __n, __gen, __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface.
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    inline _OutputIterator
+    generate_n(_OutputIterator __begin, _Size __n, _Generator __gen, 
+               __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_OutputIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __generate_n_switch(__begin, __n, __gen, _IteratorCategory(), 
+                               __parallelism_tag); 
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    inline _OutputIterator
+    generate_n(_OutputIterator __begin, _Size __n, _Generator __gen)
+    {
+      typedef std::iterator_traits<_OutputIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __generate_n_switch(__begin, __n, __gen, _IteratorCategory());
+    }
+
+
+  // Sequential fallback.
+  template<typename _RAIter>
+    inline void
+    random_shuffle(_RAIter __begin, _RAIter __end, 
+                   __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::random_shuffle(__begin, __end); }
+
+  // Sequential fallback.
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    inline void
+    random_shuffle(_RAIter __begin, _RAIter __end,
+                   _RandomNumberGenerator& __rand,
+                   __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::random_shuffle(__begin, __end, __rand); }
+
+
+  /** @brief Functor wrapper for std::rand(). */
+  template<typename _MustBeInt = int>
+    struct _CRandNumber
+    {
+      int
+      operator()(int __limit)
+      { return rand() % __limit; }
+    };
+
+  // Fill in random number generator.
+  template<typename _RAIter>
+    inline void
+    random_shuffle(_RAIter __begin, _RAIter __end)
+    {
+      _CRandNumber<> __r;
+      // Parallelization still possible.
+      __gnu_parallel::random_shuffle(__begin, __end, __r);
+    }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RAIter __begin, _RAIter __end,
+#if __cplusplus >= 201103L
+                   _RandomNumberGenerator&& __rand)
+#else
+                   _RandomNumberGenerator& __rand)
+#endif
+    {
+      if (__begin == __end)
+        return;
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().random_shuffle_minimal_n))
+        __gnu_parallel::__parallel_random_shuffle(__begin, __end, __rand);
+      else
+        __gnu_parallel::__sequential_random_shuffle(__begin, __end, __rand);
+    }
+
+  // Sequential fallback.
+  template<typename _FIterator, typename _Predicate>
+    inline _FIterator
+    partition(_FIterator __begin, _FIterator __end,
+              _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::partition(__begin, __end, __pred); }
+
+  // Sequential fallback for input iterator case.
+  template<typename _FIterator, typename _Predicate, typename _IteratorTag>
+    inline _FIterator
+    __partition_switch(_FIterator __begin, _FIterator __end,
+                     _Predicate __pred, _IteratorTag)
+    { return partition(__begin, __end, __pred,
+                       __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _RAIter, typename _Predicate>
+    _RAIter
+    __partition_switch(_RAIter __begin, _RAIter __end,
+                     _Predicate __pred, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().partition_minimal_n))
+        {
+          typedef typename std::iterator_traits<_RAIter>::
+            difference_type _DifferenceType;
+          _DifferenceType __middle = __gnu_parallel::
+            __parallel_partition(__begin, __end, __pred,
+                               __gnu_parallel::__get_max_threads());
+          return __begin + __middle;
+        }
+      else
+        return partition(__begin, __end, __pred,
+                         __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface.
+  template<typename _FIterator, typename _Predicate>
+    inline _FIterator
+    partition(_FIterator __begin, _FIterator __end, _Predicate __pred)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __partition_switch(__begin, __end, __pred, _IteratorCategory());
+    }
+
+  // sort interface
+
+  // Sequential fallback
+  template<typename _RAIter>
+    inline void
+    sort(_RAIter __begin, _RAIter __end, 
+         __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::sort(__begin, __end); }
+
+  // Sequential fallback
+  template<typename _RAIter, typename _Compare>
+    inline void
+    sort(_RAIter __begin, _RAIter __end, _Compare __comp,
+         __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::sort<_RAIter, _Compare>(__begin, __end,
+                                                             __comp); }
+
+  // Public interface
+  template<typename _RAIter, typename _Compare,
+           typename _Parallelism>
+  void
+  sort(_RAIter __begin, _RAIter __end, _Compare __comp,
+       _Parallelism __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+
+    if (__begin != __end)
+      {
+        if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >=
+              __gnu_parallel::_Settings::get().sort_minimal_n))
+          __gnu_parallel::__parallel_sort<false>(
+                            __begin, __end, __comp, __parallelism);
+        else
+          sort(__begin, __end, __comp, __gnu_parallel::sequential_tag());
+      }
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+    inline void
+    sort(_RAIter __begin, _RAIter __end)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      sort(__begin, __end, std::less<_ValueType>(),
+           __gnu_parallel::default_parallel_tag());
+    }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::default_parallel_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::parallel_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::multiway_mergesort_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::multiway_mergesort_sampling_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::multiway_mergesort_exact_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::quicksort_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::balanced_quicksort_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface
+  template<typename _RAIter, typename _Compare>
+    void
+    sort(_RAIter __begin, _RAIter __end, _Compare __comp)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, __comp, __gnu_parallel::default_parallel_tag());
+  }
+
+
+  // stable_sort interface
+
+
+  // Sequential fallback
+  template<typename _RAIter>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::sequential_tag)
+  { _GLIBCXX_STD_A::stable_sort(__begin, __end); }
+
+  // Sequential fallback
+  template<typename _RAIter, typename _Compare>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              _Compare __comp, __gnu_parallel::sequential_tag)
+  { _GLIBCXX_STD_A::stable_sort<_RAIter, _Compare>(
+      __begin, __end, __comp); }
+
+  // Public interface
+  template<typename _RAIter, typename _Compare,
+           typename _Parallelism>
+  void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              _Compare __comp, _Parallelism __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+
+    if (__begin != __end)
+      {
+        if (_GLIBCXX_PARALLEL_CONDITION(
+              static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >=
+              __gnu_parallel::_Settings::get().sort_minimal_n))
+          __gnu_parallel::__parallel_sort<true>(
+                            __begin, __end, __comp, __parallelism);
+        else
+          stable_sort(__begin, __end, __comp,
+                      __gnu_parallel::sequential_tag());
+      }
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(),
+                __gnu_parallel::default_parallel_tag());
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::default_parallel_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::parallel_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::multiway_mergesort_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::quicksort_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+  inline void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::balanced_quicksort_tag __parallelism)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
+  }
+
+  // Public interface
+  template<typename _RAIter, typename _Compare>
+  void
+  stable_sort(_RAIter __begin, _RAIter __end,
+              _Compare __comp)
+  {
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(
+      __begin, __end, __comp, __gnu_parallel::default_parallel_tag());
+  }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _IIter2 __end2, _OutputIterator __result,
+          __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::merge(
+               __begin1, __end1, __begin2, __end2, __result); }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+          _IIter2 __end2, _OutputIterator __result, _Compare __comp,
+          __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::merge(
+                __begin1, __end1, __begin2, __end2, __result, __comp); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2, typename _OutputIterator,
+           typename _Compare, typename _IteratorTag1,
+           typename _IteratorTag2, typename _IteratorTag3>
+    inline _OutputIterator
+    __merge_switch(_IIter1 __begin1, _IIter1 __end1,
+                 _IIter2 __begin2, _IIter2 __end2,
+                 _OutputIterator __result, _Compare __comp,
+                 _IteratorTag1, _IteratorTag2, _IteratorTag3)
+     { return _GLIBCXX_STD_A::merge(__begin1, __end1, __begin2, __end2,
+                                    __result, __comp); }
+
+  // Parallel algorithm for random access iterators
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    __merge_switch(_IIter1 __begin1, _IIter1 __end1, 
+                 _IIter2 __begin2, _IIter2 __end2, 
+                 _OutputIterator __result, _Compare __comp, 
+                 random_access_iterator_tag, random_access_iterator_tag, 
+                 random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            (static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
+             >= __gnu_parallel::_Settings::get().merge_minimal_n
+             || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
+             >= __gnu_parallel::_Settings::get().merge_minimal_n)))
+        return __gnu_parallel::__parallel_merge_advance(
+                 __begin1, __end1, __begin2, __end2, __result,
+                 (__end1 - __begin1) + (__end2 - __begin2), __comp);
+      else
+        return __gnu_parallel::__merge_advance(
+                 __begin1, __end1, __begin2, __end2, __result,
+                 (__end1 - __begin1) + (__end2 - __begin2), __comp);
+  }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _IIter2 __end2, _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_IIter1>::value_type _ValueType;
+
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __merge_switch(
+              __begin1, __end1, __begin2, __end2, __result, __comp,
+              _IIterCategory1(), _IIterCategory2(), _OIterCategory());
+  }
+
+
+  // Public interface, insert default comparator
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _IIter2 __end2, _OutputIterator __result)
+    {
+      typedef std::iterator_traits<_IIter1> _Iterator1Traits;
+      typedef std::iterator_traits<_IIter2> _Iterator2Traits;
+      typedef typename _Iterator1Traits::value_type _ValueType1;
+      typedef typename _Iterator2Traits::value_type _ValueType2;
+
+      return __gnu_parallel::merge(__begin1, __end1, __begin2, __end2,
+                  __result, __gnu_parallel::_Less<_ValueType1, _ValueType2>());
+    }
+
+  // Sequential fallback
+  template<typename _RAIter>
+    inline void
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end); }
+
+  // Sequential fallback
+  template<typename _RAIter, typename _Compare>
+    inline void
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end, _Compare __comp, 
+              __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end, __comp); }
+
+  // Public interface
+  template<typename _RAIter, typename _Compare>
+    inline void
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end, _Compare __comp)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().nth_element_minimal_n))
+        __gnu_parallel::__parallel_nth_element(__begin, __nth, __end, __comp);
+      else
+        nth_element(__begin, __nth, __end, __comp,
+                    __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+    inline void
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      __gnu_parallel::nth_element(__begin, __nth, __end,
+                                  std::less<_ValueType>());
+    }
+
+  // Sequential fallback
+  template<typename _RAIter, typename _Compare>
+    inline void
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end, _Compare __comp,
+                 __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end, __comp); }
+
+  // Sequential fallback
+  template<typename _RAIter>
+    inline void
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end, __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end); }
+
+  // Public interface, parallel algorithm for random access iterators
+  template<typename _RAIter, typename _Compare>
+    void
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end, _Compare __comp)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().partial_sort_minimal_n))
+        __gnu_parallel::
+          __parallel_partial_sort(__begin, __middle, __end, __comp);
+      else
+        partial_sort(__begin, __middle, __end, __comp,
+                     __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface, insert default comparator
+  template<typename _RAIter>
+    inline void
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end)
+    {
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      __gnu_parallel::partial_sort(__begin, __middle, __end,
+                                   std::less<_ValueType>());
+    }
+
+  // Sequential fallback
+  template<typename _FIterator>
+    inline _FIterator
+    max_element(_FIterator __begin, _FIterator __end, 
+                __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::max_element(__begin, __end); }
+
+  // Sequential fallback
+  template<typename _FIterator, typename _Compare>
+    inline _FIterator
+    max_element(_FIterator __begin, _FIterator __end, _Compare __comp, 
+                __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::max_element(__begin, __end, __comp); }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator, typename _Compare, typename _IteratorTag>
+    inline _FIterator
+    __max_element_switch(_FIterator __begin, _FIterator __end, 
+                       _Compare __comp, _IteratorTag)
+    { return max_element(__begin, __end, __comp,
+                         __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    __max_element_switch(_RAIter __begin, _RAIter __end, 
+                       _Compare __comp, random_access_iterator_tag, 
+                       __gnu_parallel::_Parallelism __parallelism_tag
+                       = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().max_element_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          _RAIter __res(__begin);
+          __gnu_parallel::__identity_selector<_RAIter>
+            __functionality;
+          __gnu_parallel::
+            __for_each_template_random_access(
+              __begin, __end, __gnu_parallel::_Nothing(), __functionality,
+              __gnu_parallel::__max_element_reduct<_Compare, _RAIter>(__comp),
+              __res, __res, -1, __parallelism_tag);
+          return __res;
+        }
+      else
+        return max_element(__begin, __end, __comp,
+                           __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface, insert default comparator
+  template<typename _FIterator>
+    inline _FIterator
+    max_element(_FIterator __begin, _FIterator __end, 
+                __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef typename iterator_traits<_FIterator>::value_type _ValueType;
+      return max_element(__begin, __end, std::less<_ValueType>(),
+                         __parallelism_tag);
+    }
+
+  template<typename _FIterator>
+    inline _FIterator
+    max_element(_FIterator __begin, _FIterator __end)
+    {
+      typedef typename iterator_traits<_FIterator>::value_type _ValueType;
+      return __gnu_parallel::max_element(__begin, __end,
+                                         std::less<_ValueType>());
+    }
+
+  // Public interface
+  template<typename _FIterator, typename _Compare>
+    inline _FIterator
+    max_element(_FIterator __begin, _FIterator __end, _Compare __comp,
+                __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __max_element_switch(__begin, __end, __comp, _IteratorCategory(), 
+                                  __parallelism_tag);
+    }
+
+  template<typename _FIterator, typename _Compare>
+    inline _FIterator
+    max_element(_FIterator __begin, _FIterator __end, _Compare __comp)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __max_element_switch(__begin, __end, __comp, _IteratorCategory());
+    }
+
+
+  // Sequential fallback
+  template<typename _FIterator>
+    inline _FIterator
+    min_element(_FIterator __begin, _FIterator __end, 
+                __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::min_element(__begin, __end); }
+
+  // Sequential fallback
+  template<typename _FIterator, typename _Compare>
+    inline _FIterator
+    min_element(_FIterator __begin, _FIterator __end, _Compare __comp, 
+                __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::min_element(__begin, __end, __comp); }
+
+  // Sequential fallback for input iterator case
+  template<typename _FIterator, typename _Compare, typename _IteratorTag>
+    inline _FIterator
+    __min_element_switch(_FIterator __begin, _FIterator __end, 
+                       _Compare __comp, _IteratorTag)
+    { return min_element(__begin, __end, __comp,
+                         __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    __min_element_switch(_RAIter __begin, _RAIter __end, 
+                       _Compare __comp, random_access_iterator_tag, 
+                       __gnu_parallel::_Parallelism __parallelism_tag
+                       = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().min_element_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          _RAIter __res(__begin);
+          __gnu_parallel::__identity_selector<_RAIter>
+            __functionality;
+          __gnu_parallel::
+            __for_each_template_random_access(
+              __begin, __end, __gnu_parallel::_Nothing(), __functionality,
+              __gnu_parallel::__min_element_reduct<_Compare, _RAIter>(__comp),
+              __res, __res, -1, __parallelism_tag);
+          return __res;
+        }
+      else
+        return min_element(__begin, __end, __comp,
+                           __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface, insert default comparator
+  template<typename _FIterator>
+    inline _FIterator
+    min_element(_FIterator __begin, _FIterator __end, 
+                __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef typename iterator_traits<_FIterator>::value_type _ValueType;
+      return min_element(__begin, __end, std::less<_ValueType>(),
+                         __parallelism_tag);
+    }
+
+  template<typename _FIterator>
+    inline _FIterator
+    min_element(_FIterator __begin, _FIterator __end)
+    {
+      typedef typename iterator_traits<_FIterator>::value_type _ValueType;
+      return __gnu_parallel::min_element(__begin, __end,
+                                         std::less<_ValueType>());
+    }
+
+  // Public interface
+  template<typename _FIterator, typename _Compare>
+    inline _FIterator
+    min_element(_FIterator __begin, _FIterator __end, _Compare __comp,
+                __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __min_element_switch(__begin, __end, __comp, _IteratorCategory(), 
+                                __parallelism_tag);
+    }
+
+  template<typename _FIterator, typename _Compare>
+    inline _FIterator
+    min_element(_FIterator __begin, _FIterator __end, _Compare __comp)
+    {
+      typedef iterator_traits<_FIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __min_element_switch(__begin, __end, __comp, _IteratorCategory());
+    }
+} // end namespace
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_ALGO_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/algobase.h b/gcc-4.9/libstdc++-v3/include/parallel/algobase.h
new file mode 100644
index 0000000..2dcd532
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/algobase.h
@@ -0,0 +1,432 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/algobase.h
+ *  @brief Parallel STL function calls corresponding to the
+ *  stl_algobase.h header.  The functions defined here mainly do case
+ *  switches and call the actual parallelized versions in other files.
+ *  Inlining policy: Functions that basically only contain one
+ *  function call, are declared inline.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler and Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_ALGOBASE_H
+#define _GLIBCXX_PARALLEL_ALGOBASE_H 1
+
+#include <bits/stl_algobase.h>
+#include <parallel/base.h>
+#include <parallel/algorithmfwd.h>
+#include <parallel/find.h>
+#include <parallel/find_selectors.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __parallel
+{
+  // NB: equal and lexicographical_compare require mismatch.
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+             __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2); }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+             _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
+    inline pair<_IIter1, _IIter2>
+    __mismatch_switch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+                      _Predicate __pred, _IteratorTag1, _IteratorTag2)
+    { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred); }
+
+  // Parallel mismatch for random access iterators
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
+    pair<_RAIter1, _RAIter2>
+    __mismatch_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                      _RAIter2 __begin2, _Predicate __pred, 
+                      random_access_iterator_tag, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        {
+          _RAIter1 __res =
+            __gnu_parallel::__find_template(__begin1, __end1, __begin2, __pred,
+                                            __gnu_parallel::
+                                            __mismatch_selector()).first;
+          return make_pair(__res , __begin2 + (__res - __begin1));
+        }
+      else
+        return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred);
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2)
+    {
+      typedef __gnu_parallel::_EqualTo<
+	typename std::iterator_traits<_IIter1>::value_type,
+	typename std::iterator_traits<_IIter2>::value_type> _EqualTo;
+
+      return __mismatch_switch(__begin1, __end1, __begin2, _EqualTo(),
+                               std::__iterator_category(__begin1),
+			       std::__iterator_category(__begin2));
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+             _Predicate __pred)
+    {
+      return __mismatch_switch(__begin1, __end1, __begin2, __pred,
+                               std::__iterator_category(__begin1),
+			       std::__iterator_category(__begin2));
+    }
+
+#if __cplusplus > 201103L
+  // Sequential fallback.
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2,
+	     __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::mismatch(__first1, __last1, __first2, __last2); }
+
+  // Sequential fallback.
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+	     _InputIterator2 __first2, _InputIterator2 __last2,
+	     _BinaryPredicate __binary_pred,
+	     __gnu_parallel::sequential_tag)
+    {
+      return _GLIBCXX_STD_A::mismatch(__first1, __last1, __first2, __last2,
+				      __binary_pred);
+    }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
+    inline pair<_IIter1, _IIter2>
+    __mismatch_switch(_IIter1 __begin1, _IIter1 __end1,
+		      _IIter2 __begin2, _IIter2 __end2, _Predicate __pred,
+		      _IteratorTag1, _IteratorTag2)
+    {
+      return _GLIBCXX_STD_A::mismatch(__begin1, __end1,
+				      __begin2, __end2, __pred);
+    }
+
+  // Parallel mismatch for random access iterators
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
+    pair<_RAIter1, _RAIter2>
+    __mismatch_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                      _RAIter2 __begin2, _RAIter2 __end2, _Predicate __pred, 
+                      random_access_iterator_tag, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        {
+	  if ((__end2 - __begin2) < (__end1 - __begin1))
+	    __end1 = __begin1 + (__end2 - __begin2);
+
+          _RAIter1 __res =
+            __gnu_parallel::__find_template(__begin1, __end1, __begin2, __pred,
+                                            __gnu_parallel::
+                                            __mismatch_selector()).first;
+          return make_pair(__res , __begin2 + (__res - __begin1));
+        }
+      else
+        return _GLIBCXX_STD_A::mismatch(__begin1, __end1,
+					__begin2, __end2, __pred);
+    }
+
+  template<typename _IIter1, typename _IIter2>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2)
+    {
+      typedef __gnu_parallel::_EqualTo<
+	typename std::iterator_traits<_IIter1>::value_type,
+	typename std::iterator_traits<_IIter2>::value_type> _EqualTo;
+
+      return __mismatch_switch(__begin1, __end1, __begin2, __end2, _EqualTo(),
+			       std::__iterator_category(__begin1),
+			       std::__iterator_category(__begin2));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __begin1, _InputIterator1 __end1,
+	     _InputIterator2 __begin2, _InputIterator2 __end2,
+	     _BinaryPredicate __binary_pred)
+    {
+      return __mismatch_switch(__begin1, __end1, __begin2, __end2,
+			       __binary_pred,
+			       std::__iterator_category(__begin1),
+			       std::__iterator_category(__begin2));
+    }
+#endif
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2); }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2, __pred); }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2)
+    {
+      return __gnu_parallel::mismatch(__begin1, __end1, __begin2).first
+              == __end1;
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _Predicate __pred)
+    {
+      return __gnu_parallel::mismatch(__begin1, __end1, __begin2, __pred).first
+              == __end1;
+    }
+
+#if __cplusplus > 201103L
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
+	  __gnu_parallel::sequential_tag)
+    {
+      return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2, __end2);
+    }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1,
+	  _IIter2 __begin2, _IIter2 __end2, _BinaryPredicate __binary_pred,
+	  __gnu_parallel::sequential_tag)
+    {
+      return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2, __end2,
+				   __binary_pred);
+    }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
+    inline bool
+    __equal_switch(_IIter1 __begin1, _IIter1 __end1,
+		   _IIter2 __begin2, _IIter2 __end2, _Predicate __pred,
+		   _IteratorTag1, _IteratorTag2)
+    {
+      return _GLIBCXX_STD_A::equal(__begin1, __end1,
+				   __begin2, __end2, __pred);
+    }
+
+  // Parallel equal for random access iterators
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
+    inline bool
+    __equal_switch(_RAIter1 __begin1, _RAIter1 __end1,
+		   _RAIter2 __begin2, _RAIter2 __end2, _Predicate __pred, 
+		   random_access_iterator_tag, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        {
+	  if (std::distance(__begin1, __end1)
+	      != std::distance(__begin2, __end2))
+	    return false;
+
+	  return __gnu_parallel::mismatch(__begin1, __end1, __begin2, __end2,
+					  __pred).first == __end1;
+        }
+      else
+        return _GLIBCXX_STD_A::equal(__begin1, __end1,
+				     __begin2, __end2, __pred);
+    }
+
+  template<typename _IIter1, typename _IIter2>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2)
+    {
+      typedef __gnu_parallel::_EqualTo<
+	typename std::iterator_traits<_IIter1>::value_type,
+	typename std::iterator_traits<_IIter2>::value_type> _EqualTo;
+
+      return __equal_switch(__begin1, __end1, __begin2, __end2, _EqualTo(),
+			    std::__iterator_category(__begin1),
+			    std::__iterator_category(__begin2));
+    }
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __begin1, _IIter1 __end1,
+	  _IIter2 __begin2, _IIter2 __end2, _BinaryPredicate __binary_pred)
+    {
+      return __equal_switch(__begin1, __end1, __begin2, __end2, __binary_pred,
+			    std::__iterator_category(__begin1),
+			    std::__iterator_category(__begin2));
+    }
+#endif
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2>
+    inline bool
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
+                            _IIter2 __begin2, _IIter2 __end2, 
+                            __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::lexicographical_compare(__begin1, __end1,
+                                                     __begin2, __end2); }
+
+  // Sequential fallback
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    inline bool
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
+                            _IIter2 __begin2, _IIter2 __end2, 
+                            _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::lexicographical_compare(
+               __begin1, __end1, __begin2, __end2, __pred); }
+
+  // Sequential fallback for input iterator case
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
+    inline bool
+    __lexicographical_compare_switch(_IIter1 __begin1, _IIter1 __end1,
+                                     _IIter2 __begin2, _IIter2 __end2, 
+                                     _Predicate __pred,
+                                     _IteratorTag1, _IteratorTag2)
+    { return _GLIBCXX_STD_A::lexicographical_compare(
+               __begin1, __end1, __begin2, __end2, __pred); }
+
+  // Parallel lexicographical_compare for random access iterators
+  // Limitation: Both valuetypes must be the same
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
+    bool
+    __lexicographical_compare_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                                     _RAIter2 __begin2, _RAIter2 __end2,
+                                     _Predicate __pred,
+                                     random_access_iterator_tag, 
+                                     random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(true))
+        {
+          typedef iterator_traits<_RAIter1> _TraitsType1;
+          typedef typename _TraitsType1::value_type _ValueType1;
+
+          typedef iterator_traits<_RAIter2> _TraitsType2;
+          typedef typename _TraitsType2::value_type _ValueType2;
+
+          typedef __gnu_parallel::
+                  _EqualFromLess<_ValueType1, _ValueType2, _Predicate>
+                  _EqualFromLessCompare;
+
+          // Longer sequence in first place.
+          if ((__end1 - __begin1) < (__end2 - __begin2))
+            {
+              typedef pair<_RAIter1, _RAIter2> _SpotType;
+              _SpotType __mm = __mismatch_switch(__begin1, __end1, __begin2, 
+                                             _EqualFromLessCompare(__pred), 
+                                             random_access_iterator_tag(), 
+                                             random_access_iterator_tag());
+
+              return (__mm.first == __end1)
+                        || bool(__pred(*__mm.first, *__mm.second));
+            }
+          else
+            {
+              typedef pair<_RAIter2, _RAIter1> _SpotType;
+              _SpotType __mm = __mismatch_switch(__begin2, __end2, __begin1, 
+                                             _EqualFromLessCompare(__pred), 
+                                             random_access_iterator_tag(), 
+                                             random_access_iterator_tag());
+
+              return (__mm.first != __end2)
+                        && bool(__pred(*__mm.second, *__mm.first));
+            }
+        }
+      else
+        return _GLIBCXX_STD_A::lexicographical_compare(
+                 __begin1, __end1, __begin2, __end2, __pred);
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2>
+    inline bool
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
+                            _IIter2 __begin2, _IIter2 __end2)
+    {
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::value_type _ValueType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
+
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::value_type _ValueType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
+      typedef __gnu_parallel::_Less<_ValueType1, _ValueType2> _LessType;
+
+      return __lexicographical_compare_switch(
+               __begin1, __end1, __begin2, __end2, _LessType(),
+               _IteratorCategory1(), _IteratorCategory2());
+    }
+
+  // Public interface
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    inline bool
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
+                            _IIter2 __begin2, _IIter2 __end2,
+                            _Predicate __pred)
+    {
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
+
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
+
+      return __lexicographical_compare_switch(
+               __begin1, __end1, __begin2, __end2, __pred,
+               _IteratorCategory1(), _IteratorCategory2());
+    }
+} // end namespace
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_ALGOBASE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/algorithm b/gcc-4.9/libstdc++-v3/include/parallel/algorithm
new file mode 100644
index 0000000..e099abb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/algorithm
@@ -0,0 +1,39 @@
+// Algorithm extensions -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/algorithm
+ *  This file is a GNU extension to the Standard C++ Library.
+ */
+
+#ifndef _PARALLEL_ALGORITHM
+#define _PARALLEL_ALGORITHM 1
+
+#pragma GCC system_header
+
+#include <algorithm>
+#include <parallel/algorithmfwd.h>
+#include <parallel/algobase.h>
+#include <parallel/algo.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/algorithmfwd.h b/gcc-4.9/libstdc++-v3/include/parallel/algorithmfwd.h
new file mode 100644
index 0000000..2e5b51a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/algorithmfwd.h
@@ -0,0 +1,908 @@
+// <parallel/algorithm> Forward declarations -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/algorithmfwd.h
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PARALLEL_ALGORITHMFWD_H
+#define _GLIBCXX_PARALLEL_ALGORITHMFWD_H 1
+
+#pragma GCC system_header
+
+#include <parallel/tags.h>
+#include <parallel/settings.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __parallel
+{
+  template<typename _FIter>
+    _FIter
+    adjacent_find(_FIter, _FIter);
+
+  template<typename _FIter>
+    _FIter
+    adjacent_find(_FIter, _FIter, __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _IterTag>
+    _FIter
+    __adjacent_find_switch(_FIter, _FIter, _IterTag);
+
+  template<typename _RAIter>
+    _RAIter
+    __adjacent_find_switch(_RAIter, _RAIter, random_access_iterator_tag);
+
+
+  template<typename _FIter, typename _BiPredicate>
+    _FIter
+    adjacent_find(_FIter, _FIter, _BiPredicate);
+
+  template<typename _FIter, typename _BiPredicate>
+    _FIter
+    adjacent_find(_FIter, _FIter, _BiPredicate,
+                  __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _BiPredicate, typename _IterTag>
+    _FIter
+    __adjacent_find_switch(_FIter, _FIter, _BiPredicate, _IterTag);
+
+  template<typename _RAIter, typename _BiPredicate>
+    _RAIter
+    __adjacent_find_switch(_RAIter, _RAIter, _BiPredicate, 
+                         random_access_iterator_tag);
+
+
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&, __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _Tp, typename _IterTag>
+    typename iterator_traits<_IIter>::difference_type
+    __count_switch(_IIter, _IIter, const _Tp&, _IterTag);
+
+  template<typename _RAIter, typename _Tp>
+    typename iterator_traits<_RAIter>::difference_type
+    __count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag,
+                 __gnu_parallel::_Parallelism __parallelism
+                 = __gnu_parallel::parallel_unbalanced);
+
+
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate, __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _Predicate, typename _IterTag>
+    typename iterator_traits<_IIter>::difference_type
+    __count_if_switch(_IIter, _IIter, _Predicate, _IterTag);
+
+  template<typename _RAIter, typename _Predicate>
+    typename iterator_traits<_RAIter>::difference_type
+    __count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag,
+                    __gnu_parallel::_Parallelism __parallelism
+                    = __gnu_parallel::parallel_unbalanced);
+
+  // algobase.h
+  template<typename _IIter1, typename _IIter2>
+    bool
+    equal(_IIter1, _IIter1, _IIter2, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    bool
+    equal(_IIter1, _IIter1, _IIter2, _Predicate,
+          __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    equal(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    bool
+    equal(_IIter1, _IIter1, _IIter2, _Predicate);
+
+  template<typename _IIter, typename _Tp>
+    _IIter
+    find(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Tp>
+    _IIter
+    find(_IIter, _IIter, const _Tp& __val);
+
+  template<typename _IIter, typename _Tp, typename _IterTag>
+    _IIter
+    __find_switch(_IIter, _IIter, const _Tp&, _IterTag);
+
+  template<typename _RAIter, typename _Tp>
+    _RAIter
+    __find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag);
+
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Predicate, typename _IterTag>
+    _IIter
+    __find_if_switch(_IIter, _IIter, _Predicate, _IterTag);
+
+  template<typename _RAIter, typename _Predicate>
+    _RAIter
+    __find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag);
+
+  template<typename _IIter, typename _FIter>
+    _IIter
+    find_first_of(_IIter, _IIter, _FIter, _FIter,
+                  __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _FIter, typename _BiPredicate>
+    _IIter
+    find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
+                  __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _FIter, typename _BiPredicate>
+    _IIter
+    find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate);
+
+  template<typename _IIter, typename _FIter>
+    _IIter
+    find_first_of(_IIter, _IIter, _FIter, _FIter);
+
+  template<typename _IIter, typename _FIter,
+           typename _IterTag1, typename _IterTag2>
+    _IIter
+    __find_first_of_switch(
+      _IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2);
+
+  template<typename _RAIter, typename _FIter, typename _BiPredicate,
+           typename _IterTag>
+    _RAIter
+    __find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate,
+                         random_access_iterator_tag, _IterTag);
+
+  template<typename _IIter, typename _FIter, typename _BiPredicate,
+           typename _IterTag1, typename _IterTag2>
+    _IIter
+    __find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
+                         _IterTag1, _IterTag2);
+
+
+  template<typename _IIter, typename _Function>
+    _Function
+    for_each(_IIter, _IIter, _Function);
+
+  template<typename _IIter, typename _Function>
+    _Function
+    for_each(_IIter, _IIter, _Function, __gnu_parallel::sequential_tag);
+
+  template<typename _Iterator, typename _Function>
+    _Function
+    for_each(_Iterator, _Iterator, _Function, __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _Function, typename _IterTag>
+    _Function
+    __for_each_switch(_IIter, _IIter, _Function, _IterTag);
+
+  template<typename _RAIter, typename _Function>
+    _Function
+    __for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag,
+                    __gnu_parallel::_Parallelism  __parallelism
+                    = __gnu_parallel::parallel_balanced);
+
+
+  template<typename _FIter, typename _Generator>
+    void
+    generate(_FIter, _FIter, _Generator);
+
+  template<typename _FIter, typename _Generator>
+    void
+    generate(_FIter, _FIter, _Generator, __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _Generator>
+    void
+    generate(_FIter, _FIter, _Generator, __gnu_parallel::_Parallelism);
+
+  template<typename _FIter, typename _Generator, typename _IterTag>
+    void
+    __generate_switch(_FIter, _FIter, _Generator, _IterTag);
+
+  template<typename _RAIter, typename _Generator>
+    void
+    __generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag,
+                    __gnu_parallel::_Parallelism __parallelism
+                    = __gnu_parallel::parallel_balanced);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator, __gnu_parallel::sequential_tag);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator, __gnu_parallel::_Parallelism);
+
+  template<typename _OIter, typename _Size, typename _Generator,
+           typename _IterTag>
+    _OIter
+    __generate_n_switch(_OIter, _Size, _Generator, _IterTag);
+
+  template<typename _RAIter, typename _Size, typename _Generator>
+    _RAIter
+    __generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag,
+                      __gnu_parallel::_Parallelism __parallelism
+                      = __gnu_parallel::parallel_balanced);
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2,
+                            __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate,
+                            __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate);
+
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _IterTag1, typename _IterTag2>
+    bool
+    __lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+                                   _Predicate, _IterTag1, _IterTag2);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
+    bool
+    __lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+                                   _Predicate, random_access_iterator_tag,
+                                   random_access_iterator_tag);
+
+  // algo.h
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _Predicate,
+             __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _Predicate);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+           typename _IterTag1, typename _IterTag2>
+    pair<_IIter1, _IIter2>
+    __mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate,
+                    _IterTag1, _IterTag2);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
+    pair<_RAIter1, _RAIter2>
+    __mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate,
+                    random_access_iterator_tag, random_access_iterator_tag);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, __gnu_parallel::sequential_tag);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BiPredicate>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
+           __gnu_parallel::sequential_tag);
+
+  template<typename _FIter1, typename _FIter2, typename _BiPredicate>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate);
+
+  template<typename _RAIter1, typename _RAIter2>
+    _RAIter1
+    __search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+                  random_access_iterator_tag, random_access_iterator_tag);
+
+  template<typename _FIter1, typename _FIter2, typename _IterTag1,
+           typename _IterTag2>
+    _FIter1
+    __search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2);
+
+  template<typename _RAIter1, typename _RAIter2, typename _BiPredicate>
+    _RAIter1
+    __search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate,
+                  random_access_iterator_tag, random_access_iterator_tag);
+
+  template<typename _FIter1, typename _FIter2, typename _BiPredicate,
+           typename _IterTag1, typename _IterTag2>
+    _FIter1
+    __search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
+                  _IterTag1, _IterTag2);
+
+  template<typename _FIter, typename _Integer, typename _Tp>
+    _FIter
+    search_n(_FIter, _FIter, _Integer, const _Tp&,
+             __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _Integer, typename _Tp,
+           typename _BiPredicate>
+    _FIter
+    search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate,
+             __gnu_parallel::sequential_tag);
+    
+  template<typename _FIter, typename _Integer, typename _Tp>
+    _FIter
+    search_n(_FIter, _FIter, _Integer, const _Tp&);
+
+  template<typename _FIter, typename _Integer, typename _Tp,
+           typename _BiPredicate>
+    _FIter
+    search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate);
+
+  template<typename _RAIter, typename _Integer, typename _Tp,
+           typename _BiPredicate>
+    _RAIter
+    __search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&,
+                    _BiPredicate, random_access_iterator_tag);
+
+  template<typename _FIter, typename _Integer, typename _Tp,
+           typename _BiPredicate, typename _IterTag>
+    _FIter
+    __search_n_switch(_FIter, _FIter, _Integer, const _Tp&,
+                    _BiPredicate, _IterTag);
+
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation, 
+              __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation, 
+              __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation,
+           typename _IterTag1, typename _IterTag2>
+    _OIter
+    __transform1_switch(_IIter, _IIter, _OIter, _UnaryOperation, 
+                      _IterTag1, _IterTag2);
+    
+
+  template<typename _RAIIter, typename _RAOIter, typename _UnaryOperation>
+    _RAOIter
+    __transform1_switch(_RAIIter, _RAIIter, _RAOIter, _UnaryOperation, 
+                      random_access_iterator_tag, random_access_iterator_tag, 
+                      __gnu_parallel::_Parallelism __parallelism
+                      = __gnu_parallel::parallel_balanced);
+
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _BiOperation>
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _BiOperation>
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
+              __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _BiOperation>
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
+              __gnu_parallel::_Parallelism);
+
+  template<typename _RAIter1, typename _RAIter2, typename _RAIter3,
+           typename _BiOperation>
+    _RAIter3
+    __transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
+                      random_access_iterator_tag, random_access_iterator_tag, 
+                      random_access_iterator_tag,
+                      __gnu_parallel::_Parallelism __parallelism
+                      = __gnu_parallel::parallel_balanced);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _BiOperation, typename _Tag1,
+           typename _Tag2, typename _Tag3>
+    _OIter
+    __transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
+                      _Tag1, _Tag2, _Tag3);
+
+
+  template<typename _FIter, typename _Tp>
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+
+  template<typename _FIter, typename _Tp>
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&, 
+            __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _Tp>
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&,
+            __gnu_parallel::_Parallelism);
+
+  template<typename _FIter, typename _Tp, typename _IterTag>
+    void
+    __replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag);
+
+  template<typename _RAIter, typename _Tp>
+    void
+    __replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, 
+                   random_access_iterator_tag, __gnu_parallel::_Parallelism);
+
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&,
+               __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&,
+               __gnu_parallel::_Parallelism);
+
+  template<typename _FIter, typename _Predicate, typename _Tp,
+           typename _IterTag>
+    void
+    __replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag);
+ 
+  template<typename _RAIter, typename _Predicate, typename _Tp>
+    void
+    __replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&,
+                      random_access_iterator_tag,
+                      __gnu_parallel::_Parallelism);
+
+
+  template<typename _FIter>
+    _FIter
+    max_element(_FIter, _FIter);
+
+  template<typename _FIter>
+    _FIter
+    max_element(_FIter, _FIter, __gnu_parallel::sequential_tag);
+
+  template<typename _FIter>
+    _FIter
+    max_element(_FIter, _FIter, __gnu_parallel::_Parallelism);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    max_element(_FIter, _FIter, _Compare);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    max_element(_FIter, _FIter, _Compare, __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    max_element(_FIter, _FIter, _Compare, __gnu_parallel::_Parallelism);
+
+  template<typename _FIter, typename _Compare, typename _IterTag>
+    _FIter
+    __max_element_switch(_FIter, _FIter, _Compare, _IterTag);
+
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    __max_element_switch(
+      _RAIter, _RAIter, _Compare, random_access_iterator_tag,
+      __gnu_parallel::_Parallelism __parallelism
+      = __gnu_parallel::parallel_balanced);
+
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, 
+          __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Compare>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
+          __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Compare>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Compare, typename _IterTag1, typename _IterTag2,
+           typename _IterTag3>
+    _OIter
+    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
+                 _IterTag1, _IterTag2, _IterTag3);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Compare>
+    _OIter
+    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
+                 random_access_iterator_tag, random_access_iterator_tag, 
+                 random_access_iterator_tag);
+
+
+  template<typename _FIter>
+    _FIter
+    min_element(_FIter, _FIter);
+
+  template<typename _FIter>
+    _FIter
+    min_element(_FIter, _FIter, __gnu_parallel::sequential_tag);
+
+  template<typename _FIter>
+    _FIter
+    min_element(_FIter, _FIter,
+                __gnu_parallel::_Parallelism __parallelism_tag);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    min_element(_FIter, _FIter, _Compare);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    min_element(_FIter, _FIter, _Compare, __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    min_element(_FIter, _FIter, _Compare, __gnu_parallel::_Parallelism);
+
+  template<typename _FIter, typename _Compare, typename _IterTag>
+    _FIter
+    __min_element_switch(_FIter, _FIter, _Compare, _IterTag);
+
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    __min_element_switch(
+      _RAIter, _RAIter, _Compare, random_access_iterator_tag,
+      __gnu_parallel::_Parallelism __parallelism
+      = __gnu_parallel::parallel_balanced);
+
+  template<typename _RAIter>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare,
+                __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare,
+                 __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter);
+
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    partition(_FIter, _FIter, _Predicate, __gnu_parallel::sequential_tag);
+    
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    partition(_FIter, _FIter, _Predicate);
+
+  template<typename _FIter, typename _Predicate, typename _IterTag>
+    _FIter
+    __partition_switch(_FIter, _FIter, _Predicate, _IterTag);
+    
+  template<typename _RAIter, typename _Predicate>
+    _RAIter
+    __partition_switch(
+      _RAIter, _RAIter, _Predicate, random_access_iterator_tag);
+
+  template<typename _RAIter>
+    void
+    random_shuffle(_RAIter, _RAIter, __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RAIter, _RAIter, _RandomNumberGenerator&,
+                   __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter>
+    void
+    random_shuffle(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RAIter, _RAIter,
+#if __cplusplus >= 201103L
+		   _RandomNumberGenerator&&);
+#else
+		   _RandomNumberGenerator&);
+#endif
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+            __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
+              __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter 
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+           typename _OIter, typename _IterTag1, typename _IterTag2,
+           typename _IterTag3>
+    _OIter
+    __set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                     _Predicate, _IterTag1, _IterTag2, _IterTag3);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+           typename _Predicate>
+    _Output_RAIter
+    __set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter,
+                     _Predicate, random_access_iterator_tag,
+                     random_access_iterator_tag, random_access_iterator_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                     __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
+                     __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter 
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+           typename _OIter, typename _IterTag1, typename _IterTag2,
+           typename _IterTag3>
+    _OIter
+    __set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                            _Predicate, _IterTag1, _IterTag2, _IterTag3);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+           typename _Predicate>
+    _Output_RAIter
+    __set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+                            _Output_RAIter, _Predicate,
+                            random_access_iterator_tag,
+                            random_access_iterator_tag,
+                            random_access_iterator_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                             __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                             _Predicate, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter 
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter 
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                             _Predicate);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+           typename _OIter, typename _IterTag1, typename _IterTag2,
+           typename _IterTag3>
+    _OIter
+    __set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+                                    _OIter, _Predicate, _IterTag1, _IterTag2,
+                                    _IterTag3);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+           typename _Predicate>
+    _Output_RAIter
+    __set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+                                    _Output_RAIter, _Predicate,
+                                    random_access_iterator_tag,
+                                    random_access_iterator_tag,
+                                    random_access_iterator_tag);
+
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                   __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
+                   __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+           typename _Predicate>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+           typename _OIter, typename _IterTag1, typename _IterTag2,
+           typename _IterTag3>
+    _OIter
+    __set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+                          _Predicate, _IterTag1, _IterTag2, _IterTag3);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+           typename _Predicate>
+    _Output_RAIter
+    __set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+                          _Output_RAIter, _Predicate,
+                          random_access_iterator_tag,
+                          random_access_iterator_tag,
+                          random_access_iterator_tag);
+
+
+  template<typename _RAIter>
+    void
+    sort(_RAIter, _RAIter, __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    sort(_RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter>
+    void
+    sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    stable_sort(_RAIter, _RAIter, __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    stable_sort(_RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
+
+  template<typename _RAIter>
+    void
+    stable_sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    stable_sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, _Predicate,
+                __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter);
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, _Predicate);
+
+  template<typename _IIter, typename _OIter, typename _Predicate,
+           typename _IterTag1, typename _IterTag2>
+    _OIter
+    __unique_copy_switch(_IIter, _IIter, _OIter, _Predicate,
+                       _IterTag1, _IterTag2);
+
+  template<typename _RAIter, typename _RandomAccess_OIter, typename _Predicate>
+    _RandomAccess_OIter
+    __unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate,
+                       random_access_iterator_tag, random_access_iterator_tag);
+} // end namespace __parallel
+} // end namespace std
+
+#endif /* _GLIBCXX_PARALLEL_ALGORITHMFWD_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/balanced_quicksort.h b/gcc-4.9/libstdc++-v3/include/parallel/balanced_quicksort.h
new file mode 100644
index 0000000..1ddd7fc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/balanced_quicksort.h
@@ -0,0 +1,492 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/balanced_quicksort.h
+ *  @brief Implementation of a dynamically load-balanced parallel quicksort.
+ *
+ *  It works in-place and needs only logarithmic extra memory.
+ *  The algorithm is similar to the one proposed in
+ *
+ *  P. Tsigas and Y. Zhang.
+ *  A simple, fast parallel implementation of quicksort and
+ *  its performance evaluation on SUN enterprise 10000.
+ *  In 11th Euromicro Conference on Parallel, Distributed and
+ *  Network-Based Processing, page 372, 2003.
+ *
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_BALANCED_QUICKSORT_H
+#define _GLIBCXX_PARALLEL_BALANCED_QUICKSORT_H 1
+
+#include <parallel/basic_iterator.h>
+#include <bits/stl_algo.h>
+#include <bits/stl_function.h>
+
+#include <parallel/settings.h>
+#include <parallel/partition.h>
+#include <parallel/random_number.h>
+#include <parallel/queue.h>
+
+#if _GLIBCXX_ASSERTIONS
+#include <parallel/checkers.h>
+#endif
+
+namespace __gnu_parallel
+{
+  /** @brief Information local to one thread in the parallel quicksort run. */
+  template<typename _RAIter>
+    struct _QSBThreadLocal
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      /** @brief Continuous part of the sequence, described by an
+      iterator pair. */
+      typedef std::pair<_RAIter, _RAIter> _Piece;
+
+      /** @brief Initial piece to work on. */
+      _Piece _M_initial;
+
+      /** @brief Work-stealing queue. */
+      _RestrictedBoundedConcurrentQueue<_Piece> _M_leftover_parts;
+
+      /** @brief Number of threads involved in this algorithm. */
+      _ThreadIndex _M_num_threads;
+
+      /** @brief Pointer to a counter of elements left over to sort. */
+      volatile _DifferenceType* _M_elements_leftover;
+
+      /** @brief The complete sequence to sort. */
+      _Piece _M_global;
+
+      /** @brief Constructor.
+       *  @param __queue_size size of the work-stealing queue. */
+      _QSBThreadLocal(int __queue_size) : _M_leftover_parts(__queue_size) { }
+    };
+
+  /** @brief Balanced quicksort divide step.
+    *  @param __begin Begin iterator of subsequence.
+    *  @param __end End iterator of subsequence.
+    *  @param __comp Comparator.
+    *  @param __num_threads Number of threads that are allowed to work on
+    *  this part.
+    *  @pre @c (__end-__begin)>=1 */
+  template<typename _RAIter, typename _Compare>
+    typename std::iterator_traits<_RAIter>::difference_type
+    __qsb_divide(_RAIter __begin, _RAIter __end,
+		 _Compare __comp, _ThreadIndex __num_threads)
+    {
+      _GLIBCXX_PARALLEL_ASSERT(__num_threads > 0);
+
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _RAIter __pivot_pos =
+	__median_of_three_iterators(__begin, __begin + (__end - __begin) / 2,
+				    __end  - 1, __comp);
+
+#if defined(_GLIBCXX_ASSERTIONS)
+      // Must be in between somewhere.
+      _DifferenceType __n = __end - __begin;
+
+      _GLIBCXX_PARALLEL_ASSERT((!__comp(*__pivot_pos, *__begin)
+				&& !__comp(*(__begin + __n / 2),
+					   *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *__begin)
+				   && !__comp(*(__end - 1), *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__begin + __n / 2))
+				   && !__comp(*__begin, *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__begin + __n / 2))
+				   && !__comp(*(__end - 1), *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__end - 1))
+				   && !__comp(*__begin, *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__end - 1))
+				   && !__comp(*(__begin + __n / 2),
+					      *__pivot_pos)));
+#endif
+
+      // Swap pivot value to end.
+      if (__pivot_pos != (__end - 1))
+	std::iter_swap(__pivot_pos, __end - 1);
+      __pivot_pos = __end - 1;
+
+      __gnu_parallel::__binder2nd<_Compare, _ValueType, _ValueType, bool>
+	__pred(__comp, *__pivot_pos);
+
+      // Divide, returning __end - __begin - 1 in the worst case.
+      _DifferenceType __split_pos = __parallel_partition(__begin, __end - 1,
+							 __pred,
+							 __num_threads);
+
+      // Swap back pivot to middle.
+      std::iter_swap(__begin + __split_pos, __pivot_pos);
+      __pivot_pos = __begin + __split_pos;
+
+#if _GLIBCXX_ASSERTIONS
+      _RAIter __r;
+      for (__r = __begin; __r != __pivot_pos; ++__r)
+	_GLIBCXX_PARALLEL_ASSERT(__comp(*__r, *__pivot_pos));
+      for (; __r != __end; ++__r)
+	_GLIBCXX_PARALLEL_ASSERT(!__comp(*__r, *__pivot_pos));
+#endif
+
+      return __split_pos;
+    }
+
+  /** @brief Quicksort conquer step.
+    *  @param __tls Array of thread-local storages.
+    *  @param __begin Begin iterator of subsequence.
+    *  @param __end End iterator of subsequence.
+    *  @param __comp Comparator.
+    *  @param __iam Number of the thread processing this function.
+    *  @param __num_threads
+    *          Number of threads that are allowed to work on this part. */
+  template<typename _RAIter, typename _Compare>
+    void
+    __qsb_conquer(_QSBThreadLocal<_RAIter>** __tls,
+		  _RAIter __begin, _RAIter __end,
+		  _Compare __comp,
+		  _ThreadIndex __iam, _ThreadIndex __num_threads,
+		  bool __parent_wait)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __n = __end - __begin;
+
+      if (__num_threads <= 1 || __n <= 1)
+	{
+          __tls[__iam]->_M_initial.first  = __begin;
+          __tls[__iam]->_M_initial.second = __end;
+
+          __qsb_local_sort_with_helping(__tls, __comp, __iam, __parent_wait);
+
+          return;
+	}
+
+      // Divide step.
+      _DifferenceType __split_pos =
+	__qsb_divide(__begin, __end, __comp, __num_threads);
+
+#if _GLIBCXX_ASSERTIONS
+      _GLIBCXX_PARALLEL_ASSERT(0 <= __split_pos &&
+                               __split_pos < (__end - __begin));
+#endif
+
+      _ThreadIndex
+	__num_threads_leftside = std::max<_ThreadIndex>
+	(1, std::min<_ThreadIndex>(__num_threads - 1, __split_pos
+				   * __num_threads / __n));
+
+#     pragma omp atomic
+      *__tls[__iam]->_M_elements_leftover -= (_DifferenceType)1;
+
+      // Conquer step.
+#     pragma omp parallel num_threads(2)
+      {
+	bool __wait;
+	if(omp_get_num_threads() < 2)
+          __wait = false;
+	else
+          __wait = __parent_wait;
+
+#       pragma omp sections
+	{
+#         pragma omp section
+	  {
+	    __qsb_conquer(__tls, __begin, __begin + __split_pos, __comp,
+			  __iam, __num_threads_leftside, __wait);
+	    __wait = __parent_wait;
+	  }
+	  // The pivot_pos is left in place, to ensure termination.
+#         pragma omp section
+	  {
+	    __qsb_conquer(__tls, __begin + __split_pos + 1, __end, __comp,
+			  __iam + __num_threads_leftside,
+			  __num_threads - __num_threads_leftside, __wait);
+	    __wait = __parent_wait;
+	  }
+	}
+      }
+    }
+
+  /**
+    *  @brief Quicksort step doing load-balanced local sort.
+    *  @param __tls Array of thread-local storages.
+    *  @param __comp Comparator.
+    *  @param __iam Number of the thread processing this function.
+    */
+  template<typename _RAIter, typename _Compare>
+    void
+    __qsb_local_sort_with_helping(_QSBThreadLocal<_RAIter>** __tls,
+				  _Compare& __comp, _ThreadIndex __iam,
+				  bool __wait)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef std::pair<_RAIter, _RAIter> _Piece;
+
+      _QSBThreadLocal<_RAIter>& __tl = *__tls[__iam];
+
+      _DifferenceType
+	__base_case_n = _Settings::get().sort_qsb_base_case_maximal_n;
+      if (__base_case_n < 2)
+	__base_case_n = 2;
+      _ThreadIndex __num_threads = __tl._M_num_threads;
+
+      // Every thread has its own random number generator.
+      _RandomNumber __rng(__iam + 1);
+
+      _Piece __current = __tl._M_initial;
+
+      _DifferenceType __elements_done = 0;
+#if _GLIBCXX_ASSERTIONS
+      _DifferenceType __total_elements_done = 0;
+#endif
+
+      for (;;)
+	{
+          // Invariant: __current must be a valid (maybe empty) range.
+          _RAIter __begin = __current.first, __end = __current.second;
+          _DifferenceType __n = __end - __begin;
+
+          if (__n > __base_case_n)
+            {
+              // Divide.
+              _RAIter __pivot_pos = __begin +  __rng(__n);
+
+              // Swap __pivot_pos value to end.
+              if (__pivot_pos != (__end - 1))
+        	std::iter_swap(__pivot_pos, __end - 1);
+              __pivot_pos = __end - 1;
+
+              __gnu_parallel::__binder2nd
+		<_Compare, _ValueType, _ValueType, bool>
+		__pred(__comp, *__pivot_pos);
+
+              // Divide, leave pivot unchanged in last place.
+              _RAIter __split_pos1, __split_pos2;
+              __split_pos1 = __gnu_sequential::partition(__begin, __end - 1,
+							 __pred);
+
+              // Left side: < __pivot_pos; __right side: >= __pivot_pos.
+#if _GLIBCXX_ASSERTIONS
+              _GLIBCXX_PARALLEL_ASSERT(__begin <= __split_pos1
+                                       && __split_pos1 < __end);
+#endif
+              // Swap pivot back to middle.
+              if (__split_pos1 != __pivot_pos)
+        	std::iter_swap(__split_pos1, __pivot_pos);
+              __pivot_pos = __split_pos1;
+
+              // In case all elements are equal, __split_pos1 == 0.
+              if ((__split_pos1 + 1 - __begin) < (__n >> 7)
+		  || (__end - __split_pos1) < (__n >> 7))
+        	{
+                  // Very unequal split, one part smaller than one 128th
+                  // elements not strictly larger than the pivot.
+                  __gnu_parallel::__unary_negate<__gnu_parallel::__binder1st
+                    <_Compare, _ValueType, _ValueType, bool>, _ValueType>
+                    __pred(__gnu_parallel::__binder1st
+                	 <_Compare, _ValueType, _ValueType, bool>
+			   (__comp, *__pivot_pos));
+
+                  // Find other end of pivot-equal range.
+                  __split_pos2 = __gnu_sequential::partition(__split_pos1 + 1,
+							     __end, __pred);
+        	}
+              else
+        	// Only skip the pivot.
+        	__split_pos2 = __split_pos1 + 1;
+
+              // Elements equal to pivot are done.
+              __elements_done += (__split_pos2 - __split_pos1);
+#if _GLIBCXX_ASSERTIONS
+              __total_elements_done += (__split_pos2 - __split_pos1);
+#endif
+              // Always push larger part onto stack.
+              if (((__split_pos1 + 1) - __begin) < (__end - (__split_pos2)))
+        	{
+                  // Right side larger.
+                  if ((__split_pos2) != __end)
+                    __tl._M_leftover_parts.push_front
+		      (std::make_pair(__split_pos2, __end));
+
+                  //__current.first = __begin;    //already set anyway
+                  __current.second = __split_pos1;
+                  continue;
+        	}
+              else
+        	{
+                  // Left side larger.
+                  if (__begin != __split_pos1)
+                    __tl._M_leftover_parts.push_front(std::make_pair
+						      (__begin, __split_pos1));
+
+                  __current.first = __split_pos2;
+                  //__current.second = __end;     //already set anyway
+                  continue;
+        	}
+            }
+          else
+            {
+              __gnu_sequential::sort(__begin, __end, __comp);
+              __elements_done += __n;
+#if _GLIBCXX_ASSERTIONS
+              __total_elements_done += __n;
+#endif
+
+              // Prefer own stack, small pieces.
+              if (__tl._M_leftover_parts.pop_front(__current))
+        	continue;
+
+#             pragma omp atomic
+              *__tl._M_elements_leftover -= __elements_done;
+
+              __elements_done = 0;
+
+#if _GLIBCXX_ASSERTIONS
+              double __search_start = omp_get_wtime();
+#endif
+
+              // Look for new work.
+              bool __successfully_stolen = false;
+              while (__wait && *__tl._M_elements_leftover > 0
+                     && !__successfully_stolen
+#if _GLIBCXX_ASSERTIONS
+                      // Possible dead-lock.
+                     && (omp_get_wtime() < (__search_start + 1.0))
+#endif
+		     )
+        	{
+                  _ThreadIndex __victim;
+                  __victim = __rng(__num_threads);
+
+                  // Large pieces.
+                  __successfully_stolen = (__victim != __iam)
+		    && __tls[__victim]->_M_leftover_parts.pop_back(__current);
+                  if (!__successfully_stolen)
+                    __yield();
+#if !defined(__ICC) && !defined(__ECC)
+#                 pragma omp flush
+#endif
+        	}
+
+#if _GLIBCXX_ASSERTIONS
+              if (omp_get_wtime() >= (__search_start + 1.0))
+        	{
+                  sleep(1);
+                  _GLIBCXX_PARALLEL_ASSERT(omp_get_wtime()
+                                           < (__search_start + 1.0));
+        	}
+#endif
+              if (!__successfully_stolen)
+        	{
+#if _GLIBCXX_ASSERTIONS
+                  _GLIBCXX_PARALLEL_ASSERT(*__tl._M_elements_leftover == 0);
+#endif
+                  return;
+        	}
+            }
+	}
+    }
+
+  /** @brief Top-level quicksort routine.
+    *  @param __begin Begin iterator of sequence.
+    *  @param __end End iterator of sequence.
+    *  @param __comp Comparator.
+    *  @param __num_threads Number of threads that are allowed to work on
+    *  this part.
+    */
+  template<typename _RAIter, typename _Compare>
+    void
+    __parallel_sort_qsb(_RAIter __begin, _RAIter __end,
+			_Compare __comp, _ThreadIndex __num_threads)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef std::pair<_RAIter, _RAIter> _Piece;
+
+      typedef _QSBThreadLocal<_RAIter> _TLSType;
+
+      _DifferenceType __n = __end - __begin;
+
+      if (__n <= 1)
+	return;
+
+      // At least one element per processor.
+      if (__num_threads > __n)
+	__num_threads = static_cast<_ThreadIndex>(__n);
+
+      // Initialize thread local storage
+      _TLSType** __tls = new _TLSType*[__num_threads];
+      _DifferenceType __queue_size = (__num_threads
+				      * (_ThreadIndex)(__rd_log2(__n) + 1));
+      for (_ThreadIndex __t = 0; __t < __num_threads; ++__t)
+	__tls[__t] = new _QSBThreadLocal<_RAIter>(__queue_size);
+
+      // There can never be more than ceil(__rd_log2(__n)) ranges on the
+      // stack, because
+      // 1. Only one processor pushes onto the stack
+      // 2. The largest range has at most length __n
+      // 3. Each range is larger than half of the range remaining
+      volatile _DifferenceType __elements_leftover = __n;
+      for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	{
+          __tls[__i]->_M_elements_leftover = &__elements_leftover;
+          __tls[__i]->_M_num_threads = __num_threads;
+          __tls[__i]->_M_global = std::make_pair(__begin, __end);
+
+          // Just in case nothing is left to assign.
+          __tls[__i]->_M_initial = std::make_pair(__end, __end);
+	}
+
+      // Main recursion call.
+      __qsb_conquer(__tls, __begin, __begin + __n, __comp, 0,
+		    __num_threads, true);
+
+#if _GLIBCXX_ASSERTIONS
+      // All stack must be empty.
+      _Piece __dummy;
+      for (_ThreadIndex __i = 1; __i < __num_threads; ++__i)
+	_GLIBCXX_PARALLEL_ASSERT(
+          !__tls[__i]->_M_leftover_parts.pop_back(__dummy));
+#endif
+
+      for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	delete __tls[__i];
+      delete[] __tls;
+    }
+} // namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_BALANCED_QUICKSORT_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/base.h b/gcc-4.9/libstdc++-v3/include/parallel/base.h
new file mode 100644
index 0000000..91d198f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/base.h
@@ -0,0 +1,426 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/base.h
+ *  @brief Sequential helper functions.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_BASE_H
+#define _GLIBCXX_PARALLEL_BASE_H 1
+
+#include <bits/c++config.h>
+#include <bits/stl_function.h>
+#include <omp.h>
+#include <parallel/features.h>
+#include <parallel/basic_iterator.h>
+#include <parallel/parallel.h>
+
+// Parallel mode namespaces.
+
+/**
+ * @namespace std::__parallel
+ * @brief GNU parallel code, replaces standard behavior with parallel behavior.
+ */
+namespace std _GLIBCXX_VISIBILITY(default) 
+{ 
+  namespace __parallel { } 
+}
+
+/**
+ * @namespace __gnu_parallel
+ * @brief GNU parallel code for public use.
+ */
+namespace __gnu_parallel
+{
+  // Import all the parallel versions of components in namespace std.
+  using namespace std::__parallel;
+}
+
+/**
+ * @namespace __gnu_sequential
+ * @brief GNU sequential classes for public use.
+ */
+namespace __gnu_sequential 
+{ 
+  // Import whatever is the serial version.
+#ifdef _GLIBCXX_PARALLEL
+  using namespace std::_GLIBCXX_STD_A;
+#else
+  using namespace std;
+#endif   
+}
+
+
+namespace __gnu_parallel
+{
+  // NB: Including this file cannot produce (unresolved) symbols from
+  // the OpenMP runtime unless the parallel mode is actually invoked
+  // and active, which imples that the OpenMP runtime is actually
+  // going to be linked in.
+  inline _ThreadIndex
+  __get_max_threads() 
+  { 
+    _ThreadIndex __i = omp_get_max_threads();
+    return __i > 1 ? __i : 1; 
+  }
+
+
+  inline bool 
+  __is_parallel(const _Parallelism __p) { return __p != sequential; }
+
+
+  /** @brief Calculates the rounded-down logarithm of @c __n for base 2.
+   *  @param __n Argument.
+   *  @return Returns 0 for any argument <1.
+   */
+  template<typename _Size>
+    inline _Size
+    __rd_log2(_Size __n)
+    {
+      _Size __k;
+      for (__k = 0; __n > 1; __n >>= 1)
+        ++__k;
+      return __k;
+    }
+
+  /** @brief Encode two integers into one gnu_parallel::_CASable.
+   *  @param __a First integer, to be encoded in the most-significant @c
+   *  _CASable_bits/2 bits.
+   *  @param __b Second integer, to be encoded in the least-significant
+   *  @c _CASable_bits/2 bits.
+   *  @return value encoding @c __a and @c __b.
+   *  @see __decode2
+   */
+  inline _CASable
+  __encode2(int __a, int __b)     //must all be non-negative, actually
+  {
+    return (((_CASable)__a) << (_CASable_bits / 2)) | (((_CASable)__b) << 0);
+  }
+
+  /** @brief Decode two integers from one gnu_parallel::_CASable.
+   *  @param __x __gnu_parallel::_CASable to decode integers from.
+   *  @param __a First integer, to be decoded from the most-significant
+   *  @c _CASable_bits/2 bits of @c __x.
+   *  @param __b Second integer, to be encoded in the least-significant
+   *  @c _CASable_bits/2 bits of @c __x.
+   *  @see __encode2
+   */
+  inline void
+  __decode2(_CASable __x, int& __a, int& __b)
+  {
+    __a = (int)((__x >> (_CASable_bits / 2)) & _CASable_mask);
+    __b = (int)((__x >>               0 ) & _CASable_mask);
+  }
+
+  //needed for parallel "numeric", even if "algorithm" not included
+
+  /** @brief Equivalent to std::min. */
+  template<typename _Tp>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    { return (__a < __b) ? __a : __b; }
+
+  /** @brief Equivalent to std::max. */
+  template<typename _Tp>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    { return (__a > __b) ? __a : __b; }
+
+  /** @brief Constructs predicate for equality from strict weak
+   *  ordering predicate
+   */
+  template<typename _T1, typename _T2, typename _Compare>
+    class _EqualFromLess : public std::binary_function<_T1, _T2, bool>
+    {
+    private:
+      _Compare& _M_comp;
+
+    public:
+      _EqualFromLess(_Compare& __comp) : _M_comp(__comp) { }
+
+      bool operator()(const _T1& __a, const _T2& __b)
+      { return !_M_comp(__a, __b) && !_M_comp(__b, __a); }
+    };
+
+
+  /** @brief Similar to std::unary_negate,
+   *  but giving the argument types explicitly. */
+  template<typename _Predicate, typename argument_type>
+    class __unary_negate
+    : public std::unary_function<argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+
+    public:
+      explicit
+      __unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      bool
+      operator()(const argument_type& __x)
+      { return !_M_pred(__x); }
+    };
+
+  /** @brief Similar to std::binder1st,
+   *  but giving the argument types explicitly. */
+  template<typename _Operation, typename _FirstArgumentType,
+	   typename _SecondArgumentType, typename _ResultType>
+    class __binder1st
+    : public std::unary_function<_SecondArgumentType, _ResultType>
+    {
+    protected:
+      _Operation _M_op;
+      _FirstArgumentType _M_value;
+
+    public:
+      __binder1st(const _Operation& __x, const _FirstArgumentType& __y)
+      : _M_op(__x), _M_value(__y) { }
+
+      _ResultType
+      operator()(const _SecondArgumentType& __x)
+      { return _M_op(_M_value, __x); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 109.  Missing binders for non-const sequence elements
+      _ResultType
+      operator()(_SecondArgumentType& __x) const
+      { return _M_op(_M_value, __x); }
+    };
+
+  /**
+   *  @brief Similar to std::binder2nd, but giving the argument types
+   *  explicitly.
+   */
+  template<typename _Operation, typename _FirstArgumentType,
+	   typename _SecondArgumentType, typename _ResultType>
+    class __binder2nd
+    : public std::unary_function<_FirstArgumentType, _ResultType>
+    {
+    protected:
+      _Operation _M_op;
+      _SecondArgumentType _M_value;
+
+    public:
+      __binder2nd(const _Operation& __x, const _SecondArgumentType& __y)
+      : _M_op(__x), _M_value(__y) { }
+
+      _ResultType
+      operator()(const _FirstArgumentType& __x) const
+      { return _M_op(__x, _M_value); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 109.  Missing binders for non-const sequence elements
+      _ResultType
+      operator()(_FirstArgumentType& __x)
+      { return _M_op(__x, _M_value); }
+    };
+
+  /** @brief Similar to std::equal_to, but allows two different types. */
+  template<typename _T1, typename _T2>
+    struct _EqualTo : std::binary_function<_T1, _T2, bool>
+    {
+      bool operator()(const _T1& __t1, const _T2& __t2) const
+      { return __t1 == __t2; }
+    };
+
+  /** @brief Similar to std::less, but allows two different types. */
+  template<typename _T1, typename _T2>
+    struct _Less : std::binary_function<_T1, _T2, bool>
+    {
+      bool
+      operator()(const _T1& __t1, const _T2& __t2) const
+      { return __t1 < __t2; }
+
+      bool
+      operator()(const _T2& __t2, const _T1& __t1) const
+      { return __t2 < __t1; }
+    };
+
+  // Partial specialization for one type. Same as std::less.
+  template<typename _Tp>
+    struct _Less<_Tp, _Tp>
+    : public std::less<_Tp> { };
+
+  /** @brief Similar to std::plus, but allows two different types. */
+  template<typename _Tp1, typename _Tp2, typename _Result
+	   = __typeof__(*static_cast<_Tp1*>(0)
+			+ *static_cast<_Tp2*>(0))>
+    struct _Plus : public std::binary_function<_Tp1, _Tp2, _Result>
+    {
+      _Result
+      operator()(const _Tp1& __x, const _Tp2& __y) const
+      { return __x + __y; }
+    };
+
+  // Partial specialization for one type. Same as std::plus.
+  template<typename _Tp>
+    struct _Plus<_Tp, _Tp, _Tp>
+    : public std::plus<_Tp> { };
+
+  /** @brief Similar to std::multiplies, but allows two different types. */
+  template<typename _Tp1, typename _Tp2, typename _Result
+	   = __typeof__(*static_cast<_Tp1*>(0)
+			* *static_cast<_Tp2*>(0))>
+    struct _Multiplies : public std::binary_function<_Tp1, _Tp2, _Result>
+    {
+      _Result
+      operator()(const _Tp1& __x, const _Tp2& __y) const
+      { return __x * __y; }
+    };
+
+  // Partial specialization for one type. Same as std::multiplies.
+  template<typename _Tp>
+    struct _Multiplies<_Tp, _Tp, _Tp>
+    : public std::multiplies<_Tp> { };
+
+  /** @brief _Iterator associated with __gnu_parallel::_PseudoSequence.
+   *  If features the usual random-access iterator functionality.
+   *  @param _Tp Sequence _M_value type.
+   *  @param _DifferenceTp Sequence difference type.
+   */
+  template<typename _Tp, typename _DifferenceTp>
+    class _PseudoSequenceIterator
+    {
+    public:
+      typedef _DifferenceTp _DifferenceType;
+
+      _PseudoSequenceIterator(const _Tp& __val, _DifferenceType __pos)
+      : _M_val(__val), _M_pos(__pos) { }
+
+      // Pre-increment operator.
+      _PseudoSequenceIterator&
+      operator++()
+      {
+	++_M_pos;
+	return *this;
+      }
+
+      // Post-increment operator.
+      _PseudoSequenceIterator
+      operator++(int)
+      { return _PseudoSequenceIterator(_M_pos++); }
+
+      const _Tp&
+      operator*() const
+      { return _M_val; }
+
+      const _Tp&
+      operator[](_DifferenceType) const
+      { return _M_val; }
+
+      bool
+      operator==(const _PseudoSequenceIterator& __i2)
+      { return _M_pos == __i2._M_pos; }
+
+      bool
+      operator!=(const _PseudoSequenceIterator& __i2)
+      { return _M_pos != __i2._M_pos; }
+
+      _DifferenceType
+      operator-(const _PseudoSequenceIterator& __i2)
+      { return _M_pos - __i2._M_pos; }
+
+    private:
+      const _Tp& _M_val;
+      _DifferenceType _M_pos;
+    };
+
+  /** @brief Sequence that conceptually consists of multiple copies of
+      the same element.
+      *  The copies are not stored explicitly, of course.
+      *  @param _Tp Sequence _M_value type.
+      *  @param _DifferenceTp Sequence difference type.
+      */
+  template<typename _Tp, typename _DifferenceTp>
+    class _PseudoSequence
+    {
+    public:
+      typedef _DifferenceTp _DifferenceType;
+
+      // Better cast down to uint64_t, than up to _DifferenceTp.
+      typedef _PseudoSequenceIterator<_Tp, uint64_t> iterator;
+
+      /** @brief Constructor.
+       *  @param __val Element of the sequence.
+       *  @param __count Number of (virtual) copies.
+       */
+      _PseudoSequence(const _Tp& __val, _DifferenceType __count)
+      : _M_val(__val), _M_count(__count)  { }
+
+      /** @brief Begin iterator. */
+      iterator
+      begin() const
+      { return iterator(_M_val, 0); }
+
+      /** @brief End iterator. */
+      iterator
+      end() const
+      { return iterator(_M_val, _M_count); }
+
+    private:
+      const _Tp& _M_val;
+      _DifferenceType _M_count;
+    };
+
+  /** @brief Compute the median of three referenced elements,
+      according to @c __comp.
+      *  @param __a First iterator.
+      *  @param __b Second iterator.
+      *  @param __c Third iterator.
+      *  @param __comp Comparator.
+      */
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    __median_of_three_iterators(_RAIter __a, _RAIter __b,
+				_RAIter __c, _Compare __comp)
+    {
+      if (__comp(*__a, *__b))
+	if (__comp(*__b, *__c))
+	  return __b;
+	else
+	  if (__comp(*__a, *__c))
+	    return __c;
+	  else
+	    return __a;
+      else
+	{
+	  // Just swap __a and __b.
+	  if (__comp(*__a, *__c))
+	    return __a;
+	  else
+	    if (__comp(*__b, *__c))
+	      return __c;
+	    else
+	      return __b;
+	}
+    }
+
+#define _GLIBCXX_PARALLEL_ASSERT(_Condition) __glibcxx_assert(_Condition)
+
+} //namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_BASE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/basic_iterator.h b/gcc-4.9/libstdc++-v3/include/parallel/basic_iterator.h
new file mode 100644
index 0000000..293554c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/basic_iterator.h
@@ -0,0 +1,41 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/basic_iterator.h
+ *  @brief Includes the original header files concerned with iterators
+ *  except for stream iterators.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_BASIC_ITERATOR_H
+#define _GLIBCXX_PARALLEL_BASIC_ITERATOR_H 1
+
+#include <bits/c++config.h>
+#include <bits/stl_iterator_base_types.h>
+#include <bits/stl_iterator_base_funcs.h>
+#include <bits/stl_iterator.h>
+
+#endif /* _GLIBCXX_PARALLEL_BASIC_ITERATOR_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/checkers.h b/gcc-4.9/libstdc++-v3/include/parallel/checkers.h
new file mode 100644
index 0000000..34e76ac
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/checkers.h
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/checkers.h
+ *  @brief Routines for checking the correctness of algorithm results.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_CHECKERS_H
+#define _GLIBCXX_PARALLEL_CHECKERS_H 1
+
+#include <cstdio>
+#include <bits/stl_algobase.h>
+#include <bits/stl_function.h>
+
+namespace __gnu_parallel
+{
+  /**
+   * @brief Check whether @c [__begin, @c __end) is sorted according
+   * to @c __comp.
+   * @param __begin Begin iterator of sequence.
+   * @param __end End iterator of sequence.
+   * @param __comp Comparator.
+   * @return @c true if sorted, @c false otherwise.
+   */
+  template<typename _IIter, typename _Compare>
+    bool
+    __is_sorted(_IIter __begin, _IIter __end, _Compare __comp)
+    {
+      if (__begin == __end)
+        return true;
+
+      _IIter __current(__begin), __recent(__begin);
+
+      unsigned long long __position = 1;
+      for (__current++; __current != __end; __current++)
+        {
+          if (__comp(*__current, *__recent))
+            {
+              return false;
+            }
+          __recent = __current;
+          __position++;
+        }
+
+      return true;
+    }
+}
+
+#endif /* _GLIBCXX_PARALLEL_CHECKERS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/compatibility.h b/gcc-4.9/libstdc++-v3/include/parallel/compatibility.h
new file mode 100644
index 0000000..fe505a0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/compatibility.h
@@ -0,0 +1,131 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/compatibility.h
+ *  @brief Compatibility layer, mostly concerned with atomic operations.
+ *
+ *  This file is a GNU parallel extension to the Standard C++ Library
+ *  and contains implementation details for the library's internal use.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_COMPATIBILITY_H
+#define _GLIBCXX_PARALLEL_COMPATIBILITY_H 1
+
+#include <parallel/types.h>
+#include <parallel/base.h>
+
+#if !defined(_WIN32) || defined (__CYGWIN__)
+#include <sched.h>
+#endif
+
+#ifdef __MINGW32__
+// Including <windows.h> will drag in all the windows32 names.  Since
+// that can cause user code portability problems, we just declare the
+// one needed function here.
+extern "C"
+__attribute((dllimport)) void __attribute__((stdcall)) Sleep (unsigned long);
+#endif
+
+namespace __gnu_parallel
+{
+  template<typename _Tp>
+    inline _Tp
+    __add_omp(volatile _Tp* __ptr, _Tp __addend)
+    {
+      int64_t __res;
+#pragma omp critical
+      {
+	__res = *__ptr;
+	*(__ptr) += __addend;
+      }
+      return __res;
+    }
+
+  /** @brief Add a value to a variable, atomically.
+   *
+   *  @param __ptr Pointer to a signed integer.
+   *  @param __addend Value to add.
+   */
+  template<typename _Tp>
+    inline _Tp
+    __fetch_and_add(volatile _Tp* __ptr, _Tp __addend)
+    {
+      if (__atomic_always_lock_free(sizeof(_Tp), __ptr))
+	return __atomic_fetch_add(__ptr, __addend, __ATOMIC_ACQ_REL);
+      return __add_omp(__ptr, __addend);
+    }
+
+  template<typename _Tp>
+    inline bool
+    __cas_omp(volatile _Tp* __ptr, _Tp __comparand, _Tp __replacement)
+    {
+      bool __res = false;
+#pragma omp critical
+      {
+	if (*__ptr == __comparand)
+	  {
+	    *__ptr = __replacement;
+	    __res = true;
+	  }
+      }
+      return __res;
+    }
+
+  /** @brief Compare-and-swap
+   *
+   * Compare @c *__ptr and @c __comparand. If equal, let @c
+   * *__ptr=__replacement and return @c true, return @c false otherwise.
+   *
+   *  @param __ptr Pointer to signed integer.
+   *  @param __comparand Compare value.
+   *  @param __replacement Replacement value.
+   */
+  template<typename _Tp>
+    inline bool
+    __compare_and_swap(volatile _Tp* __ptr, _Tp __comparand, _Tp __replacement)
+    {
+      if (__atomic_always_lock_free(sizeof(_Tp), __ptr))
+	return __atomic_compare_exchange_n(__ptr, &__comparand, __replacement,
+					   false, __ATOMIC_ACQ_REL,
+					   __ATOMIC_RELAXED);
+      return __cas_omp(__ptr, __comparand, __replacement);
+    }
+
+  /** @brief Yield control to another thread, without waiting for
+   *  the end of the time slice.
+   */
+  inline void
+  __yield()
+  {
+#if defined (_WIN32) && !defined (__CYGWIN__)
+    Sleep(0);
+#else
+    sched_yield();
+#endif
+  }
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_COMPATIBILITY_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/compiletime_settings.h b/gcc-4.9/libstdc++-v3/include/parallel/compiletime_settings.h
new file mode 100644
index 0000000..9a28894
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/compiletime_settings.h
@@ -0,0 +1,75 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/compiletime_settings.h
+ *  @brief Defines on options concerning debugging and performance, at
+ *  compile-time.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#include <cstdio>
+
+/** @brief Determine verbosity level of the parallel mode.
+ *  Level 1 prints a message each time a parallel-mode function is entered. */
+#define _GLIBCXX_VERBOSE_LEVEL 0
+
+/** @def _GLIBCXX_CALL
+ *  @brief Macro to produce log message when entering a function.
+ *  @param __n Input size.
+ *  @see _GLIBCXX_VERBOSE_LEVEL */
+#if (_GLIBCXX_VERBOSE_LEVEL == 0)
+#define _GLIBCXX_CALL(__n)
+#endif
+#if (_GLIBCXX_VERBOSE_LEVEL == 1)
+#define _GLIBCXX_CALL(__n) \
+  printf("   %__s:\niam = %d, __n = %ld, __num_threads = %d\n", \
+  __PRETTY_FUNCTION__, omp_get_thread_num(), (__n), __get_max_threads());
+#endif
+
+#ifndef _GLIBCXX_SCALE_DOWN_FPU
+/** @brief Use floating-point scaling instead of modulo for mapping
+ *  random numbers to a range.  This can be faster on certain CPUs. */
+#define _GLIBCXX_SCALE_DOWN_FPU 0
+#endif
+
+#ifndef _GLIBCXX_ASSERTIONS
+/** @brief Switch on many _GLIBCXX_PARALLEL_ASSERTions in parallel code.
+ *  Should be switched on only locally. */
+#define _GLIBCXX_ASSERTIONS 0
+#endif
+
+#ifndef _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
+/** @brief Switch on many _GLIBCXX_PARALLEL_ASSERTions in parallel code.
+ *  Consider the size of the L1 cache for
+*  gnu_parallel::__parallel_random_shuffle(). */
+#define _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 0
+#endif
+#ifndef _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
+/** @brief Switch on many _GLIBCXX_PARALLEL_ASSERTions in parallel code.
+ *  Consider the size of the TLB for
+*  gnu_parallel::__parallel_random_shuffle(). */
+#define _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB 0
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/equally_split.h b/gcc-4.9/libstdc++-v3/include/parallel/equally_split.h
new file mode 100644
index 0000000..1c27e48
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/equally_split.h
@@ -0,0 +1,89 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/equally_split.h
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_EQUALLY_SPLIT_H
+#define _GLIBCXX_PARALLEL_EQUALLY_SPLIT_H 1
+
+namespace __gnu_parallel
+{
+  /** @brief function to split a sequence into parts of almost equal size.
+   *
+   *  The resulting sequence __s of length __num_threads+1 contains the
+   *  splitting positions when splitting the range [0,__n) into parts of
+   *  almost equal size (plus minus 1).  The first entry is 0, the last
+   *  one n. There may result empty parts.
+   *  @param __n Number of elements
+   *  @param __num_threads Number of parts
+   *  @param __s Splitters
+   *  @returns End of __splitter sequence, i.e. @c __s+__num_threads+1 */
+  template<typename _DifferenceType, typename _OutputIterator>
+    _OutputIterator
+    __equally_split(_DifferenceType __n, _ThreadIndex __num_threads,
+		    _OutputIterator __s)
+    {
+      _DifferenceType __chunk_length = __n / __num_threads;
+      _DifferenceType __num_longer_chunks = __n % __num_threads;
+      _DifferenceType __pos = 0;
+      for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	{
+	  *__s++ = __pos;
+	  __pos += ((__i < __num_longer_chunks)
+		    ? (__chunk_length + 1) : __chunk_length);
+	}
+      *__s++ = __n;
+      return __s;
+    }
+
+  /** @brief function to split a sequence into parts of almost equal size.
+   *
+   *  Returns the position of the splitting point between
+   *  thread number __thread_no (included) and
+   *  thread number __thread_no+1 (excluded).
+   *  @param __n Number of elements
+   *  @param __num_threads Number of parts
+   *  @param __thread_no Number of threads
+   *  @returns splitting point */
+  template<typename _DifferenceType>
+    _DifferenceType
+    __equally_split_point(_DifferenceType __n,
+			  _ThreadIndex __num_threads,
+			  _ThreadIndex __thread_no)
+    {
+      _DifferenceType __chunk_length = __n / __num_threads;
+      _DifferenceType __num_longer_chunks = __n % __num_threads;
+      if (__thread_no < __num_longer_chunks)
+	return __thread_no * (__chunk_length + 1);
+      else
+	return __num_longer_chunks * (__chunk_length + 1)
+          + (__thread_no - __num_longer_chunks) * __chunk_length;
+    }
+}
+
+#endif /* _GLIBCXX_PARALLEL_EQUALLY_SPLIT_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/features.h b/gcc-4.9/libstdc++-v3/include/parallel/features.h
new file mode 100644
index 0000000..42ac36f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/features.h
@@ -0,0 +1,104 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/features.h
+ *  @brief Defines on whether to include algorithm variants.
+ *
+ *  Less variants reduce executable size and compile time.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_FEATURES_H
+#define _GLIBCXX_PARALLEL_FEATURES_H 1
+
+#ifndef _GLIBCXX_MERGESORT
+/** @def _GLIBCXX_MERGESORT
+ *  @brief Include parallel multi-way mergesort.
+ *  @see __gnu_parallel::_Settings::sort_algorithm */
+#define _GLIBCXX_MERGESORT 1
+#endif
+
+#ifndef _GLIBCXX_QUICKSORT
+/** @def _GLIBCXX_QUICKSORT
+ *  @brief Include parallel unbalanced quicksort.
+ *  @see __gnu_parallel::_Settings::sort_algorithm */
+#define _GLIBCXX_QUICKSORT 1
+#endif
+
+#ifndef _GLIBCXX_BAL_QUICKSORT
+/** @def _GLIBCXX_BAL_QUICKSORT
+ *  @brief Include parallel dynamically load-balanced quicksort.
+ *  @see __gnu_parallel::_Settings::sort_algorithm */
+#define _GLIBCXX_BAL_QUICKSORT 1
+#endif
+
+#ifndef _GLIBCXX_FIND_GROWING_BLOCKS
+/** @brief Include the growing blocks variant for std::find.
+ *  @see __gnu_parallel::_Settings::find_algorithm */
+#define _GLIBCXX_FIND_GROWING_BLOCKS 1
+#endif
+
+#ifndef _GLIBCXX_FIND_CONSTANT_SIZE_BLOCKS
+/** @brief Include the equal-sized blocks variant for std::find.
+ *  @see __gnu_parallel::_Settings::find_algorithm */
+#define _GLIBCXX_FIND_CONSTANT_SIZE_BLOCKS 1
+#endif
+
+#ifndef _GLIBCXX_FIND_EQUAL_SPLIT
+/** @def _GLIBCXX_FIND_EQUAL_SPLIT
+ *  @brief Include the equal splitting variant for std::find.
+ *  @see __gnu_parallel::_Settings::find_algorithm */
+#define _GLIBCXX_FIND_EQUAL_SPLIT 1
+#endif
+
+
+#ifndef _GLIBCXX_TREE_INITIAL_SPLITTING
+/** @def _GLIBCXX_TREE_INITIAL_SPLITTING
+ *  @brief Include the initial splitting variant for
+ *  _Rb_tree::insert_unique(_IIter beg, _IIter __end).
+ *  @see __gnu_parallel::_Rb_tree */
+#define _GLIBCXX_TREE_INITIAL_SPLITTING 1
+#endif
+
+#ifndef _GLIBCXX_TREE_DYNAMIC_BALANCING
+/** @def _GLIBCXX_TREE_DYNAMIC_BALANCING
+ *  @brief Include the dynamic balancing variant for
+ *  _Rb_tree::insert_unique(_IIter beg, _IIter __end).
+ *  @see __gnu_parallel::_Rb_tree */
+#define _GLIBCXX_TREE_DYNAMIC_BALANCING 1
+#endif
+
+#ifndef _GLIBCXX_TREE_FULL_COPY
+/** @def _GLIBCXX_TREE_FULL_COPY
+ *  @brief In order to sort the input sequence of
+ *  _Rb_tree::insert_unique(_IIter beg, _IIter __end) a
+ *  full copy of the input elements is done.
+ *  @see __gnu_parallel::_Rb_tree */
+#define _GLIBCXX_TREE_FULL_COPY 1
+#endif
+
+
+#endif /* _GLIBCXX_PARALLEL_FEATURES_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/find.h b/gcc-4.9/libstdc++-v3/include/parallel/find.h
new file mode 100644
index 0000000..1961ed5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/find.h
@@ -0,0 +1,405 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/find.h
+ *  @brief Parallel implementation base for std::find(), std::equal()
+ *  and related functions.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze and Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_FIND_H
+#define _GLIBCXX_PARALLEL_FIND_H 1
+
+#include <bits/stl_algobase.h>
+
+#include <parallel/features.h>
+#include <parallel/parallel.h>
+#include <parallel/compatibility.h>
+#include <parallel/equally_split.h>
+
+namespace __gnu_parallel
+{
+  /**
+   *  @brief Parallel std::find, switch for different algorithms.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence. Must have same
+   *  length as first sequence.
+   *  @param __pred Find predicate.
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
+   *  @return Place of finding in both sequences.
+   */
+  template<typename _RAIter1,
+	   typename _RAIter2,
+	   typename _Pred,
+           typename _Selector>
+    inline std::pair<_RAIter1, _RAIter2>
+    __find_template(_RAIter1 __begin1, _RAIter1 __end1,
+		    _RAIter2 __begin2, _Pred __pred, _Selector __selector)
+    {
+      switch (_Settings::get().find_algorithm)
+	{
+	case GROWING_BLOCKS:
+          return __find_template(__begin1, __end1, __begin2, __pred,
+				 __selector, growing_blocks_tag());
+	case CONSTANT_SIZE_BLOCKS:
+          return __find_template(__begin1, __end1, __begin2, __pred,
+				 __selector, constant_size_blocks_tag());
+	case EQUAL_SPLIT:
+          return __find_template(__begin1, __end1, __begin2, __pred,
+				 __selector, equal_split_tag());
+	default:
+          _GLIBCXX_PARALLEL_ASSERT(false);
+          return std::make_pair(__begin1, __begin2);
+	}
+    }
+
+#if _GLIBCXX_FIND_EQUAL_SPLIT
+
+  /**
+   *  @brief Parallel std::find, equal splitting variant.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence. Second __sequence
+   *  must have same length as first sequence.
+   *  @param __pred Find predicate.
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
+   *  @return Place of finding in both sequences.
+   */
+  template<typename _RAIter1,
+           typename _RAIter2,
+           typename _Pred,
+           typename _Selector>
+    std::pair<_RAIter1, _RAIter2>
+    __find_template(_RAIter1 __begin1, _RAIter1 __end1,
+		    _RAIter2 __begin2, _Pred __pred,
+		    _Selector __selector, equal_split_tag)
+    {
+      _GLIBCXX_CALL(__end1 - __begin1)
+
+      typedef std::iterator_traits<_RAIter1> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef typename _TraitsType::value_type _ValueType;
+
+      _DifferenceType __length = __end1 - __begin1;
+      _DifferenceType __result = __length;
+      _DifferenceType* __borders;
+
+      omp_lock_t __result_lock;
+      omp_init_lock(&__result_lock);
+
+      _ThreadIndex __num_threads = __get_max_threads();
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#     pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+	  __borders = new _DifferenceType[__num_threads + 1];
+	  __equally_split(__length, __num_threads, __borders);
+	} //single
+
+	_ThreadIndex __iam = omp_get_thread_num();
+	_DifferenceType __start = __borders[__iam],
+	                 __stop = __borders[__iam + 1];
+
+	_RAIter1 __i1 = __begin1 + __start;
+	_RAIter2 __i2 = __begin2 + __start;
+	for (_DifferenceType __pos = __start; __pos < __stop; ++__pos)
+	  {
+#           pragma omp flush(__result)
+	    // Result has been set to something lower.
+	    if (__result < __pos)
+	      break;
+
+	    if (__selector(__i1, __i2, __pred))
+	      {
+		omp_set_lock(&__result_lock);
+		if (__pos < __result)
+		  __result = __pos;
+		omp_unset_lock(&__result_lock);
+		break;
+	      }
+	    ++__i1;
+	    ++__i2;
+	  }
+      } //parallel
+
+      omp_destroy_lock(&__result_lock);
+      delete[] __borders;
+
+      return std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+					   __begin2 + __result);
+    }
+
+#endif
+
+#if _GLIBCXX_FIND_GROWING_BLOCKS
+
+  /**
+   *  @brief Parallel std::find, growing block size variant.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence. Second __sequence
+   *  must have same length as first sequence.
+   *  @param __pred Find predicate.
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
+   *  @return Place of finding in both sequences.
+   *  @see __gnu_parallel::_Settings::find_sequential_search_size
+   *  @see __gnu_parallel::_Settings::find_scale_factor
+   *
+   *  There are two main differences between the growing blocks and
+   *  the constant-size blocks variants.
+   *  1. For GB, the block size grows; for CSB, the block size is fixed.
+   *  2. For GB, the blocks are allocated dynamically;
+   *     for CSB, the blocks are allocated in a predetermined manner,
+   *     namely spacial round-robin.
+   */
+  template<typename _RAIter1,
+           typename _RAIter2,
+           typename _Pred,
+           typename _Selector>
+    std::pair<_RAIter1, _RAIter2>
+    __find_template(_RAIter1 __begin1, _RAIter1 __end1,
+		    _RAIter2 __begin2, _Pred __pred, _Selector __selector,
+		    growing_blocks_tag)
+    {
+      _GLIBCXX_CALL(__end1 - __begin1)
+
+      typedef std::iterator_traits<_RAIter1> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef typename _TraitsType::value_type _ValueType;
+
+      const _Settings& __s = _Settings::get();
+
+      _DifferenceType __length = __end1 - __begin1;
+
+      _DifferenceType
+	__sequential_search_size = std::min<_DifferenceType>
+	(__length, __s.find_sequential_search_size);
+
+      // Try it sequentially first.
+      std::pair<_RAIter1, _RAIter2>
+	__find_seq_result = __selector._M_sequential_algorithm
+	(__begin1, __begin1 + __sequential_search_size,
+	 __begin2, __pred);
+
+      if (__find_seq_result.first != (__begin1 + __sequential_search_size))
+	return __find_seq_result;
+
+      // Index of beginning of next free block (after sequential find).
+      _DifferenceType __next_block_start = __sequential_search_size;
+      _DifferenceType __result = __length;
+
+      omp_lock_t __result_lock;
+      omp_init_lock(&__result_lock);
+
+      const float __scale_factor = __s.find_scale_factor;
+
+      _ThreadIndex __num_threads = __get_max_threads();
+#     pragma omp parallel shared(__result) num_threads(__num_threads)
+      {
+#       pragma omp single
+	__num_threads = omp_get_num_threads();
+
+	// Not within first __k elements -> start parallel.
+	_ThreadIndex __iam = omp_get_thread_num();
+
+	_DifferenceType __block_size =
+	  std::max<_DifferenceType>(1, __scale_factor * __next_block_start);
+	_DifferenceType __start = __fetch_and_add<_DifferenceType>
+	  (&__next_block_start, __block_size);
+
+	// Get new block, update pointer to next block.
+	_DifferenceType __stop =
+	  std::min<_DifferenceType>(__length, __start + __block_size);
+
+	std::pair<_RAIter1, _RAIter2> __local_result;
+
+	while (__start < __length)
+	  {
+#           pragma omp flush(__result)
+	    // Get new value of result.
+	    if (__result < __start)
+	      {
+		// No chance to find first element.
+		break;
+	      }
+
+	    __local_result = __selector._M_sequential_algorithm
+	      (__begin1 + __start, __begin1 + __stop,
+	       __begin2 + __start, __pred);
+
+	    if (__local_result.first != (__begin1 + __stop))
+	      {
+		omp_set_lock(&__result_lock);
+		if ((__local_result.first - __begin1) < __result)
+		  {
+		    __result = __local_result.first - __begin1;
+
+		    // Result cannot be in future blocks, stop algorithm.
+		    __fetch_and_add<_DifferenceType>(&__next_block_start,
+						     __length);
+		  }
+		omp_unset_lock(&__result_lock);
+	      }
+
+	    _DifferenceType __block_size =
+	     std::max<_DifferenceType>(1, __scale_factor * __next_block_start);
+
+	    // Get new block, update pointer to next block.
+	    __start = __fetch_and_add<_DifferenceType>(&__next_block_start,
+						       __block_size);
+	    __stop =
+	      std::min<_DifferenceType>(__length, __start + __block_size);
+	  }
+      } //parallel
+
+      omp_destroy_lock(&__result_lock);
+
+      // Return iterator on found element.
+      return
+	std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+				      __begin2 + __result);
+    }
+
+#endif
+
+#if _GLIBCXX_FIND_CONSTANT_SIZE_BLOCKS
+
+  /**
+   *   @brief Parallel std::find, constant block size variant.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence. Second __sequence
+   *  must have same length as first sequence.
+   *  @param __pred Find predicate.
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
+   *  @return Place of finding in both sequences.
+   *  @see __gnu_parallel::_Settings::find_sequential_search_size
+   *  @see __gnu_parallel::_Settings::find_block_size
+   *  There are two main differences between the growing blocks and the
+   *  constant-size blocks variants.
+   *  1. For GB, the block size grows; for CSB, the block size is fixed.
+   *  2. For GB, the blocks are allocated dynamically; for CSB, the
+   *  blocks are allocated in a predetermined manner, namely spacial
+   *  round-robin.
+   */
+  template<typename _RAIter1,
+           typename _RAIter2,
+           typename _Pred,
+           typename _Selector>
+    std::pair<_RAIter1, _RAIter2>
+    __find_template(_RAIter1 __begin1, _RAIter1 __end1,
+                  _RAIter2 __begin2, _Pred __pred, _Selector __selector,
+                  constant_size_blocks_tag)
+    {
+      _GLIBCXX_CALL(__end1 - __begin1)
+      typedef std::iterator_traits<_RAIter1> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef typename _TraitsType::value_type _ValueType;
+
+      const _Settings& __s = _Settings::get();
+
+      _DifferenceType __length = __end1 - __begin1;
+
+      _DifferenceType __sequential_search_size = std::min<_DifferenceType>
+	(__length, __s.find_sequential_search_size);
+
+      // Try it sequentially first.
+      std::pair<_RAIter1, _RAIter2>
+	__find_seq_result = __selector._M_sequential_algorithm
+	(__begin1, __begin1 + __sequential_search_size, __begin2, __pred);
+
+      if (__find_seq_result.first != (__begin1 + __sequential_search_size))
+	return __find_seq_result;
+
+      _DifferenceType __result = __length;
+      omp_lock_t __result_lock;
+      omp_init_lock(&__result_lock);
+
+      // Not within first __sequential_search_size elements -> start parallel.
+
+      _ThreadIndex __num_threads = __get_max_threads();
+#     pragma omp parallel shared(__result) num_threads(__num_threads)
+      {
+#       pragma omp single
+	__num_threads = omp_get_num_threads();
+
+	_ThreadIndex __iam = omp_get_thread_num();
+	_DifferenceType __block_size = __s.find_initial_block_size;
+
+	// First element of thread's current iteration.
+	_DifferenceType __iteration_start = __sequential_search_size;
+
+	// Where to work (initialization).
+	_DifferenceType __start = __iteration_start + __iam * __block_size;
+	_DifferenceType __stop = std::min<_DifferenceType>(__length,
+							   __start
+							   + __block_size);
+
+	std::pair<_RAIter1, _RAIter2> __local_result;
+
+	while (__start < __length)
+	  {
+	    // Get new value of result.
+#           pragma omp flush(__result)
+	    // No chance to find first element.
+	    if (__result < __start)
+	      break;
+
+	    __local_result = __selector._M_sequential_algorithm
+	      (__begin1 + __start, __begin1 + __stop,
+	       __begin2 + __start, __pred);
+
+	    if (__local_result.first != (__begin1 + __stop))
+	      {
+		omp_set_lock(&__result_lock);
+		if ((__local_result.first - __begin1) < __result)
+		  __result = __local_result.first - __begin1;
+		omp_unset_lock(&__result_lock);
+		// Will not find better value in its interval.
+		break;
+	      }
+
+	    __iteration_start += __num_threads * __block_size;
+
+	    // Where to work.
+	    __start = __iteration_start + __iam * __block_size;
+	    __stop = std::min<_DifferenceType>(__length,
+					       __start + __block_size);
+	  }
+      } //parallel
+
+      omp_destroy_lock(&__result_lock);
+
+      // Return iterator on found element.
+      return std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+					   __begin2 + __result);
+    }
+#endif
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_FIND_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/find_selectors.h b/gcc-4.9/libstdc++-v3/include/parallel/find_selectors.h
new file mode 100644
index 0000000..5440a7c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/find_selectors.h
@@ -0,0 +1,197 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/find_selectors.h
+ *  @brief _Function objects representing different tasks to be plugged
+ *  into the parallel find algorithm.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_FIND_SELECTORS_H
+#define _GLIBCXX_PARALLEL_FIND_SELECTORS_H 1
+
+#include <parallel/tags.h>
+#include <parallel/basic_iterator.h>
+#include <bits/stl_pair.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Base class of all __gnu_parallel::__find_template selectors. */
+  struct __generic_find_selector
+  { };
+
+  /** 
+   *  @brief Test predicate on a single element, used for std::find()
+   *  and std::find_if ().
+   */
+  struct __find_if_selector : public __generic_find_selector
+  {
+    /** @brief Test on one position.
+     * @param __i1 _Iterator on first sequence.
+     * @param __i2 _Iterator on second sequence (unused).
+     * @param __pred Find predicate.
+     */
+    template<typename _RAIter1, typename _RAIter2,
+             typename _Pred>
+      bool 
+      operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
+      { return __pred(*__i1); }
+
+    /** @brief Corresponding sequential algorithm on a sequence.
+     *  @param __begin1 Begin iterator of first sequence.
+     *  @param __end1 End iterator of first sequence.
+     *  @param __begin2 Begin iterator of second sequence.
+     *  @param __pred Find predicate.
+     */
+    template<typename _RAIter1, typename _RAIter2,
+             typename _Pred>
+      std::pair<_RAIter1, _RAIter2> 
+      _M_sequential_algorithm(_RAIter1 __begin1,
+                           _RAIter1 __end1,
+                           _RAIter2 __begin2, _Pred __pred)
+      { return std::make_pair(find_if(__begin1, __end1, __pred,
+                                      sequential_tag()), __begin2); }
+  };
+
+  /** @brief Test predicate on two adjacent elements. */
+  struct __adjacent_find_selector : public __generic_find_selector
+  {
+    /** @brief Test on one position.
+     *  @param __i1 _Iterator on first sequence.
+     *  @param __i2 _Iterator on second sequence (unused).
+     *  @param __pred Find predicate.
+     */
+    template<typename _RAIter1, typename _RAIter2,
+             typename _Pred>
+      bool 
+      operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
+      {
+        // Passed end iterator is one short.
+        return __pred(*__i1, *(__i1 + 1));
+      }
+
+    /** @brief Corresponding sequential algorithm on a sequence.
+     *  @param __begin1 Begin iterator of first sequence.
+     *  @param __end1 End iterator of first sequence.
+     *  @param __begin2 Begin iterator of second sequence.
+     *  @param __pred Find predicate.
+     */
+    template<typename _RAIter1, typename _RAIter2,
+             typename _Pred>
+      std::pair<_RAIter1, _RAIter2>
+      _M_sequential_algorithm(_RAIter1 __begin1,
+			      _RAIter1 __end1,
+			      _RAIter2 __begin2, _Pred __pred)
+      {
+        // Passed end iterator is one short.
+        _RAIter1 __spot = adjacent_find(__begin1, __end1 + 1,
+					__pred, sequential_tag());
+        if (__spot == (__end1 + 1))
+          __spot = __end1;
+        return std::make_pair(__spot, __begin2);
+      }
+  };
+
+  /** @brief Test inverted predicate on a single element. */
+  struct __mismatch_selector : public __generic_find_selector
+  {
+    /** 
+     *  @brief Test on one position.
+     *  @param __i1 _Iterator on first sequence.
+     *  @param __i2 _Iterator on second sequence (unused).
+     *  @param __pred Find predicate. 
+     */
+    template<typename _RAIter1, typename _RAIter2,
+             typename _Pred>
+      bool 
+      operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
+      { return !__pred(*__i1, *__i2); }
+
+    /** 
+     *  @brief Corresponding sequential algorithm on a sequence.
+     *  @param __begin1 Begin iterator of first sequence.
+     *  @param __end1 End iterator of first sequence.
+     *  @param __begin2 Begin iterator of second sequence.
+     *  @param __pred Find predicate. 
+     */
+    template<typename _RAIter1, typename _RAIter2,
+             typename _Pred>
+      std::pair<_RAIter1, _RAIter2>
+      _M_sequential_algorithm(_RAIter1 __begin1,
+			      _RAIter1 __end1,
+			      _RAIter2 __begin2, _Pred __pred)
+      { return mismatch(__begin1, __end1, __begin2,
+			__pred, sequential_tag()); }
+  };
+
+
+  /** @brief Test predicate on several elements. */
+  template<typename _FIterator>
+    struct __find_first_of_selector : public __generic_find_selector
+    {
+      _FIterator _M_begin;
+      _FIterator _M_end;
+
+      explicit __find_first_of_selector(_FIterator __begin,
+					_FIterator __end)
+      : _M_begin(__begin), _M_end(__end) { }
+
+      /** @brief Test on one position.
+       *  @param __i1 _Iterator on first sequence.
+       *  @param __i2 _Iterator on second sequence (unused).
+       *  @param __pred Find predicate. */
+      template<typename _RAIter1, typename _RAIter2,
+	       typename _Pred>
+        bool
+        operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
+        {
+	  for (_FIterator __pos_in_candidates = _M_begin;
+	       __pos_in_candidates != _M_end; ++__pos_in_candidates)
+	    if (__pred(*__i1, *__pos_in_candidates))
+	      return true;
+	  return false;
+	}
+
+      /** @brief Corresponding sequential algorithm on a sequence.
+       *  @param __begin1 Begin iterator of first sequence.
+       *  @param __end1 End iterator of first sequence.
+       *  @param __begin2 Begin iterator of second sequence.
+       *  @param __pred Find predicate. */
+      template<typename _RAIter1, typename _RAIter2,
+	       typename _Pred>
+        std::pair<_RAIter1, _RAIter2>
+        _M_sequential_algorithm(_RAIter1 __begin1,
+				_RAIter1 __end1,
+				_RAIter2 __begin2, _Pred __pred)
+        {
+	  return std::make_pair(find_first_of(__begin1, __end1,
+					      _M_begin, _M_end, __pred,
+					      sequential_tag()), __begin2);
+	}
+     };
+}
+
+#endif /* _GLIBCXX_PARALLEL_FIND_SELECTORS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/for_each.h b/gcc-4.9/libstdc++-v3/include/parallel/for_each.h
new file mode 100644
index 0000000..3486fcc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/for_each.h
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/for_each.h
+ *  @brief Main interface for embarrassingly parallel functions.
+ *
+ *  The explicit implementation are in other header files, like
+ *  workstealing.h, par_loop.h, omp_loop.h, and omp_loop_static.h.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_FOR_EACH_H
+#define _GLIBCXX_PARALLEL_FOR_EACH_H 1
+
+#include <parallel/settings.h>
+#include <parallel/par_loop.h>
+#include <parallel/omp_loop.h>
+#include <parallel/workstealing.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Chose the desired algorithm by evaluating @c __parallelism_tag.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __user_op A user-specified functor (comparator, predicate,
+   *  associative operator,...)
+   *  @param __functionality functor to @a process an element with
+   *  __user_op (depends on desired functionality, e. g. accumulate,
+   *  for_each,...
+   *  @param __reduction Reduction functor.
+   *  @param __reduction_start Initial value for reduction.
+   *  @param __output Output iterator.
+   *  @param __bound Maximum number of elements processed.
+   *  @param __parallelism_tag Parallelization method */
+  template<typename _IIter, typename _UserOp,
+           typename _Functionality, typename _Red, typename _Result>
+    _UserOp
+    __for_each_template_random_access(_IIter __begin, _IIter __end,
+                                      _UserOp __user_op,
+                                      _Functionality& __functionality,
+                                      _Red __reduction,
+                                      _Result __reduction_start,
+                                      _Result& __output, typename
+                                      std::iterator_traits<_IIter>::
+                                      difference_type __bound,
+                                      _Parallelism __parallelism_tag)
+    {
+      if (__parallelism_tag == parallel_unbalanced)
+        return __for_each_template_random_access_ed
+	  (__begin, __end, __user_op, __functionality, __reduction,
+	   __reduction_start, __output, __bound);
+      else if (__parallelism_tag == parallel_omp_loop)
+        return __for_each_template_random_access_omp_loop
+	  (__begin, __end, __user_op, __functionality, __reduction,
+	   __reduction_start, __output, __bound);
+      else if (__parallelism_tag == parallel_omp_loop_static)
+        return __for_each_template_random_access_omp_loop
+	  (__begin, __end, __user_op, __functionality, __reduction,
+	   __reduction_start, __output, __bound);
+      else      //e. g. parallel_balanced
+        return __for_each_template_random_access_workstealing
+	  (__begin, __end, __user_op, __functionality, __reduction,
+	   __reduction_start, __output, __bound);
+  }
+}
+
+#endif /* _GLIBCXX_PARALLEL_FOR_EACH_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/for_each_selectors.h b/gcc-4.9/libstdc++-v3/include/parallel/for_each_selectors.h
new file mode 100644
index 0000000..d3fb334
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/for_each_selectors.h
@@ -0,0 +1,349 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/for_each_selectors.h
+ *  @brief Functors representing different tasks to be plugged into the
+ *  generic parallelization methods for embarrassingly parallel functions.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H
+#define _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H 1
+
+#include <parallel/basic_iterator.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Generic __selector for embarrassingly parallel functions. */
+  template<typename _It>
+    struct __generic_for_each_selector
+    {
+      /** @brief _Iterator on last element processed; needed for some
+       *  algorithms (e. g. std::transform()).
+       */
+      _It _M_finish_iterator;
+    };
+
+  /** @brief std::for_each() selector. */
+  template<typename _It>
+    struct __for_each_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
+        bool
+        operator()(_Op& __o, _It __i)
+        {
+          __o(*__i);
+          return true;
+        }
+    };
+
+  /** @brief std::generate() selector. */
+  template<typename _It>
+    struct __generate_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
+        bool
+        operator()(_Op& __o, _It __i)
+        {
+          *__i = __o();
+          return true;
+        }
+    };
+
+  /** @brief std::fill() selector. */
+  template<typename _It>
+    struct __fill_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __v Current value.
+       *  @param __i iterator referencing object. */
+      template<typename _ValueType>
+        bool
+        operator()(_ValueType& __v, _It __i)
+        {
+          *__i = __v;
+          return true;
+        }
+    };
+
+  /** @brief std::transform() __selector, one input sequence variant. */
+  template<typename _It>
+    struct __transform1_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
+        bool
+        operator()(_Op& __o, _It __i)
+        {
+          *__i.second = __o(*__i.first);
+          return true;
+        }
+    };
+
+  /** @brief std::transform() __selector, two input sequences variant. */
+  template<typename _It>
+    struct __transform2_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
+        bool
+        operator()(_Op& __o, _It __i)
+        {
+          *__i._M_third = __o(*__i._M_first, *__i._M_second);
+          return true;
+        }
+    };
+
+  /** @brief std::replace() selector. */
+  template<typename _It, typename _Tp>
+    struct __replace_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Value to replace with. */
+      const _Tp& __new_val;
+
+      /** @brief Constructor
+       *  @param __new_val Value to replace with. */
+      explicit
+      __replace_selector(const _Tp &__new_val) : __new_val(__new_val) {}
+
+      /** @brief Functor execution.
+       *  @param __v Current value.
+       *  @param __i iterator referencing object. */
+      bool
+      operator()(_Tp& __v, _It __i)
+      {
+        if (*__i == __v)
+          *__i = __new_val;
+        return true;
+      }
+    };
+
+  /** @brief std::replace() selector. */
+  template<typename _It, typename _Op, typename _Tp>
+    struct __replace_if_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Value to replace with. */
+      const _Tp& __new_val;
+
+      /** @brief Constructor.
+       *  @param __new_val Value to replace with. */
+      explicit
+      __replace_if_selector(const _Tp &__new_val) : __new_val(__new_val) { }
+
+      /** @brief Functor execution.
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      bool
+      operator()(_Op& __o, _It __i)
+      {
+        if (__o(*__i))
+          *__i = __new_val;
+        return true;
+      }
+    };
+
+  /** @brief std::count() selector. */
+  template<typename _It, typename _Diff>
+    struct __count_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __v Current value.
+       *  @param __i iterator referencing object.
+       *  @return 1 if count, 0 if does not count. */
+      template<typename _ValueType>
+        _Diff
+        operator()(_ValueType& __v, _It __i)
+        { return (__v == *__i) ? 1 : 0; }
+    };
+
+  /** @brief std::count_if () selector. */
+  template<typename _It, typename _Diff>
+    struct __count_if_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __o Operator.
+       *  @param __i iterator referencing object.
+       *  @return 1 if count, 0 if does not count. */
+      template<typename _Op>
+        _Diff
+        operator()(_Op& __o, _It __i)
+        { return (__o(*__i)) ? 1 : 0; }
+    };
+
+  /** @brief std::accumulate() selector. */
+  template<typename _It>
+    struct __accumulate_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __o Operator (unused).
+       *  @param __i iterator referencing object.
+       *  @return The current value. */
+      template<typename _Op>
+        typename std::iterator_traits<_It>::value_type
+        operator()(_Op __o, _It __i)
+        { return *__i; }
+    };
+
+  /** @brief std::inner_product() selector. */
+  template<typename _It, typename _It2, typename _Tp>
+    struct __inner_product_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Begin iterator of first sequence. */
+      _It  __begin1_iterator;
+
+      /** @brief Begin iterator of second sequence. */
+      _It2 __begin2_iterator;
+
+      /** @brief Constructor.
+       *  @param __b1 Begin iterator of first sequence.
+       *  @param __b2 Begin iterator of second sequence. */
+      explicit
+      __inner_product_selector(_It __b1, _It2 __b2)
+      : __begin1_iterator(__b1), __begin2_iterator(__b2) { }
+
+      /** @brief Functor execution.
+       *  @param __mult Multiplication functor.
+       *  @param __current iterator referencing object.
+       *  @return Inner product elemental __result. */
+      template<typename _Op>
+        _Tp
+        operator()(_Op __mult, _It __current)
+        {
+          typename std::iterator_traits<_It>::difference_type __position
+            = __current - __begin1_iterator;
+          return __mult(*__current, *(__begin2_iterator + __position));
+        }
+    };
+
+  /** @brief Selector that just returns the passed iterator. */
+  template<typename _It>
+    struct __identity_selector : public __generic_for_each_selector<_It>
+    {
+      /** @brief Functor execution.
+       *  @param __o Operator (unused).
+       *  @param __i iterator referencing object.
+       *  @return Passed iterator. */
+      template<typename _Op>
+        _It
+        operator()(_Op __o, _It __i)
+        { return __i; }
+    };
+
+  /** @brief Selector that returns the difference between two adjacent
+   *  __elements.
+   */
+  template<typename _It>
+    struct __adjacent_difference_selector
+    : public __generic_for_each_selector<_It>
+    {
+      template<typename _Op>
+        bool
+        operator()(_Op& __o, _It __i)
+        {
+          typename _It::first_type __go_back_one = __i.first;
+          --__go_back_one;
+          *__i.second = __o(*__i.first, *__go_back_one);
+          return true;
+        }
+    };
+
+  /** @brief Functor doing nothing
+   *
+   *  For some __reduction tasks (this is not a function object, but is
+   *  passed as __selector __dummy parameter.
+   */
+  struct _Nothing
+  {
+    /** @brief Functor execution.
+     *  @param __i iterator referencing object. */
+    template<typename _It>
+      void
+      operator()(_It __i) { }
+  };
+
+  /** @brief Reduction function doing nothing. */
+  struct _DummyReduct
+  {
+    bool
+    operator()(bool, bool) const
+    { return true; }
+  };
+
+  /** @brief Reduction for finding the maximum element, using a comparator. */
+  template<typename _Compare, typename _It>
+    struct __min_element_reduct
+    {
+      _Compare& __comp;
+
+      explicit
+      __min_element_reduct(_Compare &__c) : __comp(__c) { }
+
+      _It
+      operator()(_It __x, _It __y)
+      { return (__comp(*__x, *__y)) ? __x : __y; }
+    };
+
+  /** @brief Reduction for finding the maximum element, using a comparator. */
+  template<typename _Compare, typename _It>
+    struct __max_element_reduct
+    {
+      _Compare& __comp;
+
+      explicit
+      __max_element_reduct(_Compare& __c) : __comp(__c) { }
+
+      _It
+      operator()(_It __x, _It __y)
+      { return (__comp(*__x, *__y)) ? __y : __x; }
+    };
+
+  /** @brief General reduction, using a binary operator. */
+  template<typename _BinOp>
+    struct __accumulate_binop_reduct
+    {
+      _BinOp& __binop;
+
+      explicit
+      __accumulate_binop_reduct(_BinOp& __b) : __binop(__b) { }
+
+      template<typename _Result, typename _Addend>
+        _Result
+        operator()(const _Result& __x, const _Addend& __y)
+        { return __binop(__x, __y); }
+    };
+}
+
+#endif /* _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/iterator.h b/gcc-4.9/libstdc++-v3/include/parallel/iterator.h
new file mode 100644
index 0000000..6b482ed
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/iterator.h
@@ -0,0 +1,198 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/iterator.h
+ * @brief Helper iterator classes for the std::transform() functions.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_ITERATOR_H
+#define _GLIBCXX_PARALLEL_ITERATOR_H 1
+
+#include <parallel/basic_iterator.h>
+#include <bits/stl_pair.h>
+
+namespace __gnu_parallel
+{
+  /** @brief A pair of iterators. The usual iterator operations are
+   *  applied to both child iterators.
+   */
+  template<typename _Iterator1, typename _Iterator2,
+           typename _IteratorCategory>
+    class _IteratorPair : public std::pair<_Iterator1, _Iterator2>
+    {
+    private:
+      typedef std::pair<_Iterator1, _Iterator2> _Base;
+
+    public:
+      typedef _IteratorCategory iterator_category;
+      typedef void value_type;
+
+      typedef std::iterator_traits<_Iterator1> _TraitsType;
+      typedef typename _TraitsType::difference_type difference_type;
+      typedef _IteratorPair* pointer;
+      typedef _IteratorPair& reference;
+
+      _IteratorPair() { }
+
+      _IteratorPair(const _Iterator1& __first, const _Iterator2& __second)
+      : _Base(__first, __second) { }
+
+      // Pre-increment operator.
+      _IteratorPair&
+      operator++()
+      {
+        ++_Base::first;
+        ++_Base::second;
+        return *this;
+      }
+
+      // Post-increment operator.
+      const _IteratorPair
+      operator++(int)
+      { return _IteratorPair(_Base::first++, _Base::second++); }
+
+      // Pre-decrement operator.
+      _IteratorPair&
+      operator--()
+      {
+        --_Base::first;
+        --_Base::second;
+        return *this;
+      }
+
+      // Post-decrement operator.
+      const _IteratorPair
+      operator--(int)
+      { return _IteratorPair(_Base::first--, _Base::second--); }
+
+      // Type conversion.
+      operator _Iterator2() const
+      { return _Base::second; }
+
+      _IteratorPair&
+      operator=(const _IteratorPair& __other)
+      {
+        _Base::first = __other.first;
+        _Base::second = __other.second;
+        return *this;
+      }
+
+      _IteratorPair
+      operator+(difference_type __delta) const
+      { return _IteratorPair(_Base::first + __delta, _Base::second + __delta);
+        }
+
+      difference_type
+      operator-(const _IteratorPair& __other) const
+      { return _Base::first - __other.first; }
+  };
+
+
+  /** @brief A triple of iterators. The usual iterator operations are
+      applied to all three child iterators.
+   */
+  template<typename _Iterator1, typename _Iterator2, typename _Iterator3,
+           typename _IteratorCategory>
+    class _IteratorTriple
+    {
+    public:
+      typedef _IteratorCategory iterator_category;
+      typedef void value_type;
+      typedef typename std::iterator_traits<_Iterator1>::difference_type
+                                                            difference_type;
+      typedef _IteratorTriple* pointer;
+      typedef _IteratorTriple& reference;
+
+      _Iterator1 _M_first;
+      _Iterator2 _M_second;
+      _Iterator3 _M_third;
+
+      _IteratorTriple() { }
+
+      _IteratorTriple(const _Iterator1& __first, const _Iterator2& __second,
+                      const _Iterator3& __third)
+      {
+        _M_first = __first;
+        _M_second = __second;
+        _M_third = __third;
+      }
+
+      // Pre-increment operator.
+      _IteratorTriple&
+      operator++()
+      {
+        ++_M_first;
+        ++_M_second;
+        ++_M_third;
+        return *this;
+      }
+
+      // Post-increment operator.
+      const _IteratorTriple
+      operator++(int)
+      { return _IteratorTriple(_M_first++, _M_second++, _M_third++); }
+
+      // Pre-decrement operator.
+      _IteratorTriple&
+      operator--()
+      {
+        --_M_first;
+        --_M_second;
+        --_M_third;
+        return *this;
+      }
+
+      // Post-decrement operator.
+      const _IteratorTriple
+      operator--(int)
+      { return _IteratorTriple(_M_first--, _M_second--, _M_third--); }
+
+      // Type conversion.
+      operator _Iterator3() const
+      { return _M_third; }
+
+      _IteratorTriple&
+      operator=(const _IteratorTriple& __other)
+      {
+        _M_first = __other._M_first;
+        _M_second = __other._M_second;
+        _M_third = __other._M_third;
+        return *this;
+      }
+
+      _IteratorTriple
+      operator+(difference_type __delta) const
+      { return _IteratorTriple(_M_first + __delta, _M_second + __delta,
+                               _M_third + __delta); }
+
+      difference_type
+      operator-(const _IteratorTriple& __other) const
+      { return _M_first - __other._M_first; }
+  };
+}
+
+#endif /* _GLIBCXX_PARALLEL_ITERATOR_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/list_partition.h b/gcc-4.9/libstdc++-v3/include/parallel/list_partition.h
new file mode 100644
index 0000000..c9452a4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/list_partition.h
@@ -0,0 +1,179 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute __it and/or modify __it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that __it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/list_partition.h
+ *  @brief _Functionality to split __sequence referenced by only input
+ *  iterators.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Leonor Frias Moya and Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_LIST_PARTITION_H
+#define _GLIBCXX_PARALLEL_LIST_PARTITION_H 1
+
+#include <parallel/parallel.h>
+#include <vector>
+
+namespace __gnu_parallel
+{
+  /** @brief Shrinks and doubles the ranges.
+   *  @param __os_starts Start positions worked on (oversampled).
+   *  @param __count_to_two Counts up to 2.
+   *  @param __range_length Current length of a chunk.
+   *  @param __make_twice Whether the @c __os_starts is allowed to be
+   *  grown or not
+   */
+  template<typename _IIter>
+    void
+    __shrink_and_double(std::vector<_IIter>& __os_starts,
+			size_t& __count_to_two, size_t& __range_length,
+			const bool __make_twice)
+    {
+      ++__count_to_two;
+      if (!__make_twice || __count_to_two < 2)
+        __shrink(__os_starts, __count_to_two, __range_length);
+      else
+        {
+          __os_starts.resize((__os_starts.size() - 1) * 2 + 1);
+          __count_to_two = 0;
+        }
+    }
+
+  /** @brief Combines two ranges into one and thus halves the number of ranges.
+   *  @param __os_starts Start positions worked on (oversampled).
+   *  @param __count_to_two Counts up to 2.
+   *  @param __range_length Current length of a chunk. */
+  template<typename _IIter>
+    void
+    __shrink(std::vector<_IIter>& __os_starts, size_t& __count_to_two,
+	     size_t& __range_length)
+    {
+      for (typename std::vector<_IIter>::size_type __i = 0;
+           __i <= (__os_starts.size() / 2); ++__i)
+        __os_starts[__i] = __os_starts[__i * 2];
+      __range_length *= 2;
+    }
+
+  /** @brief Splits a sequence given by input iterators into parts of
+   * almost equal size
+   *
+   *  The function needs only one pass over the sequence.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __starts Start iterators for the resulting parts, dimension
+   *  @c __num_parts+1. For convenience, @c __starts @c [__num_parts]
+   *  contains the end iterator of the sequence.
+   *  @param __lengths Length of the resulting parts.
+   *  @param __num_parts Number of parts to split the sequence into.
+   *  @param __f Functor to be applied to each element by traversing __it
+   *  @param __oversampling Oversampling factor. If 0, then the
+   *  partitions will differ in at most 
+   *  \sqrt{\mathrm{__end} - \mathrm{__begin}} 
+   *  __elements. Otherwise, the ratio between the
+   *  longest and the shortest part is bounded by
+   *  1/(\mathrm{__oversampling} \cdot \mathrm{num\_parts})
+   *  @return Length of the whole sequence.
+   */
+  template<typename _IIter, typename _FunctorType>
+    size_t
+    list_partition(const _IIter __begin, const _IIter __end,
+                   _IIter* __starts, size_t* __lengths, const int __num_parts,
+                   _FunctorType& __f, int __oversampling = 0)
+    {
+      bool __make_twice = false;
+
+      // The resizing algorithm is chosen according to the oversampling factor.
+      if (__oversampling == 0)
+        {
+          __make_twice = true;
+          __oversampling = 1;
+        }
+
+      std::vector<_IIter> __os_starts(2 * __oversampling * __num_parts + 1);
+
+      __os_starts[0] = __begin;
+      _IIter __prev  = __begin, __it = __begin;
+      size_t __dist_limit = 0, __dist = 0;
+      size_t __cur = 1, __next = 1;
+      size_t __range_length = 1;
+      size_t __count_to_two = 0;
+      while (__it != __end)
+        {
+          __cur = __next;
+          for (; __cur < __os_starts.size() and __it != __end; ++__cur)
+            {
+              for (__dist_limit += __range_length;
+                   __dist < __dist_limit and __it != __end; ++__dist)
+                {
+                  __f(__it);
+                  ++__it;
+                }
+              __os_starts[__cur] = __it;
+            }
+
+          // Must compare for end and not __cur < __os_starts.size() , because
+          // __cur could be == __os_starts.size() as well
+          if (__it == __end)
+            break;
+
+          __shrink_and_double(__os_starts, __count_to_two, __range_length,
+                              __make_twice);
+          __next = __os_starts.size() / 2 + 1;
+        }
+
+      // Calculation of the parts (one must be extracted from __current
+      // because the partition beginning at end, consists only of
+      // itself).
+      size_t __size_part = (__cur - 1) / __num_parts;
+      int __size_greater = static_cast<int>((__cur - 1) % __num_parts);
+      __starts[0] = __os_starts[0];
+
+      size_t __index = 0;
+
+      // Smallest partitions.
+      for (int __i = 1; __i < (__num_parts + 1 - __size_greater); ++__i)
+        {
+          __lengths[__i - 1] =  __size_part * __range_length;
+          __index += __size_part;
+          __starts[__i] = __os_starts[__index];
+        }
+
+      // Biggest partitions.
+      for (int __i = __num_parts + 1 - __size_greater; __i <= __num_parts;
+           ++__i)
+        {
+          __lengths[__i - 1] =  (__size_part+1) * __range_length;
+          __index += (__size_part+1);
+          __starts[__i] = __os_starts[__index];
+        }
+
+      // Correction of the end size (the end iteration has not finished).
+      __lengths[__num_parts - 1] -= (__dist_limit - __dist);
+
+      return __dist;
+    }
+}
+
+#endif /* _GLIBCXX_PARALLEL_LIST_PARTITION_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/losertree.h b/gcc-4.9/libstdc++-v3/include/parallel/losertree.h
new file mode 100644
index 0000000..04b1e45
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/losertree.h
@@ -0,0 +1,1063 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/losertree.h
+*  @brief Many generic loser tree variants.
+*  This file is a GNU parallel extension to the Standard C++ Library.
+*/
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_LOSERTREE_H
+#define _GLIBCXX_PARALLEL_LOSERTREE_H 1
+
+#include <bits/stl_algobase.h>
+#include <bits/stl_function.h>
+#include <parallel/features.h>
+#include <parallel/base.h>
+
+namespace __gnu_parallel
+{
+  /**
+   * @brief Guarded loser/tournament tree.
+   *
+   * The smallest element is at the top.
+   *
+   * Guarding is done explicitly through one flag _M_sup per element,
+   * inf is not needed due to a better initialization routine.  This
+   * is a well-performing variant.
+   *
+   * @param _Tp the element type
+   * @param _Compare the comparator to use, defaults to std::less<_Tp>
+   */
+  template<typename _Tp, typename _Compare>
+    class _LoserTreeBase
+    {
+    protected:
+      /** @brief Internal representation of a _LoserTree element. */
+      struct _Loser
+      {
+	/** @brief flag, true iff this is a "maximum" __sentinel. */
+	bool _M_sup;
+	/** @brief __index of the __source __sequence. */
+	int _M_source;
+	/** @brief _M_key of the element in the _LoserTree. */
+	_Tp _M_key;
+      };
+
+      unsigned int _M_ik, _M_k, _M_offset;
+
+      /** log_2{_M_k} */
+      unsigned int _M_log_k;
+
+      /** @brief _LoserTree __elements. */
+      _Loser* _M_losers;
+
+      /** @brief _Compare to use. */
+      _Compare _M_comp;
+
+      /**
+       * @brief State flag that determines whether the _LoserTree is empty.
+       *
+       * Only used for building the _LoserTree.
+       */
+      bool _M_first_insert;
+
+    public:
+      /**
+       * @brief The constructor.
+       *
+       * @param __k The number of sequences to merge.
+       * @param __comp The comparator to use.
+       */
+      _LoserTreeBase(unsigned int __k, _Compare __comp)
+      : _M_comp(__comp)
+      {
+	_M_ik = __k;
+
+	// Compute log_2{_M_k} for the _Loser Tree
+	_M_log_k = __rd_log2(_M_ik - 1) + 1;
+
+	// Next greater power of 2.
+	_M_k = 1 << _M_log_k;
+	_M_offset = _M_k;
+
+	// Avoid default-constructing _M_losers[]._M_key
+	_M_losers = static_cast<_Loser*>(::operator new(2 * _M_k
+							* sizeof(_Loser)));
+	for (unsigned int __i = _M_ik - 1; __i < _M_k; ++__i)
+	  _M_losers[__i + _M_k]._M_sup = true;
+
+	_M_first_insert = true;
+      }
+
+      /**
+       * @brief The destructor.
+       */
+      ~_LoserTreeBase()
+      {
+	for (unsigned int __i = 0; __i < (2 * _M_k); ++__i)
+	  _M_losers[__i].~_Loser();
+	::operator delete(_M_losers);
+      }
+
+      /**
+       * @brief Initializes the sequence "_M_source" with the element "__key".
+       *
+       * @param __key the element to insert
+       * @param __source __index of the __source __sequence
+       * @param __sup flag that determines whether the value to insert is an
+       *   explicit __supremum.
+       */
+      void
+      __insert_start(const _Tp& __key, int __source, bool __sup)
+      {
+	unsigned int __pos = _M_k + __source;
+
+	if (_M_first_insert)
+	  {
+	    // Construct all keys, so we can easily destruct them.
+	    for (unsigned int __i = 0; __i < (2 * _M_k); ++__i)
+	      ::new(&(_M_losers[__i]._M_key)) _Tp(__key);
+	    _M_first_insert = false;
+	  }
+	else
+	  _M_losers[__pos]._M_key = __key;
+
+	_M_losers[__pos]._M_sup = __sup;
+	_M_losers[__pos]._M_source = __source;
+      }
+
+      /**
+       * @return the index of the sequence with the smallest element.
+       */
+      int __get_min_source()
+      { return _M_losers[0]._M_source; }
+    };
+
+    /**
+     * @brief Stable _LoserTree variant.
+     *
+     * Provides the stable implementations of insert_start, __init_winner,
+     * __init and __delete_min_insert.
+     *
+     * Unstable variant is done using partial specialisation below.
+     */
+  template<bool __stable/* default == true */, typename _Tp,
+	   typename _Compare>
+    class _LoserTree
+    : public _LoserTreeBase<_Tp, _Compare>
+    {
+      typedef _LoserTreeBase<_Tp, _Compare> _Base;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+      using _Base::_M_first_insert;
+
+    public:
+      _LoserTree(unsigned int __k, _Compare __comp)
+      : _Base::_LoserTreeBase(__k, __comp)
+      { }
+
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+	    if (_M_losers[__right]._M_sup
+		|| (!_M_losers[__left]._M_sup
+		    && !_M_comp(_M_losers[__right]._M_key,
+				_M_losers[__left]._M_key)))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void __init()
+      { _M_losers[0] = _M_losers[__init_winner(1)]; }
+
+      /**
+       * @brief Delete the smallest element and insert a new element from
+       *   the previously smallest element's sequence.
+       *
+       * This implementation is stable.
+       */
+      // Do not pass a const reference since __key will be used as
+      // local variable.
+      void
+      __delete_min_insert(_Tp __key, bool __sup)
+      {
+        using std::swap;
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted, ties are broken by _M_source.
+	    if ((__sup && (!_M_losers[__pos]._M_sup
+			   || _M_losers[__pos]._M_source < __source))
+		|| (!__sup && !_M_losers[__pos]._M_sup
+		    && ((_M_comp(_M_losers[__pos]._M_key, __key))
+			|| (!_M_comp(__key, _M_losers[__pos]._M_key)
+			    && _M_losers[__pos]._M_source < __source))))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		swap(_M_losers[__pos]._M_key, __key);
+	      }
+	  }
+
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
+      }
+    };
+
+    /**
+     * @brief Unstable _LoserTree variant.
+     *
+     * Stability (non-stable here) is selected with partial specialization.
+     */
+  template<typename _Tp, typename _Compare>
+    class _LoserTree</* __stable == */false, _Tp, _Compare>
+    : public _LoserTreeBase<_Tp, _Compare>
+    {
+      typedef _LoserTreeBase<_Tp, _Compare> _Base;
+      using _Base::_M_log_k;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+      using _Base::_M_first_insert;
+
+    public:
+      _LoserTree(unsigned int __k, _Compare __comp)
+      : _Base::_LoserTreeBase(__k, __comp)
+      { }
+
+      /**
+       * Computes the winner of the competition at position "__root".
+       *
+       * Called recursively (starting at 0) to build the initial tree.
+       *
+       * @param __root __index of the "game" to start.
+       */
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+	    if (_M_losers[__right]._M_sup
+		|| (!_M_losers[__left]._M_sup
+		    && !_M_comp(_M_losers[__right]._M_key,
+				_M_losers[__left]._M_key)))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void
+      __init()
+      { _M_losers[0] = _M_losers[__init_winner(1)]; }
+
+      /**
+       * Delete the _M_key smallest element and insert the element __key
+       * instead.
+       *
+       * @param __key the _M_key to insert
+       * @param __sup true iff __key is an explicitly marked supremum
+       */
+      // Do not pass a const reference since __key will be used as local
+      // variable.
+      void
+      __delete_min_insert(_Tp __key, bool __sup)
+      {
+        using std::swap;
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted.
+	    if (__sup || (!_M_losers[__pos]._M_sup
+			  && _M_comp(_M_losers[__pos]._M_key, __key)))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		swap(_M_losers[__pos]._M_key, __key);
+	      }
+	  }
+
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
+      }
+    };
+
+  /**
+   * @brief Base class of _Loser Tree implementation using pointers.
+   */
+  template<typename _Tp, typename _Compare>
+    class _LoserTreePointerBase
+    {
+    protected:
+      /** @brief Internal representation of _LoserTree __elements. */
+      struct _Loser
+      {
+	bool _M_sup;
+	int _M_source;
+	const _Tp* _M_keyp;
+      };
+
+      unsigned int _M_ik, _M_k, _M_offset;
+      _Loser* _M_losers;
+      _Compare _M_comp;
+
+    public:
+      _LoserTreePointerBase(unsigned int __k,
+			    _Compare __comp = std::less<_Tp>())
+      : _M_comp(__comp)
+      {
+	_M_ik = __k;
+
+	// Next greater power of 2.
+	_M_k = 1 << (__rd_log2(_M_ik - 1) + 1);
+	_M_offset = _M_k;
+	_M_losers = new _Loser[_M_k * 2];
+	for (unsigned int __i = _M_ik - 1; __i < _M_k; __i++)
+	  _M_losers[__i + _M_k]._M_sup = true;
+      }
+
+      ~_LoserTreePointerBase()
+      { delete[] _M_losers; }
+
+      int __get_min_source()
+      { return _M_losers[0]._M_source; }
+
+      void __insert_start(const _Tp& __key, int __source, bool __sup)
+      {
+	unsigned int __pos = _M_k + __source;
+
+	_M_losers[__pos]._M_sup = __sup;
+	_M_losers[__pos]._M_source = __source;
+	_M_losers[__pos]._M_keyp = &__key;
+      }
+    };
+
+  /**
+   * @brief Stable _LoserTree implementation.
+   *
+   * The unstable variant is implemented using partial instantiation below.
+   */
+  template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+    class _LoserTreePointer
+    : public _LoserTreePointerBase<_Tp, _Compare>
+    {
+      typedef _LoserTreePointerBase<_Tp, _Compare> _Base;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+
+    public:
+      _LoserTreePointer(unsigned int __k, _Compare __comp = std::less<_Tp>())
+      : _Base::_LoserTreePointerBase(__k, __comp)
+      { }
+
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+	    if (_M_losers[__right]._M_sup
+		|| (!_M_losers[__left]._M_sup
+		    && !_M_comp(*_M_losers[__right]._M_keyp,
+				*_M_losers[__left]._M_keyp)))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void __init()
+      { _M_losers[0] = _M_losers[__init_winner(1)]; }
+
+      void __delete_min_insert(const _Tp& __key, bool __sup)
+      {
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted, ties are broken by __source.
+	    if ((__sup && (!_M_losers[__pos]._M_sup
+			   || _M_losers[__pos]._M_source < __source))
+		|| (!__sup && !_M_losers[__pos]._M_sup &&
+		    ((_M_comp(*_M_losers[__pos]._M_keyp, *__keyp))
+		     || (!_M_comp(*__keyp, *_M_losers[__pos]._M_keyp)
+			 && _M_losers[__pos]._M_source < __source))))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
+	      }
+	  }
+
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
+      }
+    };
+
+  /**
+   * @brief Unstable _LoserTree implementation.
+   *
+   * The stable variant is above.
+   */
+  template<typename _Tp, typename _Compare>
+    class _LoserTreePointer</* __stable == */false, _Tp, _Compare>
+    : public _LoserTreePointerBase<_Tp, _Compare>
+    {
+      typedef _LoserTreePointerBase<_Tp, _Compare> _Base;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+
+    public:
+      _LoserTreePointer(unsigned int __k, _Compare __comp = std::less<_Tp>())
+      : _Base::_LoserTreePointerBase(__k, __comp)
+      { }
+
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+	    if (_M_losers[__right]._M_sup
+        	|| (!_M_losers[__left]._M_sup
+		    && !_M_comp(*_M_losers[__right]._M_keyp,
+				*_M_losers[__left]._M_keyp)))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void __init()
+      { _M_losers[0] = _M_losers[__init_winner(1)]; }
+
+      void __delete_min_insert(const _Tp& __key, bool __sup)
+      {
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted.
+	    if (__sup || (!_M_losers[__pos]._M_sup
+			  && _M_comp(*_M_losers[__pos]._M_keyp, *__keyp)))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
+	      }
+	  }
+
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
+      }
+    };
+
+  /** @brief Base class for unguarded _LoserTree implementation.
+   * 
+   * The whole element is copied into the tree structure.
+   *
+   * No guarding is done, therefore not a single input sequence must
+   * run empty.  Unused __sequence heads are marked with a sentinel which
+   * is &gt; all elements that are to be merged.
+   *
+   * This is a very fast variant.
+   */
+  template<typename _Tp, typename _Compare>
+    class _LoserTreeUnguardedBase
+    {
+    protected:
+      struct _Loser
+      {
+	int _M_source;
+	_Tp _M_key;
+      };
+
+      unsigned int _M_ik, _M_k, _M_offset;
+      _Loser* _M_losers;
+      _Compare _M_comp;
+
+    public:
+      _LoserTreeUnguardedBase(unsigned int __k, const _Tp& __sentinel,
+			      _Compare __comp = std::less<_Tp>())
+      : _M_comp(__comp)
+      {
+	_M_ik = __k;
+
+	// Next greater power of 2.
+	_M_k = 1 << (__rd_log2(_M_ik - 1) + 1);
+	_M_offset = _M_k;
+	// Avoid default-constructing _M_losers[]._M_key
+	_M_losers = static_cast<_Loser*>(::operator new(2 * _M_k
+							* sizeof(_Loser)));
+
+        for (unsigned int __i = 0; __i < _M_k; ++__i)
+          {
+	    ::new(&(_M_losers[__i]._M_key)) _Tp(__sentinel);
+	    _M_losers[__i]._M_source = -1;
+	  }
+        for (unsigned int __i = _M_k + _M_ik - 1; __i < (2 * _M_k); ++__i)
+          {
+	    ::new(&(_M_losers[__i]._M_key)) _Tp(__sentinel);
+	    _M_losers[__i]._M_source = -1;
+	  }
+      }
+
+      ~_LoserTreeUnguardedBase()
+      {
+	for (unsigned int __i = 0; __i < (2 * _M_k); ++__i)
+	  _M_losers[__i].~_Loser();
+	::operator delete(_M_losers);
+      }
+
+      int
+      __get_min_source()
+      {
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+	return _M_losers[0]._M_source;
+      }
+
+      void
+      __insert_start(const _Tp& __key, int __source, bool)
+      {
+	unsigned int __pos = _M_k + __source;
+
+	::new(&(_M_losers[__pos]._M_key)) _Tp(__key);
+	_M_losers[__pos]._M_source = __source;
+      }
+    };
+
+  /**
+   * @brief Stable implementation of unguarded _LoserTree.
+   *
+   * Unstable variant is selected below with partial specialization.
+   */
+  template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+    class _LoserTreeUnguarded
+    : public _LoserTreeUnguardedBase<_Tp, _Compare>
+    {
+      typedef _LoserTreeUnguardedBase<_Tp, _Compare> _Base;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+
+  public:
+      _LoserTreeUnguarded(unsigned int __k, const _Tp& __sentinel,
+			  _Compare __comp = std::less<_Tp>())
+      : _Base::_LoserTreeUnguardedBase(__k, __sentinel, __comp)
+      { }
+
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+	    if (!_M_comp(_M_losers[__right]._M_key,
+			 _M_losers[__left]._M_key))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void
+      __init()
+      {
+	_M_losers[0] = _M_losers[__init_winner(1)];
+
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top at the beginning
+	// (0 sequences!)
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+      }
+
+      // Do not pass a const reference since __key will be used as
+      // local variable.
+      void
+      __delete_min_insert(_Tp __key, bool)
+      {
+        using std::swap;
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted, ties are broken by _M_source.
+	    if (_M_comp(_M_losers[__pos]._M_key, __key)
+        	|| (!_M_comp(__key, _M_losers[__pos]._M_key)
+                    && _M_losers[__pos]._M_source < __source))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_source, __source);
+		swap(_M_losers[__pos]._M_key, __key);
+	      }
+	  }
+
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
+      }
+    };
+
+  /**
+   * @brief Non-Stable implementation of unguarded _LoserTree.
+   *
+   * Stable implementation is above.
+   */
+  template<typename _Tp, typename _Compare>
+    class _LoserTreeUnguarded</* __stable == */false, _Tp, _Compare>
+    : public _LoserTreeUnguardedBase<_Tp, _Compare>
+    {
+      typedef _LoserTreeUnguardedBase<_Tp, _Compare> _Base;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+
+    public:
+      _LoserTreeUnguarded(unsigned int __k, const _Tp& __sentinel,
+			  _Compare __comp = std::less<_Tp>())
+      : _Base::_LoserTreeUnguardedBase(__k, __sentinel, __comp)
+      { }
+
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+
+#if _GLIBCXX_ASSERTIONS
+	    // If __left one is sentinel then __right one must be, too.
+	    if (_M_losers[__left]._M_source == -1)
+	      _GLIBCXX_PARALLEL_ASSERT(_M_losers[__right]._M_source == -1);
+#endif
+
+	    if (!_M_comp(_M_losers[__right]._M_key,
+			 _M_losers[__left]._M_key))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void
+      __init()
+      {
+	_M_losers[0] = _M_losers[__init_winner(1)];
+
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top at the beginning
+	// (0 sequences!)
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+      }
+
+      // Do not pass a const reference since __key will be used as
+      // local variable.
+      void
+      __delete_min_insert(_Tp __key, bool)
+      {
+        using std::swap;
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted.
+	    if (_M_comp(_M_losers[__pos]._M_key, __key))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_source, __source);
+		swap(_M_losers[__pos]._M_key, __key);
+	      }
+	  }
+
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
+      }
+    };
+
+  /** @brief Unguarded loser tree, keeping only pointers to the
+  * elements in the tree structure.
+  *
+  *  No guarding is done, therefore not a single input sequence must
+  *  run empty.  This is a very fast variant.
+  */
+  template<typename _Tp, typename _Compare>
+    class _LoserTreePointerUnguardedBase
+    {
+    protected:
+      struct _Loser
+      {
+	int _M_source;
+	const _Tp* _M_keyp;
+      };
+
+      unsigned int _M_ik, _M_k, _M_offset;
+      _Loser* _M_losers;
+      _Compare _M_comp;
+
+    public:
+
+      _LoserTreePointerUnguardedBase(unsigned int __k, const _Tp& __sentinel,
+				     _Compare __comp = std::less<_Tp>())
+      : _M_comp(__comp)
+      {
+	_M_ik = __k;
+
+	// Next greater power of 2.
+	_M_k = 1 << (__rd_log2(_M_ik - 1) + 1);
+	_M_offset = _M_k;
+	// Avoid default-constructing _M_losers[]._M_key
+	_M_losers = new _Loser[2 * _M_k];
+
+	for (unsigned int __i = _M_k + _M_ik - 1; __i < (2 * _M_k); ++__i)
+	  {
+	    _M_losers[__i]._M_keyp = &__sentinel;
+	    _M_losers[__i]._M_source = -1;
+	  }
+      }
+
+      ~_LoserTreePointerUnguardedBase()
+      { delete[] _M_losers; }
+
+      int
+      __get_min_source()
+      {
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+	return _M_losers[0]._M_source;
+      }
+
+      void
+      __insert_start(const _Tp& __key, int __source, bool)
+      {
+	unsigned int __pos = _M_k + __source;
+
+	_M_losers[__pos]._M_keyp = &__key;
+	_M_losers[__pos]._M_source = __source;
+      }
+    };
+
+  /**
+   * @brief Stable unguarded _LoserTree variant storing pointers.
+   *
+   * Unstable variant is implemented below using partial specialization.
+   */
+  template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+    class _LoserTreePointerUnguarded
+    : public _LoserTreePointerUnguardedBase<_Tp, _Compare>
+    {
+      typedef _LoserTreePointerUnguardedBase<_Tp, _Compare> _Base;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+
+    public:
+      _LoserTreePointerUnguarded(unsigned int __k, const _Tp& __sentinel,
+				 _Compare __comp = std::less<_Tp>())
+      : _Base::_LoserTreePointerUnguardedBase(__k, __sentinel, __comp)
+      { }
+
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+	    if (!_M_comp(*_M_losers[__right]._M_keyp,
+			 *_M_losers[__left]._M_keyp))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void
+      __init()
+      {
+	_M_losers[0] = _M_losers[__init_winner(1)];
+
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top at the beginning
+	// (0 sequences!)
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+      }
+
+      void
+      __delete_min_insert(const _Tp& __key, bool __sup)
+      {
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted, ties are broken by _M_source.
+	    if (_M_comp(*_M_losers[__pos]._M_keyp, *__keyp)
+		|| (!_M_comp(*__keyp, *_M_losers[__pos]._M_keyp)
+		    && _M_losers[__pos]._M_source < __source))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
+	      }
+	  }
+
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
+      }
+    };
+
+  /**
+   * @brief Unstable unguarded _LoserTree variant storing pointers.
+   *
+   * Stable variant is above.
+   */
+  template<typename _Tp, typename _Compare>
+    class _LoserTreePointerUnguarded</* __stable == */false, _Tp, _Compare>
+    : public _LoserTreePointerUnguardedBase<_Tp, _Compare>
+    {
+      typedef _LoserTreePointerUnguardedBase<_Tp, _Compare> _Base;
+      using _Base::_M_k;
+      using _Base::_M_comp;
+      using _Base::_M_losers;
+
+  public:
+      _LoserTreePointerUnguarded(unsigned int __k, const _Tp& __sentinel,
+				 _Compare __comp = std::less<_Tp>())
+      : _Base::_LoserTreePointerUnguardedBase(__k, __sentinel, __comp)
+      { }
+
+      unsigned int
+      __init_winner(unsigned int __root)
+      {
+	if (__root >= _M_k)
+	  return __root;
+	else
+	  {
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+
+#if _GLIBCXX_ASSERTIONS
+	    // If __left one is sentinel then __right one must be, too.
+	    if (_M_losers[__left]._M_source == -1)
+	      _GLIBCXX_PARALLEL_ASSERT(_M_losers[__right]._M_source == -1);
+#endif
+
+	    if (!_M_comp(*_M_losers[__right]._M_keyp,
+			 *_M_losers[__left]._M_keyp))
+	      {
+		// Left one is less or equal.
+		_M_losers[__root] = _M_losers[__right];
+		return __left;
+	      }
+	    else
+	      {
+		// Right one is less.
+		_M_losers[__root] = _M_losers[__left];
+		return __right;
+	      }
+	  }
+      }
+
+      void
+      __init()
+      {
+	_M_losers[0] = _M_losers[__init_winner(1)];
+
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top at the beginning
+	// (0 sequences!)
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+      }
+
+      void
+      __delete_min_insert(const _Tp& __key, bool __sup)
+      {
+#if _GLIBCXX_ASSERTIONS
+	// no dummy sequence can ever be at the top!
+	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
+#endif
+
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
+	  {
+	    // The smaller one gets promoted.
+	    if (_M_comp(*(_M_losers[__pos]._M_keyp), *__keyp))
+	      {
+		// The other one is smaller.
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
+	      }
+	  }
+
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
+      }
+    };
+} // namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_LOSERTREE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/merge.h b/gcc-4.9/libstdc++-v3/include/parallel/merge.h
new file mode 100644
index 0000000..65f3d3e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/merge.h
@@ -0,0 +1,251 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/merge.h
+ *  @brief Parallel implementation of std::merge().
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_MERGE_H
+#define _GLIBCXX_PARALLEL_MERGE_H 1
+
+#include <parallel/basic_iterator.h>
+#include <bits/stl_algo.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Merge routine being able to merge only the @c __max_length
+   * smallest elements.
+   *
+   * The @c __begin iterators are advanced accordingly, they might not
+   * reach @c __end, in contrast to the usual variant.
+   * @param __begin1 Begin iterator of first sequence.
+   * @param __end1 End iterator of first sequence.
+   * @param __begin2 Begin iterator of second sequence.
+   * @param __end2 End iterator of second sequence.
+   * @param __target Target begin iterator.
+   * @param __max_length Maximum number of elements to merge.
+   * @param __comp Comparator.
+   * @return Output end iterator. */
+  template<typename _RAIter1, typename _RAIter2,
+           typename _OutputIterator, typename _DifferenceTp,
+           typename _Compare>
+    _OutputIterator
+    __merge_advance_usual(_RAIter1& __begin1, _RAIter1 __end1,
+			  _RAIter2& __begin2, _RAIter2 __end2,
+			  _OutputIterator __target,
+			  _DifferenceTp __max_length, _Compare __comp)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      while (__begin1 != __end1 && __begin2 != __end2 && __max_length > 0)
+        {
+          // array1[__i1] < array0[i0]
+          if (__comp(*__begin2, *__begin1))
+            *__target++ = *__begin2++;
+          else
+            *__target++ = *__begin1++;
+          --__max_length;
+        }
+
+      if (__begin1 != __end1)
+        {
+          __target = std::copy(__begin1, __begin1 + __max_length, __target);
+          __begin1 += __max_length;
+        }
+      else
+        {
+          __target = std::copy(__begin2, __begin2 + __max_length, __target);
+          __begin2 += __max_length;
+        }
+      return __target;
+    }
+
+  /** @brief Merge routine being able to merge only the @c __max_length
+   * smallest elements.
+   *
+   * The @c __begin iterators are advanced accordingly, they might not
+   * reach @c __end, in contrast to the usual variant.
+   * Specially designed code should allow the compiler to generate
+   * conditional moves instead of branches.
+   * @param __begin1 Begin iterator of first sequence.
+   * @param __end1 End iterator of first sequence.
+   * @param __begin2 Begin iterator of second sequence.
+   * @param __end2 End iterator of second sequence.
+   * @param __target Target begin iterator.
+   * @param __max_length Maximum number of elements to merge.
+   * @param __comp Comparator.
+   * @return Output end iterator. */
+  template<typename _RAIter1, typename _RAIter2,
+           typename _OutputIterator, typename _DifferenceTp,
+           typename _Compare>
+    _OutputIterator
+    __merge_advance_movc(_RAIter1& __begin1, _RAIter1 __end1,
+			 _RAIter2& __begin2, _RAIter2 __end2,
+			 _OutputIterator __target,
+			 _DifferenceTp __max_length, _Compare __comp)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+        _ValueType1;
+      typedef typename std::iterator_traits<_RAIter2>::value_type
+        _ValueType2;
+
+#if _GLIBCXX_ASSERTIONS
+      _GLIBCXX_PARALLEL_ASSERT(__max_length >= 0);
+#endif
+
+      while (__begin1 != __end1 && __begin2 != __end2 && __max_length > 0)
+        {
+          _RAIter1 __next1 = __begin1 + 1;
+          _RAIter2 __next2 = __begin2 + 1;
+          _ValueType1 __element1 = *__begin1;
+          _ValueType2 __element2 = *__begin2;
+
+          if (__comp(__element2, __element1))
+            {
+              __element1 = __element2;
+              __begin2 = __next2;
+            }
+          else
+            __begin1 = __next1;
+
+          *__target = __element1;
+
+          ++__target;
+          --__max_length;
+        }
+      if (__begin1 != __end1)
+        {
+          __target = std::copy(__begin1, __begin1 + __max_length, __target);
+          __begin1 += __max_length;
+        }
+      else
+        {
+          __target = std::copy(__begin2, __begin2 + __max_length, __target);
+          __begin2 += __max_length;
+        }
+      return __target;
+    }
+
+  /** @brief Merge routine being able to merge only the @c __max_length
+   * smallest elements.
+   *
+   *  The @c __begin iterators are advanced accordingly, they might not
+   *  reach @c __end, in contrast to the usual variant.
+   *  Static switch on whether to use the conditional-move variant.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence.
+   *  @param __end2 End iterator of second sequence.
+   *  @param __target Target begin iterator.
+   *  @param __max_length Maximum number of elements to merge.
+   *  @param __comp Comparator.
+   *  @return Output end iterator. */
+  template<typename _RAIter1, typename _RAIter2,
+           typename _OutputIterator, typename _DifferenceTp,
+           typename _Compare>
+    inline _OutputIterator
+    __merge_advance(_RAIter1& __begin1, _RAIter1 __end1,
+		    _RAIter2& __begin2, _RAIter2 __end2,
+		    _OutputIterator __target, _DifferenceTp __max_length,
+		    _Compare __comp)
+    {
+      _GLIBCXX_CALL(__max_length)
+
+      return __merge_advance_movc(__begin1, __end1, __begin2, __end2,
+				  __target, __max_length, __comp);
+    }
+
+  /** @brief Merge routine fallback to sequential in case the
+      iterators of the two input sequences are of different type.
+      *  @param __begin1 Begin iterator of first sequence.
+      *  @param __end1 End iterator of first sequence.
+      *  @param __begin2 Begin iterator of second sequence.
+      *  @param __end2 End iterator of second sequence.
+      *  @param __target Target begin iterator.
+      *  @param __max_length Maximum number of elements to merge.
+      *  @param __comp Comparator.
+      *  @return Output end iterator. */
+  template<typename _RAIter1, typename _RAIter2,
+           typename _RAIter3, typename _Compare>
+    inline _RAIter3
+    __parallel_merge_advance(_RAIter1& __begin1, _RAIter1 __end1,
+			     _RAIter2& __begin2,
+			     // different iterators, parallel implementation
+			     // not available
+			     _RAIter2 __end2, _RAIter3 __target, typename
+			     std::iterator_traits<_RAIter1>::
+			     difference_type __max_length, _Compare __comp)
+    { return __merge_advance(__begin1, __end1, __begin2, __end2, __target,
+			     __max_length, __comp); }
+
+  /** @brief Parallel merge routine being able to merge only the @c
+   * __max_length smallest elements.
+   *
+   *  The @c __begin iterators are advanced accordingly, they might not
+   *  reach @c __end, in contrast to the usual variant.
+   *  The functionality is projected onto parallel_multiway_merge.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence.
+   *  @param __end2 End iterator of second sequence.
+   *  @param __target Target begin iterator.
+   *  @param __max_length Maximum number of elements to merge.
+   *  @param __comp Comparator.
+   *  @return Output end iterator.
+   */
+  template<typename _RAIter1, typename _RAIter3,
+           typename _Compare>
+    inline _RAIter3
+    __parallel_merge_advance(_RAIter1& __begin1, _RAIter1 __end1,
+			     _RAIter1& __begin2, _RAIter1 __end2,
+			     _RAIter3 __target, typename
+			     std::iterator_traits<_RAIter1>::
+			     difference_type __max_length, _Compare __comp)
+    {
+      typedef typename
+          std::iterator_traits<_RAIter1>::value_type _ValueType;
+      typedef typename std::iterator_traits<_RAIter1>::
+        difference_type _DifferenceType1 /* == difference_type2 */;
+      typedef typename std::iterator_traits<_RAIter3>::
+        difference_type _DifferenceType3;
+      typedef typename std::pair<_RAIter1, _RAIter1>
+        _IteratorPair;
+
+      _IteratorPair __seqs[2] = { std::make_pair(__begin1, __end1),
+				  std::make_pair(__begin2, __end2) };
+      _RAIter3 __target_end = parallel_multiway_merge
+	< /* __stable = */ true, /* __sentinels = */ false>
+	(__seqs, __seqs + 2, __target, multiway_merge_exact_splitting
+	 < /* __stable = */ true, _IteratorPair*,
+	 _Compare, _DifferenceType1>, __max_length, __comp,
+	 omp_get_max_threads());
+
+      return __target_end;
+    }
+}       //namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_MERGE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/multiseq_selection.h b/gcc-4.9/libstdc++-v3/include/parallel/multiseq_selection.h
new file mode 100644
index 0000000..225c183
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/multiseq_selection.h
@@ -0,0 +1,644 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/multiseq_selection.h
+ *  @brief Functions to find elements of a certain global __rank in
+ *  multiple sorted sequences.  Also serves for splitting such
+ *  sequence sets.
+ *
+ *  The algorithm description can be found in 
+ *
+ *  P. J. Varman, S. D. Scheufler, B. R. Iyer, and G. R. Ricard.
+ *  Merging Multiple Lists on Hierarchical-Memory Multiprocessors.
+ *  Journal of Parallel and Distributed Computing, 12(2):171–177, 1991.
+ *
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_MULTISEQ_SELECTION_H
+#define _GLIBCXX_PARALLEL_MULTISEQ_SELECTION_H 1
+
+#include <vector>
+#include <queue>
+
+#include <bits/stl_algo.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Compare __a pair of types lexicographically, ascending. */
+  template<typename _T1, typename _T2, typename _Compare>
+    class _Lexicographic
+    : public std::binary_function<std::pair<_T1, _T2>,
+				  std::pair<_T1, _T2>, bool>
+    {
+    private:
+      _Compare& _M_comp;
+
+    public:
+      _Lexicographic(_Compare& __comp) : _M_comp(__comp) { }
+
+      bool
+      operator()(const std::pair<_T1, _T2>& __p1,
+                 const std::pair<_T1, _T2>& __p2) const
+      {
+        if (_M_comp(__p1.first, __p2.first))
+          return true;
+
+        if (_M_comp(__p2.first, __p1.first))
+          return false;
+
+        // Firsts are equal.
+        return __p1.second < __p2.second;
+      }
+    };
+
+  /** @brief Compare __a pair of types lexicographically, descending. */
+  template<typename _T1, typename _T2, typename _Compare>
+    class _LexicographicReverse : public std::binary_function<_T1, _T2, bool>
+    {
+    private:
+      _Compare& _M_comp;
+
+    public:
+      _LexicographicReverse(_Compare& __comp) : _M_comp(__comp) { }
+
+      bool
+      operator()(const std::pair<_T1, _T2>& __p1,
+                 const std::pair<_T1, _T2>& __p2) const
+      {
+        if (_M_comp(__p2.first, __p1.first))
+          return true;
+
+        if (_M_comp(__p1.first, __p2.first))
+          return false;
+
+        // Firsts are equal.
+        return __p2.second < __p1.second;
+      }
+    };
+
+  /** 
+   *  @brief Splits several sorted sequences at a certain global __rank,
+   *  resulting in a splitting point for each sequence.
+   *  The sequences are passed via a sequence of random-access
+   *  iterator pairs, none of the sequences may be empty.  If there
+   *  are several equal elements across the split, the ones on the
+   *  __left side will be chosen from sequences with smaller number.
+   *  @param __begin_seqs Begin of the sequence of iterator pairs.
+   *  @param __end_seqs End of the sequence of iterator pairs.
+   *  @param __rank The global rank to partition at.
+   *  @param __begin_offsets A random-access __sequence __begin where the
+   *  __result will be stored in. Each element of the sequence is an
+   *  iterator that points to the first element on the greater part of
+   *  the respective __sequence.
+   *  @param __comp The ordering functor, defaults to std::less<_Tp>. 
+   */
+  template<typename _RanSeqs, typename _RankType, typename _RankIterator,
+            typename _Compare>
+    void
+    multiseq_partition(_RanSeqs __begin_seqs, _RanSeqs __end_seqs,
+                       _RankType __rank,
+                       _RankIterator __begin_offsets,
+                       _Compare __comp = std::less<
+                       typename std::iterator_traits<typename
+                       std::iterator_traits<_RanSeqs>::value_type::
+                       first_type>::value_type>()) // std::less<_Tp>
+    {
+      _GLIBCXX_CALL(__end_seqs - __begin_seqs)
+
+      typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type
+        _It;
+      typedef typename std::iterator_traits<_RanSeqs>::difference_type
+        _SeqNumber;
+      typedef typename std::iterator_traits<_It>::difference_type
+               _DifferenceType;
+      typedef typename std::iterator_traits<_It>::value_type _ValueType;
+
+      _Lexicographic<_ValueType, _SeqNumber, _Compare> __lcomp(__comp);
+      _LexicographicReverse<_ValueType, _SeqNumber, _Compare> __lrcomp(__comp);
+
+      // Number of sequences, number of elements in total (possibly
+      // including padding).
+      _DifferenceType __m = std::distance(__begin_seqs, __end_seqs), __nn = 0,
+                      __nmax, __n, __r;
+
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        {
+          __nn += std::distance(__begin_seqs[__i].first,
+                               __begin_seqs[__i].second);
+          _GLIBCXX_PARALLEL_ASSERT(
+            std::distance(__begin_seqs[__i].first,
+                          __begin_seqs[__i].second) > 0);
+        }
+
+      if (__rank == __nn)
+        {
+          for (_SeqNumber __i = 0; __i < __m; __i++)
+            __begin_offsets[__i] = __begin_seqs[__i].second; // Very end.
+          // Return __m - 1;
+          return;
+        }
+
+      _GLIBCXX_PARALLEL_ASSERT(__m != 0);
+      _GLIBCXX_PARALLEL_ASSERT(__nn != 0);
+      _GLIBCXX_PARALLEL_ASSERT(__rank >= 0);
+      _GLIBCXX_PARALLEL_ASSERT(__rank < __nn);
+
+      _DifferenceType* __ns = new _DifferenceType[__m];
+      _DifferenceType* __a = new _DifferenceType[__m];
+      _DifferenceType* __b = new _DifferenceType[__m];
+      _DifferenceType __l;
+
+      __ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second);
+      __nmax = __ns[0];
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        {
+          __ns[__i] = std::distance(__begin_seqs[__i].first,
+                                    __begin_seqs[__i].second);
+          __nmax = std::max(__nmax, __ns[__i]);
+        }
+
+      __r = __rd_log2(__nmax) + 1;
+
+      // Pad all lists to this length, at least as long as any ns[__i],
+      // equality iff __nmax = 2^__k - 1.
+      __l = (1ULL << __r) - 1;
+
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        {
+          __a[__i] = 0;
+          __b[__i] = __l;
+        }
+      __n = __l / 2;
+
+      // Invariants:
+      // 0 <= __a[__i] <= __ns[__i], 0 <= __b[__i] <= __l
+
+#define __S(__i) (__begin_seqs[__i].first)
+
+      // Initial partition.
+      std::vector<std::pair<_ValueType, _SeqNumber> > __sample;
+
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        if (__n < __ns[__i])    //__sequence long enough
+          __sample.push_back(std::make_pair(__S(__i)[__n], __i));
+      __gnu_sequential::sort(__sample.begin(), __sample.end(), __lcomp);
+
+      for (_SeqNumber __i = 0; __i < __m; __i++)       //conceptual infinity
+        if (__n >= __ns[__i])   //__sequence too short, conceptual infinity
+          __sample.push_back(
+            std::make_pair(__S(__i)[0] /*__dummy element*/, __i));
+
+      _DifferenceType __localrank = __rank / __l;
+
+      _SeqNumber __j;
+      for (__j = 0;
+           __j < __localrank && ((__n + 1) <= __ns[__sample[__j].second]);
+           ++__j)
+        __a[__sample[__j].second] += __n + 1;
+      for (; __j < __m; __j++)
+        __b[__sample[__j].second] -= __n + 1;
+      
+      // Further refinement.
+      while (__n > 0)
+        {
+          __n /= 2;
+
+          _SeqNumber __lmax_seq = -1;  // to avoid warning
+          const _ValueType* __lmax = 0; // impossible to avoid the warning?
+          for (_SeqNumber __i = 0; __i < __m; __i++)
+            {
+              if (__a[__i] > 0)
+                {
+                  if (!__lmax)
+                    {
+                      __lmax = &(__S(__i)[__a[__i] - 1]);
+                      __lmax_seq = __i;
+                    }
+                  else
+                    {
+                      // Max, favor rear sequences.
+                      if (!__comp(__S(__i)[__a[__i] - 1], *__lmax))
+                        {
+                          __lmax = &(__S(__i)[__a[__i] - 1]);
+                          __lmax_seq = __i;
+                        }
+                    }
+                }
+            }
+
+          _SeqNumber __i;
+          for (__i = 0; __i < __m; __i++)
+            {
+              _DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
+              if (__lmax && __middle < __ns[__i] &&
+                  __lcomp(std::make_pair(__S(__i)[__middle], __i),
+                        std::make_pair(*__lmax, __lmax_seq)))
+                __a[__i] = std::min(__a[__i] + __n + 1, __ns[__i]);
+              else
+                __b[__i] -= __n + 1;
+            }
+
+          _DifferenceType __leftsize = 0;
+          for (_SeqNumber __i = 0; __i < __m; __i++)
+              __leftsize += __a[__i] / (__n + 1);
+
+          _DifferenceType __skew = __rank / (__n + 1) - __leftsize;
+
+          if (__skew > 0)
+            {
+              // Move to the left, find smallest.
+              std::priority_queue<std::pair<_ValueType, _SeqNumber>,
+                std::vector<std::pair<_ValueType, _SeqNumber> >,
+                _LexicographicReverse<_ValueType, _SeqNumber, _Compare> >
+                __pq(__lrcomp);
+              
+              for (_SeqNumber __i = 0; __i < __m; __i++)
+                if (__b[__i] < __ns[__i])
+                  __pq.push(std::make_pair(__S(__i)[__b[__i]], __i));
+
+              for (; __skew != 0 && !__pq.empty(); --__skew)
+                {
+                  _SeqNumber __source = __pq.top().second;
+                  __pq.pop();
+
+                  __a[__source]
+                      = std::min(__a[__source] + __n + 1, __ns[__source]);
+                  __b[__source] += __n + 1;
+
+                  if (__b[__source] < __ns[__source])
+                    __pq.push(
+                      std::make_pair(__S(__source)[__b[__source]], __source));
+                }
+            }
+          else if (__skew < 0)
+            {
+              // Move to the right, find greatest.
+              std::priority_queue<std::pair<_ValueType, _SeqNumber>,
+                std::vector<std::pair<_ValueType, _SeqNumber> >,
+                _Lexicographic<_ValueType, _SeqNumber, _Compare> >
+                  __pq(__lcomp);
+
+              for (_SeqNumber __i = 0; __i < __m; __i++)
+                if (__a[__i] > 0)
+                  __pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i));
+
+              for (; __skew != 0; ++__skew)
+                {
+                  _SeqNumber __source = __pq.top().second;
+                  __pq.pop();
+
+                  __a[__source] -= __n + 1;
+                  __b[__source] -= __n + 1;
+
+                  if (__a[__source] > 0)
+                    __pq.push(std::make_pair(
+                        __S(__source)[__a[__source] - 1], __source));
+                }
+            }
+        }
+
+      // Postconditions:
+      // __a[__i] == __b[__i] in most cases, except when __a[__i] has been
+      // clamped because of having reached the boundary
+
+      // Now return the result, calculate the offset.
+
+      // Compare the keys on both edges of the border.
+
+      // Maximum of left edge, minimum of right edge.
+      _ValueType* __maxleft = 0;
+      _ValueType* __minright = 0;
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        {
+          if (__a[__i] > 0)
+            {
+              if (!__maxleft)
+                __maxleft = &(__S(__i)[__a[__i] - 1]);
+              else
+                {
+                  // Max, favor rear sequences.
+                  if (!__comp(__S(__i)[__a[__i] - 1], *__maxleft))
+                    __maxleft = &(__S(__i)[__a[__i] - 1]);
+                }
+            }
+          if (__b[__i] < __ns[__i])
+            {
+              if (!__minright)
+                __minright = &(__S(__i)[__b[__i]]);
+              else
+                {
+                  // Min, favor fore sequences.
+                  if (__comp(__S(__i)[__b[__i]], *__minright))
+                    __minright = &(__S(__i)[__b[__i]]);
+                }
+            }
+        }
+
+      _SeqNumber __seq = 0;
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        __begin_offsets[__i] = __S(__i) + __a[__i];
+
+      delete[] __ns;
+      delete[] __a;
+      delete[] __b;
+    }
+
+
+  /** 
+   *  @brief Selects the element at a certain global __rank from several
+   *  sorted sequences.
+   *
+   *  The sequences are passed via a sequence of random-access
+   *  iterator pairs, none of the sequences may be empty.
+   *  @param __begin_seqs Begin of the sequence of iterator pairs.
+   *  @param __end_seqs End of the sequence of iterator pairs.
+   *  @param __rank The global rank to partition at.
+   *  @param __offset The rank of the selected element in the global
+   *  subsequence of elements equal to the selected element. If the
+   *  selected element is unique, this number is 0.
+   *  @param __comp The ordering functor, defaults to std::less. 
+   */
+  template<typename _Tp, typename _RanSeqs, typename _RankType,
+           typename _Compare>
+    _Tp
+    multiseq_selection(_RanSeqs __begin_seqs, _RanSeqs __end_seqs,
+                       _RankType __rank,
+                       _RankType& __offset, _Compare __comp = std::less<_Tp>())
+    {
+      _GLIBCXX_CALL(__end_seqs - __begin_seqs)
+
+      typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type
+        _It;
+      typedef typename std::iterator_traits<_RanSeqs>::difference_type
+        _SeqNumber;
+      typedef typename std::iterator_traits<_It>::difference_type
+        _DifferenceType;
+
+      _Lexicographic<_Tp, _SeqNumber, _Compare> __lcomp(__comp);
+      _LexicographicReverse<_Tp, _SeqNumber, _Compare> __lrcomp(__comp);
+
+      // Number of sequences, number of elements in total (possibly
+      // including padding).
+      _DifferenceType __m = std::distance(__begin_seqs, __end_seqs);
+      _DifferenceType __nn = 0;
+      _DifferenceType __nmax, __n, __r;
+
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        __nn += std::distance(__begin_seqs[__i].first,
+			      __begin_seqs[__i].second);
+
+      if (__m == 0 || __nn == 0 || __rank < 0 || __rank >= __nn)
+        {
+          // result undefined if there is no data or __rank is outside bounds
+          throw std::exception();
+        }
+
+
+      _DifferenceType* __ns = new _DifferenceType[__m];
+      _DifferenceType* __a = new _DifferenceType[__m];
+      _DifferenceType* __b = new _DifferenceType[__m];
+      _DifferenceType __l;
+
+      __ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second);
+      __nmax = __ns[0];
+      for (_SeqNumber __i = 0; __i < __m; ++__i)
+        {
+          __ns[__i] = std::distance(__begin_seqs[__i].first,
+                                    __begin_seqs[__i].second);
+          __nmax = std::max(__nmax, __ns[__i]);
+        }
+
+      __r = __rd_log2(__nmax) + 1;
+
+      // Pad all lists to this length, at least as long as any ns[__i],
+      // equality iff __nmax = 2^__k - 1
+      __l = __round_up_to_pow2(__r) - 1;
+
+      for (_SeqNumber __i = 0; __i < __m; ++__i)
+        {
+          __a[__i] = 0;
+          __b[__i] = __l;
+        }
+      __n = __l / 2;
+
+      // Invariants:
+      // 0 <= __a[__i] <= __ns[__i], 0 <= __b[__i] <= __l
+
+#define __S(__i) (__begin_seqs[__i].first)
+
+      // Initial partition.
+      std::vector<std::pair<_Tp, _SeqNumber> > __sample;
+
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        if (__n < __ns[__i])
+          __sample.push_back(std::make_pair(__S(__i)[__n], __i));
+      __gnu_sequential::sort(__sample.begin(), __sample.end(),
+                             __lcomp, sequential_tag());
+
+      // Conceptual infinity.
+      for (_SeqNumber __i = 0; __i < __m; __i++)
+        if (__n >= __ns[__i])
+          __sample.push_back(
+            std::make_pair(__S(__i)[0] /*__dummy element*/, __i));
+
+      _DifferenceType __localrank = __rank / __l;
+
+      _SeqNumber __j;
+      for (__j = 0;
+           __j < __localrank && ((__n + 1) <= __ns[__sample[__j].second]);
+           ++__j)
+        __a[__sample[__j].second] += __n + 1;
+      for (; __j < __m; ++__j)
+        __b[__sample[__j].second] -= __n + 1;
+
+      // Further refinement.
+      while (__n > 0)
+        {
+          __n /= 2;
+
+          const _Tp* __lmax = 0;
+          for (_SeqNumber __i = 0; __i < __m; ++__i)
+            {
+              if (__a[__i] > 0)
+                {
+                  if (!__lmax)
+                    __lmax = &(__S(__i)[__a[__i] - 1]);
+                  else
+                    {
+                      if (__comp(*__lmax, __S(__i)[__a[__i] - 1]))      //max
+                        __lmax = &(__S(__i)[__a[__i] - 1]);
+                    }
+                }
+            }
+
+          _SeqNumber __i;
+          for (__i = 0; __i < __m; __i++)
+            {
+              _DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
+              if (__lmax && __middle < __ns[__i]
+                  && __comp(__S(__i)[__middle], *__lmax))
+                __a[__i] = std::min(__a[__i] + __n + 1, __ns[__i]);
+              else
+                __b[__i] -= __n + 1;
+            }
+
+          _DifferenceType __leftsize = 0;
+          for (_SeqNumber __i = 0; __i < __m; ++__i)
+              __leftsize += __a[__i] / (__n + 1);
+
+          _DifferenceType __skew = __rank / (__n + 1) - __leftsize;
+
+          if (__skew > 0)
+            {
+              // Move to the left, find smallest.
+              std::priority_queue<std::pair<_Tp, _SeqNumber>,
+                std::vector<std::pair<_Tp, _SeqNumber> >,
+                _LexicographicReverse<_Tp, _SeqNumber, _Compare> >
+                  __pq(__lrcomp);
+
+              for (_SeqNumber __i = 0; __i < __m; ++__i)
+                if (__b[__i] < __ns[__i])
+                  __pq.push(std::make_pair(__S(__i)[__b[__i]], __i));
+
+              for (; __skew != 0 && !__pq.empty(); --__skew)
+                {
+                  _SeqNumber __source = __pq.top().second;
+                  __pq.pop();
+
+                  __a[__source]
+                      = std::min(__a[__source] + __n + 1, __ns[__source]);
+                  __b[__source] += __n + 1;
+
+                  if (__b[__source] < __ns[__source])
+                    __pq.push(
+                      std::make_pair(__S(__source)[__b[__source]], __source));
+                }
+            }
+          else if (__skew < 0)
+            {
+              // Move to the right, find greatest.
+              std::priority_queue<std::pair<_Tp, _SeqNumber>,
+                std::vector<std::pair<_Tp, _SeqNumber> >,
+                _Lexicographic<_Tp, _SeqNumber, _Compare> > __pq(__lcomp);
+
+              for (_SeqNumber __i = 0; __i < __m; ++__i)
+                if (__a[__i] > 0)
+                  __pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i));
+
+              for (; __skew != 0; ++__skew)
+                {
+                  _SeqNumber __source = __pq.top().second;
+                  __pq.pop();
+
+                  __a[__source] -= __n + 1;
+                  __b[__source] -= __n + 1;
+
+                  if (__a[__source] > 0)
+                    __pq.push(std::make_pair(
+                        __S(__source)[__a[__source] - 1], __source));
+                }
+            }
+        }
+
+      // Postconditions:
+      // __a[__i] == __b[__i] in most cases, except when __a[__i] has been
+      // clamped because of having reached the boundary
+
+      // Now return the result, calculate the offset.
+
+      // Compare the keys on both edges of the border.
+
+      // Maximum of left edge, minimum of right edge.
+      bool __maxleftset = false, __minrightset = false;
+
+      // Impossible to avoid the warning?
+      _Tp __maxleft, __minright;
+      for (_SeqNumber __i = 0; __i < __m; ++__i)
+        {
+          if (__a[__i] > 0)
+            {
+              if (!__maxleftset)
+                {
+                  __maxleft = __S(__i)[__a[__i] - 1];
+                  __maxleftset = true;
+                }
+              else
+                {
+                  // Max.
+                  if (__comp(__maxleft, __S(__i)[__a[__i] - 1]))
+                    __maxleft = __S(__i)[__a[__i] - 1];
+                }
+            }
+          if (__b[__i] < __ns[__i])
+            {
+              if (!__minrightset)
+                {
+                  __minright = __S(__i)[__b[__i]];
+                  __minrightset = true;
+                }
+              else
+                {
+                  // Min.
+                  if (__comp(__S(__i)[__b[__i]], __minright))
+                    __minright = __S(__i)[__b[__i]];
+                }
+            }
+      }
+
+      // Minright is the __splitter, in any case.
+
+      if (!__maxleftset || __comp(__minright, __maxleft))
+        {
+          // Good luck, everything is split unambiguously.
+          __offset = 0;
+        }
+      else
+        {
+          // We have to calculate an offset.
+          __offset = 0;
+
+          for (_SeqNumber __i = 0; __i < __m; ++__i)
+            {
+              _DifferenceType lb
+                = std::lower_bound(__S(__i), __S(__i) + __ns[__i],
+                                   __minright,
+                                   __comp) - __S(__i);
+              __offset += __a[__i] - lb;
+            }
+        }
+
+      delete[] __ns;
+      delete[] __a;
+      delete[] __b;
+
+      return __minright;
+    }
+}
+
+#undef __S
+
+#endif /* _GLIBCXX_PARALLEL_MULTISEQ_SELECTION_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/multiway_merge.h b/gcc-4.9/libstdc++-v3/include/parallel/multiway_merge.h
new file mode 100644
index 0000000..b0dee39
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/multiway_merge.h
@@ -0,0 +1,2072 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/multiway_merge.h
+*  @brief Implementation of sequential and parallel multiway merge.
+*
+*  Explanations on the high-speed merging routines in the appendix of
+*
+*  P. Sanders.
+*  Fast priority queues for cached memory.
+*  ACM Journal of Experimental Algorithmics, 5, 2000.
+*
+*  This file is a GNU parallel extension to the Standard C++ Library.
+*/
+
+// Written by Johannes Singler and Manuel Holtgrewe.
+
+#ifndef _GLIBCXX_PARALLEL_MULTIWAY_MERGE_H
+#define _GLIBCXX_PARALLEL_MULTIWAY_MERGE_H
+
+#include <vector>
+
+#include <bits/stl_algo.h>
+#include <parallel/features.h>
+#include <parallel/parallel.h>
+#include <parallel/losertree.h>
+#include <parallel/multiseq_selection.h>
+#if _GLIBCXX_ASSERTIONS
+#include <parallel/checkers.h>
+#endif
+
+/** @brief Length of a sequence described by a pair of iterators. */
+#define _GLIBCXX_PARALLEL_LENGTH(__s) ((__s).second - (__s).first)
+
+namespace __gnu_parallel
+{
+  template<typename _RAIter1, typename _RAIter2, typename _OutputIterator,
+	   typename _DifferenceTp, typename _Compare>
+    _OutputIterator
+    __merge_advance(_RAIter1&, _RAIter1, _RAIter2&, _RAIter2,
+		    _OutputIterator, _DifferenceTp, _Compare);
+
+  /** @brief _Iterator wrapper supporting an implicit supremum at the end
+   *         of the sequence, dominating all comparisons.
+   *
+   * The implicit supremum comes with a performance cost.
+   *
+   * Deriving from _RAIter is not possible since
+   * _RAIter need not be a class.
+   */
+  template<typename _RAIter, typename _Compare>
+    class _GuardedIterator
+    {
+    private:
+      /** @brief Current iterator __position. */
+      _RAIter _M_current;
+
+      /** @brief End iterator of the sequence. */
+      _RAIter _M_end;
+
+      /** @brief _Compare. */
+      _Compare& __comp;
+
+    public:
+      /** @brief Constructor. Sets iterator to beginning of sequence.
+      *  @param __begin Begin iterator of sequence.
+      *  @param __end End iterator of sequence.
+      *  @param __comp Comparator provided for associated overloaded
+      *  compare operators. */
+      _GuardedIterator(_RAIter __begin, _RAIter __end, _Compare& __comp)
+      : _M_current(__begin), _M_end(__end), __comp(__comp)
+      { }
+
+      /** @brief Pre-increment operator.
+      *  @return This. */
+      _GuardedIterator<_RAIter, _Compare>&
+      operator++()
+      {
+	++_M_current;
+	return *this;
+      }
+
+      /** @brief Dereference operator.
+      *  @return Referenced element. */
+      typename std::iterator_traits<_RAIter>::value_type&
+      operator*()
+      { return *_M_current; }
+
+      /** @brief Convert to wrapped iterator.
+      *  @return Wrapped iterator. */
+      operator _RAIter()
+      { return _M_current; }
+
+      /** @brief Compare two elements referenced by guarded iterators.
+       *  @param __bi1 First iterator.
+       *  @param __bi2 Second iterator.
+       *  @return @c true if less. */
+      friend bool
+      operator<(_GuardedIterator<_RAIter, _Compare>& __bi1,
+		_GuardedIterator<_RAIter, _Compare>& __bi2)
+      {
+	if (__bi1._M_current == __bi1._M_end)       // __bi1 is sup
+	  return __bi2._M_current == __bi2._M_end;  // __bi2 is not sup
+	if (__bi2._M_current == __bi2._M_end)       // __bi2 is sup
+	  return true;
+	return (__bi1.__comp)(*__bi1, *__bi2);      // normal compare
+      }
+
+      /** @brief Compare two elements referenced by guarded iterators.
+       *  @param __bi1 First iterator.
+       *  @param __bi2 Second iterator.
+       *  @return @c True if less equal. */
+      friend bool
+      operator<=(_GuardedIterator<_RAIter, _Compare>& __bi1,
+		 _GuardedIterator<_RAIter, _Compare>& __bi2)
+      {
+	if (__bi2._M_current == __bi2._M_end)       // __bi1 is sup
+	  return __bi1._M_current != __bi1._M_end;  // __bi2 is not sup
+	if (__bi1._M_current == __bi1._M_end)       // __bi2 is sup
+	  return false;
+	return !(__bi1.__comp)(*__bi2, *__bi1);     // normal compare
+      } 
+    };
+
+  template<typename _RAIter, typename _Compare>
+    class _UnguardedIterator
+    {
+    private:
+      /** @brief Current iterator __position. */
+      _RAIter _M_current;
+      /** @brief _Compare. */
+      _Compare& __comp;
+
+    public:
+      /** @brief Constructor. Sets iterator to beginning of sequence.
+      *  @param __begin Begin iterator of sequence.
+      *  @param __end Unused, only for compatibility.
+      *  @param __comp Unused, only for compatibility. */
+      _UnguardedIterator(_RAIter __begin,
+                	 _RAIter /* __end */, _Compare& __comp)
+      : _M_current(__begin), __comp(__comp)
+      { }
+
+      /** @brief Pre-increment operator.
+      *  @return This. */
+      _UnguardedIterator<_RAIter, _Compare>&
+      operator++()
+      {
+	++_M_current;
+	return *this;
+      }
+
+      /** @brief Dereference operator.
+      *  @return Referenced element. */
+      typename std::iterator_traits<_RAIter>::value_type&
+      operator*()
+      { return *_M_current; }
+
+      /** @brief Convert to wrapped iterator.
+      *  @return Wrapped iterator. */
+      operator _RAIter()
+      { return _M_current; }
+
+      /** @brief Compare two elements referenced by unguarded iterators.
+       *  @param __bi1 First iterator.
+       *  @param __bi2 Second iterator.
+       *  @return @c true if less. */
+      friend bool
+      operator<(_UnguardedIterator<_RAIter, _Compare>& __bi1,
+		_UnguardedIterator<_RAIter, _Compare>& __bi2)
+      {
+	// Normal compare.
+	return (__bi1.__comp)(*__bi1, *__bi2);
+      }
+
+      /** @brief Compare two elements referenced by unguarded iterators.
+       *  @param __bi1 First iterator.
+       *  @param __bi2 Second iterator.
+       *  @return @c True if less equal. */
+      friend bool
+      operator<=(_UnguardedIterator<_RAIter, _Compare>& __bi1,
+		 _UnguardedIterator<_RAIter, _Compare>& __bi2)
+      {
+	// Normal compare.
+	return !(__bi1.__comp)(*__bi2, *__bi1);
+      }
+    };
+
+  /** @brief Highly efficient 3-way merging procedure.
+   *
+   * Merging is done with the algorithm implementation described by Peter
+   * Sanders.  Basically, the idea is to minimize the number of necessary
+   * comparison after merging an element.  The implementation trick
+   * that makes this fast is that the order of the sequences is stored
+   * in the instruction pointer (translated into labels in C++).
+   *
+   * This works well for merging up to 4 sequences.
+   *
+   * Note that making the merging stable does @a not come at a
+   * performance hit.
+   *
+   * Whether the merging is done guarded or unguarded is selected by the
+   * used iterator class.
+   *
+   * @param __seqs_begin Begin iterator of iterator pair input sequence.
+   * @param __seqs_end End iterator of iterator pair input sequence.
+   * @param __target Begin iterator of output sequence.
+   * @param __comp Comparator.
+   * @param __length Maximum length to merge, less equal than the
+   * total number of elements available.
+   *
+   * @return End iterator of output sequence.
+   */
+  template<template<typename RAI, typename C> class iterator,
+           typename _RAIterIterator,
+           typename _RAIter3,
+           typename _DifferenceTp,
+           typename _Compare>
+    _RAIter3
+    multiway_merge_3_variant(_RAIterIterator __seqs_begin,
+			     _RAIterIterator __seqs_end,
+			     _RAIter3 __target,
+			     _DifferenceTp __length, _Compare __comp)
+    {
+      _GLIBCXX_CALL(__length);
+
+      typedef _DifferenceTp _DifferenceType;
+
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+	_ValueType;
+
+      if (__length == 0)
+	return __target;
+
+#if _GLIBCXX_ASSERTIONS
+      _DifferenceTp __orig_length = __length;
+#endif
+
+      iterator<_RAIter1, _Compare>
+	__seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp),
+	__seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp),
+	__seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp);
+
+      if (__seq0 <= __seq1)
+	{
+          if (__seq1 <= __seq2)
+            goto __s012;
+          else
+            if (__seq2 <  __seq0)
+              goto __s201;
+            else
+              goto __s021;
+	}
+      else
+	{
+          if (__seq1 <= __seq2)
+            {
+              if (__seq0 <= __seq2)
+        	goto __s102;
+              else
+        	goto __s120;
+            }
+          else
+            goto __s210;
+	}
+#define _GLIBCXX_PARALLEL_MERGE_3_CASE(__a, __b, __c, __c0, __c1) \
+      __s ## __a ## __b ## __c :                            \
+	*__target = *__seq ## __a;                          \
+	++__target;                                         \
+	--__length;                                         \
+	++__seq ## __a;                                     \
+	if (__length == 0) goto __finish;                   \
+	if (__seq ## __a __c0 __seq ## __b) goto __s ## __a ## __b ## __c; \
+	if (__seq ## __a __c1 __seq ## __c) goto __s ## __b ## __a ## __c; \
+	goto __s ## __b ## __c ## __a;
+
+      _GLIBCXX_PARALLEL_MERGE_3_CASE(0, 1, 2, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_3_CASE(1, 2, 0, <=, < );
+      _GLIBCXX_PARALLEL_MERGE_3_CASE(2, 0, 1, < , < );
+      _GLIBCXX_PARALLEL_MERGE_3_CASE(1, 0, 2, < , <=);
+      _GLIBCXX_PARALLEL_MERGE_3_CASE(0, 2, 1, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_3_CASE(2, 1, 0, < , < );
+
+#undef _GLIBCXX_PARALLEL_MERGE_3_CASE
+
+    __finish:
+      ;
+
+#if _GLIBCXX_ASSERTIONS
+    _GLIBCXX_PARALLEL_ASSERT(
+	((_RAIter1)__seq0 - __seqs_begin[0].first) +
+	((_RAIter1)__seq1 - __seqs_begin[1].first) +
+	((_RAIter1)__seq2 - __seqs_begin[2].first)
+	== __orig_length);
+#endif
+
+      __seqs_begin[0].first = __seq0;
+      __seqs_begin[1].first = __seq1;
+      __seqs_begin[2].first = __seq2;
+
+      return __target;
+    }
+
+  /**
+   * @brief Highly efficient 4-way merging procedure.
+   *
+   * Merging is done with the algorithm implementation described by Peter
+   * Sanders. Basically, the idea is to minimize the number of necessary
+   * comparison after merging an element.  The implementation trick
+   * that makes this fast is that the order of the sequences is stored
+   * in the instruction pointer (translated into goto labels in C++).
+   *
+   * This works well for merging up to 4 sequences.
+   *
+   * Note that making the merging stable does @a not come at a
+   * performance hit.
+   *
+   * Whether the merging is done guarded or unguarded is selected by the
+   * used iterator class.
+   *
+   * @param __seqs_begin Begin iterator of iterator pair input sequence.
+   * @param __seqs_end End iterator of iterator pair input sequence.
+   * @param __target Begin iterator of output sequence.
+   * @param __comp Comparator.
+   * @param __length Maximum length to merge, less equal than the
+   * total number of elements available.
+   *
+   * @return End iterator of output sequence.
+   */
+  template<template<typename RAI, typename C> class iterator,
+           typename _RAIterIterator,
+           typename _RAIter3,
+           typename _DifferenceTp,
+           typename _Compare>
+    _RAIter3
+    multiway_merge_4_variant(_RAIterIterator __seqs_begin,
+                             _RAIterIterator __seqs_end,
+                             _RAIter3 __target,
+                             _DifferenceTp __length, _Compare __comp)
+    {
+      _GLIBCXX_CALL(__length);
+      typedef _DifferenceTp _DifferenceType;
+
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+	_ValueType;
+
+      iterator<_RAIter1, _Compare>
+	__seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp),
+	__seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp),
+	__seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp),
+	__seq3(__seqs_begin[3].first, __seqs_begin[3].second, __comp);
+
+#define _GLIBCXX_PARALLEL_DECISION(__a, __b, __c, __d) {  \
+	if (__seq ## __d < __seq ## __a)		  \
+	  goto __s ## __d ## __a ## __b ## __c;		  \
+	if (__seq ## __d < __seq ## __b)		  \
+	  goto __s ## __a ## __d ## __b ## __c;		  \
+	if (__seq ## __d < __seq ## __c)		  \
+	  goto __s ## __a ## __b ## __d ## __c;		  \
+	goto __s ## __a ## __b ## __c ## __d;  }
+
+      if (__seq0 <= __seq1)
+	{
+          if (__seq1 <= __seq2)
+            _GLIBCXX_PARALLEL_DECISION(0,1,2,3)
+            else
+              if (__seq2 < __seq0)
+        	_GLIBCXX_PARALLEL_DECISION(2,0,1,3)
+        	else
+                  _GLIBCXX_PARALLEL_DECISION(0,2,1,3)
+                    }
+      else
+	{
+          if (__seq1 <= __seq2)
+            {
+              if (__seq0 <= __seq2)
+        	_GLIBCXX_PARALLEL_DECISION(1,0,2,3)
+        	else
+                  _GLIBCXX_PARALLEL_DECISION(1,2,0,3)
+                    }
+          else
+            _GLIBCXX_PARALLEL_DECISION(2,1,0,3)
+              }
+
+#define _GLIBCXX_PARALLEL_MERGE_4_CASE(__a, __b, __c, __d,  \
+				       __c0, __c1, __c2)    \
+      __s ## __a ## __b ## __c ## __d:                      \
+      if (__length == 0) goto __finish;                     \
+      *__target = *__seq ## __a;                            \
+      ++__target;                                           \
+      --__length;                                           \
+      ++__seq ## __a;                                       \
+      if (__seq ## __a __c0 __seq ## __b)      \
+	goto __s ## __a ## __b ## __c ## __d;  \
+      if (__seq ## __a __c1 __seq ## __c)      \
+	goto __s ## __b ## __a ## __c ## __d;  \
+      if (__seq ## __a __c2 __seq ## __d)      \
+	goto __s ## __b ## __c ## __a ## __d;  \
+      goto __s ## __b ## __c ## __d ## __a;
+
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 2, 3, <=, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 3, 2, <=, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 2, 1, 3, <=, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 2, 3, 1, <=, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 3, 1, 2, <=, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 3, 2, 1, <=, <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 0, 2, 3, < , <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 0, 3, 2, < , <=, <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 2, 0, 3, <=, < , <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 2, 3, 0, <=, <=, < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 3, 0, 2, <=, < , <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(1, 3, 2, 0, <=, <=, < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 0, 1, 3, < , < , <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 0, 3, 1, < , <=, < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 1, 0, 3, < , < , <=);
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 1, 3, 0, < , <=, < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 3, 0, 1, <=, < , < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(2, 3, 1, 0, <=, < , < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 0, 1, 2, < , < , < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 0, 2, 1, < , < , < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 1, 0, 2, < , < , < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 1, 2, 0, < , < , < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 2, 0, 1, < , < , < );
+      _GLIBCXX_PARALLEL_MERGE_4_CASE(3, 2, 1, 0, < , < , < );
+
+#undef _GLIBCXX_PARALLEL_MERGE_4_CASE
+#undef _GLIBCXX_PARALLEL_DECISION
+
+    __finish:
+      ;
+
+      __seqs_begin[0].first = __seq0;
+      __seqs_begin[1].first = __seq1;
+      __seqs_begin[2].first = __seq2;
+      __seqs_begin[3].first = __seq3;
+
+      return __target;
+    }
+
+  /** @brief Multi-way merging procedure for a high branching factor,
+   *         guarded case.
+   *
+   * This merging variant uses a LoserTree class as selected by <tt>_LT</tt>.
+   *
+   * Stability is selected through the used LoserTree class <tt>_LT</tt>.
+   *
+   * At least one non-empty sequence is required.
+   *
+   * @param __seqs_begin Begin iterator of iterator pair input sequence.
+   * @param __seqs_end End iterator of iterator pair input sequence.
+   * @param __target Begin iterator of output sequence.
+   * @param __comp Comparator.
+   * @param __length Maximum length to merge, less equal than the
+   * total number of elements available.
+   *
+   * @return End iterator of output sequence.
+   */
+  template<typename _LT,
+           typename _RAIterIterator,
+           typename _RAIter3,
+           typename _DifferenceTp,
+           typename _Compare>
+    _RAIter3
+    multiway_merge_loser_tree(_RAIterIterator __seqs_begin,
+                              _RAIterIterator __seqs_end,
+                              _RAIter3 __target,
+                              _DifferenceTp __length, _Compare __comp)
+    {
+      _GLIBCXX_CALL(__length)
+
+      typedef _DifferenceTp _DifferenceType;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::difference_type _SeqNumber;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+	_ValueType;
+
+      _SeqNumber __k = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
+
+      _LT __lt(__k, __comp);
+
+      // Default value for potentially non-default-constructible types.
+      _ValueType* __arbitrary_element = 0;
+
+      for (_SeqNumber __t = 0; __t < __k; ++__t)
+	{
+          if(!__arbitrary_element
+	     && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0)
+            __arbitrary_element = &(*__seqs_begin[__t].first);
+	}
+
+      for (_SeqNumber __t = 0; __t < __k; ++__t)
+	{
+          if (__seqs_begin[__t].first == __seqs_begin[__t].second)
+            __lt.__insert_start(*__arbitrary_element, __t, true);
+          else
+            __lt.__insert_start(*__seqs_begin[__t].first, __t, false);
+	}
+
+      __lt.__init();
+
+      _SeqNumber __source;
+
+      for (_DifferenceType __i = 0; __i < __length; ++__i)
+	{
+          //take out
+          __source = __lt.__get_min_source();
+
+          *(__target++) = *(__seqs_begin[__source].first++);
+
+          // Feed.
+          if (__seqs_begin[__source].first == __seqs_begin[__source].second)
+            __lt.__delete_min_insert(*__arbitrary_element, true);
+          else
+            // Replace from same __source.
+            __lt.__delete_min_insert(*__seqs_begin[__source].first, false);
+	}
+
+      return __target;
+    }
+
+  /** @brief Multi-way merging procedure for a high branching factor,
+   *         unguarded case.
+   *
+   * Merging is done using the LoserTree class <tt>_LT</tt>.
+   *
+   * Stability is selected by the used LoserTrees.
+   *
+   * @pre No input will run out of elements during the merge.
+   *
+   * @param __seqs_begin Begin iterator of iterator pair input sequence.
+   * @param __seqs_end End iterator of iterator pair input sequence.
+   * @param __target Begin iterator of output sequence.
+   * @param __comp Comparator.
+   * @param __length Maximum length to merge, less equal than the
+   * total number of elements available.
+   *
+   * @return End iterator of output sequence.
+   */
+  template<typename _LT,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp, typename _Compare>
+    _RAIter3
+    multiway_merge_loser_tree_unguarded(_RAIterIterator __seqs_begin,
+					_RAIterIterator __seqs_end,
+					_RAIter3 __target,
+       const typename std::iterator_traits<typename std::iterator_traits<
+	  _RAIterIterator>::value_type::first_type>::value_type&
+					__sentinel,
+					_DifferenceTp __length,
+					_Compare __comp)
+    {
+      _GLIBCXX_CALL(__length)
+      typedef _DifferenceTp _DifferenceType;
+
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::difference_type _SeqNumber;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+	_ValueType;
+
+      _SeqNumber __k = __seqs_end - __seqs_begin;
+
+      _LT __lt(__k, __sentinel, __comp);
+
+      for (_SeqNumber __t = 0; __t < __k; ++__t)
+	{
+#if _GLIBCXX_ASSERTIONS
+          _GLIBCXX_PARALLEL_ASSERT(__seqs_begin[__t].first
+                                   != __seqs_begin[__t].second);
+#endif
+          __lt.__insert_start(*__seqs_begin[__t].first, __t, false);
+	}
+
+      __lt.__init();
+
+      _SeqNumber __source;
+
+#if _GLIBCXX_ASSERTIONS
+      _DifferenceType __i = 0;
+#endif
+
+      _RAIter3 __target_end = __target + __length;
+      while (__target < __target_end)
+	{
+          // Take out.
+          __source = __lt.__get_min_source();
+
+#if _GLIBCXX_ASSERTIONS
+          _GLIBCXX_PARALLEL_ASSERT(0 <= __source && __source < __k);
+          _GLIBCXX_PARALLEL_ASSERT(__i == 0
+              || !__comp(*(__seqs_begin[__source].first), *(__target - 1)));
+#endif
+
+          // Feed.
+          *(__target++) = *(__seqs_begin[__source].first++);
+
+#if _GLIBCXX_ASSERTIONS
+          ++__i;
+#endif
+          // Replace from same __source.
+          __lt.__delete_min_insert(*__seqs_begin[__source].first, false);
+	}
+
+      return __target;
+    }
+
+
+  /** @brief Multi-way merging procedure for a high branching factor,
+   *         requiring sentinels to exist.
+   *
+   * @tparam UnguardedLoserTree _Loser Tree variant to use for the unguarded
+   *   merging.
+   *
+   * @param __seqs_begin Begin iterator of iterator pair input sequence.
+   * @param __seqs_end End iterator of iterator pair input sequence.
+   * @param __target Begin iterator of output sequence.
+   * @param __comp Comparator.
+   * @param __length Maximum length to merge, less equal than the
+   * total number of elements available.
+   *
+   * @return End iterator of output sequence.
+   */
+  template<typename UnguardedLoserTree,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIter3
+    multiway_merge_loser_tree_sentinel(_RAIterIterator __seqs_begin,
+				       _RAIterIterator __seqs_end,
+				       _RAIter3 __target,
+      const typename std::iterator_traits<typename std::iterator_traits<
+	_RAIterIterator>::value_type::first_type>::value_type&
+				       __sentinel,
+				       _DifferenceTp __length,
+				       _Compare __comp)
+    {
+      _GLIBCXX_CALL(__length)
+
+      typedef _DifferenceTp _DifferenceType;
+      typedef std::iterator_traits<_RAIterIterator> _TraitsType;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+	_ValueType;
+
+      _RAIter3 __target_end;
+
+      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
+	// Move the sequence ends to the sentinel.  This has the
+	// effect that the sentinel appears to be within the sequence. Then,
+	// we can use the unguarded variant if we merge out as many
+	// non-sentinel elements as we have.
+	++((*__s).second);
+
+      __target_end = multiway_merge_loser_tree_unguarded<UnguardedLoserTree>
+	(__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
+
+#if _GLIBCXX_ASSERTIONS
+      _GLIBCXX_PARALLEL_ASSERT(__target_end == __target + __length);
+      _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target_end, __comp));
+#endif
+
+      // Restore the sequence ends so the sentinels are not contained in the
+      // sequence any more (see comment in loop above).
+      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
+	--((*__s).second);
+
+      return __target_end;
+    }
+
+  /**
+   * @brief Traits for determining whether the loser tree should
+   *   use pointers or copies.
+   *
+   * The field "_M_use_pointer" is used to determine whether to use pointers
+   * in he loser trees or whether to copy the values into the loser tree.
+   *
+   * The default behavior is to use pointers if the data type is 4 times as
+   * big as the pointer to it.
+   *
+   * Specialize for your data type to customize the behavior.
+   *
+   * Example:
+   *
+   *   template<>
+   *   struct _LoserTreeTraits<int>
+   *   { static const bool _M_use_pointer = false; };
+   *
+   *   template<>
+   *   struct _LoserTreeTraits<heavyweight_type>
+   *   { static const bool _M_use_pointer = true; };
+   *
+   * @param _Tp type to give the loser tree traits for.
+   */
+  template <typename _Tp>
+    struct _LoserTreeTraits
+    {
+      /**
+       * @brief True iff to use pointers instead of values in loser trees.
+       *
+       * The default behavior is to use pointers if the data type is four
+       * times as big as the pointer to it.
+       */
+      static const bool _M_use_pointer = (sizeof(_Tp) > 4 * sizeof(_Tp*));
+    };
+
+  /**
+   * @brief Switch for 3-way merging with __sentinels turned off.
+   *
+   * Note that 3-way merging is always stable!
+   */
+  template<bool __sentinels /*default == false*/,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    struct __multiway_merge_3_variant_sentinel_switch
+    {
+      _RAIter3
+      operator()(_RAIterIterator __seqs_begin,
+		 _RAIterIterator __seqs_end,
+		 _RAIter3 __target,
+		 _DifferenceTp __length, _Compare __comp)
+      { return multiway_merge_3_variant<_GuardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
+    };
+
+  /**
+   * @brief Switch for 3-way merging with __sentinels turned on.
+   *
+   * Note that 3-way merging is always stable!
+   */
+  template<typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    struct __multiway_merge_3_variant_sentinel_switch<true, _RAIterIterator,
+						      _RAIter3, _DifferenceTp,
+						      _Compare>
+    {
+      _RAIter3
+      operator()(_RAIterIterator __seqs_begin,
+		 _RAIterIterator __seqs_end,
+		 _RAIter3 __target,
+		 _DifferenceTp __length, _Compare __comp)
+      { return multiway_merge_3_variant<_UnguardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
+    };
+
+  /**
+   * @brief Switch for 4-way merging with __sentinels turned off.
+   *
+   * Note that 4-way merging is always stable!
+   */
+  template<bool __sentinels /*default == false*/,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    struct __multiway_merge_4_variant_sentinel_switch
+    {
+      _RAIter3
+      operator()(_RAIterIterator __seqs_begin,
+		 _RAIterIterator __seqs_end,
+		 _RAIter3 __target,
+		 _DifferenceTp __length, _Compare __comp)
+      { return multiway_merge_4_variant<_GuardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
+    };
+
+  /**
+   * @brief Switch for 4-way merging with __sentinels turned on.
+   *
+   * Note that 4-way merging is always stable!
+   */
+  template<typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    struct __multiway_merge_4_variant_sentinel_switch<true, _RAIterIterator,
+						      _RAIter3, _DifferenceTp,
+						      _Compare>
+    {
+      _RAIter3
+      operator()(_RAIterIterator __seqs_begin,
+		 _RAIterIterator __seqs_end,
+		 _RAIter3 __target,
+		 _DifferenceTp __length, _Compare __comp)
+      { return multiway_merge_4_variant<_UnguardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
+    };
+
+  /**
+   * @brief Switch for k-way merging with __sentinels turned on.
+   */
+  template<bool __sentinels,
+	   bool __stable,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    struct __multiway_merge_k_variant_sentinel_switch
+    {
+      _RAIter3
+      operator()(_RAIterIterator __seqs_begin,
+		 _RAIterIterator __seqs_end,
+		 _RAIter3 __target,
+      const typename std::iterator_traits<typename std::iterator_traits<
+      _RAIterIterator>::value_type::first_type>::value_type&
+		 __sentinel,
+		 _DifferenceTp __length, _Compare __comp)
+      {
+	typedef typename std::iterator_traits<_RAIterIterator>
+	  ::value_type::first_type
+	  _RAIter1;
+	typedef typename std::iterator_traits<_RAIter1>::value_type
+	  _ValueType;
+
+	return multiway_merge_loser_tree_sentinel<
+	typename __gnu_cxx::__conditional_type<
+	_LoserTreeTraits<_ValueType>::_M_use_pointer,
+	  _LoserTreePointerUnguarded<__stable, _ValueType, _Compare>,
+	  _LoserTreeUnguarded<__stable, _ValueType, _Compare>
+          >::__type>
+	  (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
+      }
+    };
+
+  /**
+   * @brief Switch for k-way merging with __sentinels turned off.
+   */
+  template<bool __stable,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    struct __multiway_merge_k_variant_sentinel_switch<false, __stable,
+						      _RAIterIterator,
+						      _RAIter3, _DifferenceTp,
+						      _Compare>
+    {
+      _RAIter3
+      operator()(_RAIterIterator __seqs_begin,
+		 _RAIterIterator __seqs_end,
+		 _RAIter3 __target,
+       const typename std::iterator_traits<typename std::iterator_traits<
+       _RAIterIterator>::value_type::first_type>::value_type&
+		 __sentinel,
+		 _DifferenceTp __length, _Compare __comp)
+      {
+	typedef typename std::iterator_traits<_RAIterIterator>
+	  ::value_type::first_type
+	  _RAIter1;
+	typedef typename std::iterator_traits<_RAIter1>::value_type
+	  _ValueType;
+
+	return multiway_merge_loser_tree<
+	typename __gnu_cxx::__conditional_type<
+	_LoserTreeTraits<_ValueType>::_M_use_pointer,
+	  _LoserTreePointer<__stable, _ValueType, _Compare>,
+	  _LoserTree<__stable, _ValueType, _Compare>
+          >::__type >(__seqs_begin, __seqs_end, __target, __length, __comp);
+      }
+    };
+
+  /** @brief Sequential multi-way merging switch.
+   *
+   *  The _GLIBCXX_PARALLEL_DECISION is based on the branching factor and
+   *  runtime settings.
+   *  @param __seqs_begin Begin iterator of iterator pair input sequence.
+   *  @param __seqs_end End iterator of iterator pair input sequence.
+   *  @param __target Begin iterator of output sequence.
+   *  @param __comp Comparator.
+   *  @param __length Maximum length to merge, possibly larger than the
+   *  number of elements available.
+   *  @param __sentinel The sequences have __a __sentinel element.
+   *  @return End iterator of output sequence. */
+  template<bool __stable,
+	   bool __sentinels,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIter3
+    __sequential_multiway_merge(_RAIterIterator __seqs_begin,
+				_RAIterIterator __seqs_end,
+				_RAIter3 __target,
+      const typename std::iterator_traits<typename std::iterator_traits<
+	_RAIterIterator>::value_type::first_type>::value_type&
+				__sentinel,
+				_DifferenceTp __length, _Compare __comp)
+    {
+      _GLIBCXX_CALL(__length)
+
+      typedef _DifferenceTp _DifferenceType;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::difference_type _SeqNumber;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+	_ValueType;
+
+#if _GLIBCXX_ASSERTIONS
+      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
+	{
+          _GLIBCXX_PARALLEL_ASSERT(__is_sorted((*__s).first,
+					       (*__s).second, __comp));
+	}
+#endif
+
+      _DifferenceTp __total_length = 0;
+      for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
+	__total_length += _GLIBCXX_PARALLEL_LENGTH(*__s);
+
+      __length = std::min<_DifferenceTp>(__length, __total_length);
+
+      if(__length == 0)
+	return __target;
+
+      _RAIter3 __return_target = __target;
+      _SeqNumber __k = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
+
+      switch (__k)
+	{
+	case 0:
+          break;
+	case 1:
+          __return_target = std::copy(__seqs_begin[0].first,
+				      __seqs_begin[0].first + __length,
+				      __target);
+          __seqs_begin[0].first += __length;
+          break;
+	case 2:
+          __return_target = __merge_advance(__seqs_begin[0].first,
+					    __seqs_begin[0].second,
+					    __seqs_begin[1].first,
+					    __seqs_begin[1].second,
+					    __target, __length, __comp);
+          break;
+	case 3:
+          __return_target = __multiway_merge_3_variant_sentinel_switch
+	    <__sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare>()
+	    (__seqs_begin, __seqs_end, __target, __length, __comp);
+          break;
+	case 4:
+          __return_target = __multiway_merge_4_variant_sentinel_switch
+	    <__sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare>()
+	    (__seqs_begin, __seqs_end, __target, __length, __comp);
+          break;
+	default:
+	  __return_target = __multiway_merge_k_variant_sentinel_switch
+	    <__sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp,
+	     _Compare>()
+	    (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
+	  break;
+	}
+#if _GLIBCXX_ASSERTIONS
+      _GLIBCXX_PARALLEL_ASSERT(
+	__is_sorted(__target, __target + __length, __comp));
+#endif
+
+      return __return_target;
+    }
+
+  /**
+   * @brief Stable sorting functor.
+   *
+   * Used to reduce code instanciation in multiway_merge_sampling_splitting.
+   */
+  template<bool __stable, class _RAIter, class _StrictWeakOrdering>
+    struct _SamplingSorter
+    {
+      void
+      operator()(_RAIter __first, _RAIter __last, _StrictWeakOrdering __comp)
+      { __gnu_sequential::stable_sort(__first, __last, __comp); }
+    };
+
+  /**
+   * @brief Non-__stable sorting functor.
+   *
+   * Used to reduce code instantiation in multiway_merge_sampling_splitting.
+   */
+  template<class _RAIter, class _StrictWeakOrdering>
+    struct _SamplingSorter<false, _RAIter, _StrictWeakOrdering>
+    {
+      void
+      operator()(_RAIter __first, _RAIter __last, _StrictWeakOrdering __comp)
+      { __gnu_sequential::sort(__first, __last, __comp); }
+    };
+
+  /**
+   * @brief Sampling based splitting for parallel multiway-merge routine.
+   */
+  template<bool __stable,
+	   typename _RAIterIterator,
+	   typename _Compare,
+	   typename _DifferenceType>
+    void
+    multiway_merge_sampling_splitting(_RAIterIterator __seqs_begin,
+				      _RAIterIterator __seqs_end,
+				      _DifferenceType __length,
+				      _DifferenceType __total_length,
+				      _Compare __comp,
+     std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
+    {
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::difference_type _SeqNumber;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
+	_ValueType;
+
+      // __k sequences.
+      const _SeqNumber __k
+	= static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
+
+      const _ThreadIndex __num_threads = omp_get_num_threads();
+
+      const _DifferenceType __num_samples =
+	__gnu_parallel::_Settings::get().merge_oversampling * __num_threads;
+
+      _ValueType* __samples = static_cast<_ValueType*>
+	(::operator new(sizeof(_ValueType) * __k * __num_samples));
+      // Sample.
+      for (_SeqNumber __s = 0; __s < __k; ++__s)
+	for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
+	  {
+	    _DifferenceType sample_index = static_cast<_DifferenceType>
+	      (_GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__s])
+	       * (double(__i + 1) / (__num_samples + 1))
+	       * (double(__length) / __total_length));
+	    new(&(__samples[__s * __num_samples + __i]))
+              _ValueType(__seqs_begin[__s].first[sample_index]);
+	  }
+
+      // Sort stable or non-stable, depending on value of template parameter
+      // "__stable".
+      _SamplingSorter<__stable, _ValueType*, _Compare>()
+	(__samples, __samples + (__num_samples * __k), __comp);
+
+      for (_ThreadIndex __slab = 0; __slab < __num_threads; ++__slab)
+	// For each slab / processor.
+	for (_SeqNumber __seq = 0; __seq < __k; ++__seq)
+	  {
+	    // For each sequence.
+	    if (__slab > 0)
+	      __pieces[__slab][__seq].first = std::upper_bound
+		(__seqs_begin[__seq].first, __seqs_begin[__seq].second,
+		 __samples[__num_samples * __k * __slab / __num_threads],
+		 __comp)
+		- __seqs_begin[__seq].first;
+	    else
+	      // Absolute beginning.
+	      __pieces[__slab][__seq].first = 0;
+	    if ((__slab + 1) < __num_threads)
+	      __pieces[__slab][__seq].second = std::upper_bound
+		(__seqs_begin[__seq].first, __seqs_begin[__seq].second,
+		 __samples[__num_samples * __k * (__slab + 1) / __num_threads],
+		 __comp)
+		- __seqs_begin[__seq].first;
+	    else
+              // Absolute end.
+	      __pieces[__slab][__seq].second =
+		_GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]);
+	  }
+
+      for (_SeqNumber __s = 0; __s < __k; ++__s)
+	for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
+	  __samples[__s * __num_samples + __i].~_ValueType();
+      ::operator delete(__samples);
+    }
+
+  /**
+   * @brief Exact splitting for parallel multiway-merge routine.
+   *
+   * None of the passed sequences may be empty.
+   */
+  template<bool __stable,
+	   typename _RAIterIterator,
+	   typename _Compare,
+	   typename _DifferenceType>
+    void
+    multiway_merge_exact_splitting(_RAIterIterator __seqs_begin,
+				   _RAIterIterator __seqs_end,
+				   _DifferenceType __length,
+				   _DifferenceType __total_length,
+				   _Compare __comp,
+       std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
+    {
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::difference_type _SeqNumber;
+      typedef typename std::iterator_traits<_RAIterIterator>
+	::value_type::first_type
+	_RAIter1;
+
+      const bool __tight = (__total_length == __length);
+
+      // __k sequences.
+      const _SeqNumber __k = __seqs_end - __seqs_begin;
+
+      const _ThreadIndex __num_threads = omp_get_num_threads();
+
+      // (Settings::multiway_merge_splitting
+      //  == __gnu_parallel::_Settings::EXACT).
+      std::vector<_RAIter1>* __offsets = 
+	new std::vector<_RAIter1>[__num_threads];
+      std::vector<std::pair<_RAIter1, _RAIter1> > __se(__k);
+
+      copy(__seqs_begin, __seqs_end, __se.begin());
+
+      _DifferenceType* __borders =
+	new _DifferenceType[__num_threads + 1];
+      __equally_split(__length, __num_threads, __borders);
+
+      for (_ThreadIndex __s = 0; __s < (__num_threads - 1); ++__s)
+	{
+	  __offsets[__s].resize(__k);
+	  multiseq_partition(__se.begin(), __se.end(), __borders[__s + 1],
+			     __offsets[__s].begin(), __comp);
+
+	  // Last one also needed and available.
+	  if (!__tight)
+	    {
+	      __offsets[__num_threads - 1].resize(__k);
+	      multiseq_partition(__se.begin(), __se.end(),
+				 _DifferenceType(__length),
+				 __offsets[__num_threads - 1].begin(),
+				 __comp);
+	    }
+	}
+      delete[] __borders;
+
+      for (_ThreadIndex __slab = 0; __slab < __num_threads; ++__slab)
+	{
+	  // For each slab / processor.
+	  for (_SeqNumber __seq = 0; __seq < __k; ++__seq)
+	    {
+	      // For each sequence.
+	      if (__slab == 0)
+		{
+		  // Absolute beginning.
+		  __pieces[__slab][__seq].first = 0;
+		}
+	      else
+		__pieces[__slab][__seq].first =
+		  __pieces[__slab - 1][__seq].second;
+	      if (!__tight || __slab < (__num_threads - 1))
+		__pieces[__slab][__seq].second =
+		  __offsets[__slab][__seq] - __seqs_begin[__seq].first;
+	      else
+		{
+		  // __slab == __num_threads - 1
+		  __pieces[__slab][__seq].second =
+                    _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]);
+		}
+	    }
+	}
+      delete[] __offsets;
+    }
+
+  /** @brief Parallel multi-way merge routine.
+   *
+   * The _GLIBCXX_PARALLEL_DECISION is based on the branching factor
+   * and runtime settings.
+   *
+   * Must not be called if the number of sequences is 1.
+   *
+   * @tparam _Splitter functor to split input (either __exact or sampling based)
+   * @tparam __stable Stable merging incurs a performance penalty.
+   * @tparam __sentinel Ignored.
+   *
+   * @param __seqs_begin Begin iterator of iterator pair input sequence.
+   * @param __seqs_end End iterator of iterator pair input sequence.
+   * @param __target Begin iterator of output sequence.
+   * @param __comp Comparator.
+   * @param __length Maximum length to merge, possibly larger than the
+   * number of elements available.
+   * @return End iterator of output sequence.
+   */
+  template<bool __stable,
+	   bool __sentinels,
+	   typename _RAIterIterator,
+	   typename _RAIter3,
+	   typename _DifferenceTp,
+	   typename _Splitter,
+	   typename _Compare>
+    _RAIter3
+    parallel_multiway_merge(_RAIterIterator __seqs_begin,
+                            _RAIterIterator __seqs_end,
+                            _RAIter3 __target,
+                            _Splitter __splitter,
+                            _DifferenceTp __length,
+                            _Compare __comp,
+                            _ThreadIndex __num_threads)
+      {
+#if _GLIBCXX_ASSERTIONS
+	_GLIBCXX_PARALLEL_ASSERT(__seqs_end - __seqs_begin > 1);
+#endif
+
+	_GLIBCXX_CALL(__length)
+
+	typedef _DifferenceTp _DifferenceType;
+        typedef typename std::iterator_traits<_RAIterIterator>
+	  ::difference_type _SeqNumber;
+	typedef typename std::iterator_traits<_RAIterIterator>
+          ::value_type::first_type
+          _RAIter1;
+	typedef typename
+          std::iterator_traits<_RAIter1>::value_type _ValueType;
+
+	// Leave only non-empty sequences.
+	typedef std::pair<_RAIter1, _RAIter1> seq_type;
+	seq_type* __ne_seqs = new seq_type[__seqs_end - __seqs_begin];
+	_SeqNumber __k = 0;
+	_DifferenceType __total_length = 0;
+	for (_RAIterIterator __raii = __seqs_begin;
+             __raii != __seqs_end; ++__raii)
+          {
+            _DifferenceTp __seq_length = _GLIBCXX_PARALLEL_LENGTH(*__raii);
+            if(__seq_length > 0)
+              {
+        	__total_length += __seq_length;
+        	__ne_seqs[__k++] = *__raii;
+              }
+          }
+
+	_GLIBCXX_CALL(__total_length)
+
+	__length = std::min<_DifferenceTp>(__length, __total_length);
+
+	if (__total_length == 0 || __k == 0)
+	  {
+	    delete[] __ne_seqs;
+	    return __target;
+	  }
+
+	std::vector<std::pair<_DifferenceType, _DifferenceType> >* __pieces;
+
+	__num_threads = static_cast<_ThreadIndex>
+          (std::min<_DifferenceType>(__num_threads, __total_length));
+
+#       pragma omp parallel num_threads (__num_threads)
+	{
+#         pragma omp single
+	  {
+	    __num_threads = omp_get_num_threads();
+	    // Thread __t will have to merge pieces[__iam][0..__k - 1]
+	    __pieces = new std::vector<
+	    std::pair<_DifferenceType, _DifferenceType> >[__num_threads];
+	    for (_ThreadIndex __s = 0; __s < __num_threads; ++__s)
+	      __pieces[__s].resize(__k);
+
+	    _DifferenceType __num_samples =
+	      __gnu_parallel::_Settings::get().merge_oversampling
+	      * __num_threads;
+
+	    __splitter(__ne_seqs, __ne_seqs + __k, __length, __total_length,
+		       __comp, __pieces);
+	  } //single
+
+	  _ThreadIndex __iam = omp_get_thread_num();
+
+	  _DifferenceType __target_position = 0;
+
+	  for (_SeqNumber __c = 0; __c < __k; ++__c)
+	    __target_position += __pieces[__iam][__c].first;
+
+	  seq_type* __chunks = new seq_type[__k];
+
+	  for (_SeqNumber __s = 0; __s < __k; ++__s)
+	    __chunks[__s] = std::make_pair(__ne_seqs[__s].first
+					   + __pieces[__iam][__s].first,
+					   __ne_seqs[__s].first
+					   + __pieces[__iam][__s].second);
+
+	  if(__length > __target_position)
+	    __sequential_multiway_merge<__stable, __sentinels>
+	      (__chunks, __chunks + __k, __target + __target_position,
+	       *(__seqs_begin->second), __length - __target_position, __comp);
+
+	  delete[] __chunks;
+	} // parallel
+
+#if _GLIBCXX_ASSERTIONS
+	_GLIBCXX_PARALLEL_ASSERT(
+          __is_sorted(__target, __target + __length, __comp));
+#endif
+
+	__k = 0;
+	// Update ends of sequences.
+	for (_RAIterIterator __raii = __seqs_begin;
+             __raii != __seqs_end; ++__raii)
+          {
+            _DifferenceTp __length = _GLIBCXX_PARALLEL_LENGTH(*__raii);
+            if(__length > 0)
+              (*__raii).first += __pieces[__num_threads - 1][__k++].second;
+          }
+
+	delete[] __pieces;
+	delete[] __ne_seqs;
+
+	return __target + __length;
+      }
+
+  /**
+   * @brief Multiway Merge Frontend.
+   *
+   * Merge the sequences specified by seqs_begin and __seqs_end into
+   * __target.  __seqs_begin and __seqs_end must point to a sequence of
+   * pairs.  These pairs must contain an iterator to the beginning
+   * of a sequence in their first entry and an iterator the _M_end of
+   * the same sequence in their second entry.
+   *
+   * Ties are broken arbitrarily.  See stable_multiway_merge for a variant
+   * that breaks ties by sequence number but is slower.
+   *
+   * The first entries of the pairs (i.e. the begin iterators) will be moved
+   * forward.
+   *
+   * The output sequence has to provide enough space for all elements
+   * that are written to it.
+   *
+   * This function will merge the input sequences:
+   *
+   * - not stable
+   * - parallel, depending on the input size and Settings
+   * - using sampling for splitting
+   * - not using sentinels
+   *
+   * Example:
+   *
+   * <pre>
+   *   int sequences[10][10];
+   *   for (int __i = 0; __i < 10; ++__i)
+   *     for (int __j = 0; __i < 10; ++__j)
+   *       sequences[__i][__j] = __j;
+   *
+   *   int __out[33];
+   *   std::vector<std::pair<int*> > seqs;
+   *   for (int __i = 0; __i < 10; ++__i)
+   *     { seqs.push(std::make_pair<int*>(sequences[__i],
+   *                                      sequences[__i] + 10)) }
+   *
+   *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
+   * </pre>
+   *
+   * @see stable_multiway_merge
+   *
+   * @pre All input sequences must be sorted.
+   * @pre Target must provide enough space to merge out length elements or
+   *    the number of elements in all sequences, whichever is smaller.
+   *
+   * @post [__target, return __value) contains merged __elements from the
+   *    input sequences.
+   * @post return __value - __target = min(__length, number of elements in all
+   *    sequences).
+   *
+   * @tparam _RAIterPairIterator iterator over sequence
+   *    of pairs of iterators
+   * @tparam _RAIterOut iterator over target sequence
+   * @tparam _DifferenceTp difference type for the sequence
+   * @tparam _Compare strict weak ordering type to compare elements
+   *    in sequences
+   *
+   * @param __seqs_begin  __begin of sequence __sequence
+   * @param __seqs_end    _M_end of sequence __sequence
+   * @param __target      target sequence to merge to.
+   * @param __comp        strict weak ordering to use for element comparison.
+   * @param __length Maximum length to merge, possibly larger than the
+   * number of elements available.
+   *
+   * @return _M_end iterator of output sequence
+   */
+  // multiway_merge
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge(_RAIterPairIterator __seqs_begin,
+		   _RAIterPairIterator __seqs_end,
+		   _RAIterOut __target,
+		   _DifferenceTp __length, _Compare __comp,
+		   __gnu_parallel::sequential_tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute multiway merge *sequentially*.
+      return __sequential_multiway_merge
+	</* __stable = */ false, /* __sentinels = */ false>
+	(__seqs_begin, __seqs_end, __target,
+	 *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge(_RAIterPairIterator __seqs_begin,
+		   _RAIterPairIterator __seqs_end,
+		   _RAIterOut __target,
+		   _DifferenceTp __length, _Compare __comp,
+		   __gnu_parallel::exact_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_exact_splitting</* __stable = */ false,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge(_RAIterPairIterator __seqs_begin,
+		   _RAIterPairIterator __seqs_end,
+		   _RAIterOut __target,
+		   _DifferenceTp __length, _Compare __comp,
+		   __gnu_parallel::sampling_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_exact_splitting</* __stable = */ false,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge(_RAIterPairIterator __seqs_begin,
+		   _RAIterPairIterator __seqs_end,
+		   _RAIterOut __target,
+		   _DifferenceTp __length, _Compare __comp,
+		   parallel_tag __tag = parallel_tag(0))
+    { return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
+			    __comp, exact_tag(__tag.__get_num_threads())); }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge(_RAIterPairIterator __seqs_begin,
+		   _RAIterPairIterator __seqs_end,
+		   _RAIterOut __target,
+		   _DifferenceTp __length, _Compare __comp,
+		   default_parallel_tag __tag)
+    { return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
+			    __comp, exact_tag(__tag.__get_num_threads())); }
+
+  // stable_multiway_merge
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
+			  _RAIterPairIterator __seqs_end,
+			  _RAIterOut __target,
+			  _DifferenceTp __length, _Compare __comp,
+			  __gnu_parallel::sequential_tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute multiway merge *sequentially*.
+      return __sequential_multiway_merge
+	</* __stable = */ true, /* __sentinels = */ false>
+          (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
+			  _RAIterPairIterator __seqs_end,
+			  _RAIterOut __target,
+			  _DifferenceTp __length, _Compare __comp,
+			  __gnu_parallel::exact_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+          </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_exact_splitting</* __stable = */ true,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+	  </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
+			  _RAIterPairIterator __seqs_end,
+			  _RAIterOut __target,
+			  _DifferenceTp __length, _Compare __comp,
+			  sampling_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+          </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_sampling_splitting</* __stable = */ true,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+          </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
+			  _RAIterPairIterator __seqs_end,
+			  _RAIterOut __target,
+			  _DifferenceTp __length, _Compare __comp,
+			  parallel_tag __tag = parallel_tag(0))
+    {
+      return stable_multiway_merge
+	(__seqs_begin, __seqs_end, __target, __length, __comp,
+	 exact_tag(__tag.__get_num_threads()));
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge(_RAIterPairIterator __seqs_begin,
+			  _RAIterPairIterator __seqs_end,
+			  _RAIterOut __target,
+			  _DifferenceTp __length, _Compare __comp,
+			  default_parallel_tag __tag)
+    {
+      return stable_multiway_merge
+	(__seqs_begin, __seqs_end, __target, __length, __comp,
+	 exact_tag(__tag.__get_num_threads()));
+    }
+
+  /**
+   * @brief Multiway Merge Frontend.
+   *
+   * Merge the sequences specified by seqs_begin and __seqs_end into
+   * __target.  __seqs_begin and __seqs_end must point to a sequence of
+   * pairs.  These pairs must contain an iterator to the beginning
+   * of a sequence in their first entry and an iterator the _M_end of
+   * the same sequence in their second entry.
+   *
+   * Ties are broken arbitrarily.  See stable_multiway_merge for a variant
+   * that breaks ties by sequence number but is slower.
+   *
+   * The first entries of the pairs (i.e. the begin iterators) will be moved
+   * forward accordingly.
+   *
+   * The output sequence has to provide enough space for all elements
+   * that are written to it.
+   *
+   * This function will merge the input sequences:
+   *
+   * - not stable
+   * - parallel, depending on the input size and Settings
+   * - using sampling for splitting
+   * - using sentinels
+   *
+   * You have to take care that the element the _M_end iterator points to is
+   * readable and contains a value that is greater than any other non-sentinel
+   * value in all sequences.
+   *
+   * Example:
+   *
+   * <pre>
+   *   int sequences[10][11];
+   *   for (int __i = 0; __i < 10; ++__i)
+   *     for (int __j = 0; __i < 11; ++__j)
+   *       sequences[__i][__j] = __j; // __last one is sentinel!
+   *
+   *   int __out[33];
+   *   std::vector<std::pair<int*> > seqs;
+   *   for (int __i = 0; __i < 10; ++__i)
+   *     { seqs.push(std::make_pair<int*>(sequences[__i],
+   *                                      sequences[__i] + 10)) }
+   *
+   *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
+   * </pre>
+   *
+   * @pre All input sequences must be sorted.
+   * @pre Target must provide enough space to merge out length elements or
+   *    the number of elements in all sequences, whichever is smaller.
+   * @pre For each @c __i, @c __seqs_begin[__i].second must be the end
+   *    marker of the sequence, but also reference the one more __sentinel
+   *    element.
+   *
+   * @post [__target, return __value) contains merged __elements from the
+   *    input sequences.
+   * @post return __value - __target = min(__length, number of elements in all
+   *    sequences).
+   *
+   * @see stable_multiway_merge_sentinels
+   *
+   * @tparam _RAIterPairIterator iterator over sequence
+   *    of pairs of iterators
+   * @tparam _RAIterOut iterator over target sequence
+   * @tparam _DifferenceTp difference type for the sequence
+   * @tparam _Compare strict weak ordering type to compare elements
+   *    in sequences
+   *
+   * @param __seqs_begin  __begin of sequence __sequence
+   * @param __seqs_end    _M_end of sequence __sequence
+   * @param __target      target sequence to merge to.
+   * @param __comp        strict weak ordering to use for element comparison.
+   * @param __length Maximum length to merge, possibly larger than the
+   * number of elements available.
+   *
+   * @return _M_end iterator of output sequence
+   */
+  // multiway_merge_sentinels
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+			     _RAIterPairIterator __seqs_end,
+			     _RAIterOut __target,
+			     _DifferenceTp __length, _Compare __comp,
+			     __gnu_parallel::sequential_tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute multiway merge *sequentially*.
+      return __sequential_multiway_merge
+	</* __stable = */ false, /* __sentinels = */ true>
+          (__seqs_begin, __seqs_end,
+           __target, *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+			     _RAIterPairIterator __seqs_end,
+			     _RAIterOut __target,
+			     _DifferenceTp __length, _Compare __comp,
+			     __gnu_parallel::exact_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+          </* __stable = */ false, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_exact_splitting</* __stable = */ false,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+          </* __stable = */ false, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+			     _RAIterPairIterator __seqs_end,
+			     _RAIterOut __target,
+			     _DifferenceTp __length, _Compare __comp,
+			     sampling_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+          </* __stable = */ false, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_sampling_splitting</* __stable = */ false,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+          </* __stable = */false, /* __sentinels = */ true>(
+            __seqs_begin, __seqs_end, __target,
+	    *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+			     _RAIterPairIterator __seqs_end,
+			     _RAIterOut __target,
+			     _DifferenceTp __length, _Compare __comp,
+			     parallel_tag __tag = parallel_tag(0))
+    {
+      return multiway_merge_sentinels
+	(__seqs_begin, __seqs_end, __target, __length, __comp,
+	 exact_tag(__tag.__get_num_threads()));
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+			     _RAIterPairIterator __seqs_end,
+			     _RAIterOut __target,
+			     _DifferenceTp __length, _Compare __comp,
+			     default_parallel_tag __tag)
+    {
+      return multiway_merge_sentinels
+	(__seqs_begin, __seqs_end, __target, __length, __comp,
+	 exact_tag(__tag.__get_num_threads()));
+    }
+
+  // stable_multiway_merge_sentinels
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+				    _RAIterPairIterator __seqs_end,
+				    _RAIterOut __target,
+				    _DifferenceTp __length, _Compare __comp,
+				    __gnu_parallel::sequential_tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute multiway merge *sequentially*.
+      return __sequential_multiway_merge
+	</* __stable = */ true, /* __sentinels = */ true>
+	(__seqs_begin, __seqs_end, __target,
+	 *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+				    _RAIterPairIterator __seqs_end,
+				    _RAIterOut __target,
+				    _DifferenceTp __length, _Compare __comp,
+				    __gnu_parallel::exact_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+            __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+            __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_exact_splitting</* __stable = */ true,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+				    _RAIterPairIterator __seqs_end,
+				    _RAIterOut __target,
+				    _DifferenceTp __length,
+				    _Compare __comp,
+				    sampling_tag __tag)
+    {
+      typedef _DifferenceTp _DifferenceType;
+      _GLIBCXX_CALL(__seqs_end - __seqs_begin)
+
+      // catch special case: no sequences
+      if (__seqs_begin == __seqs_end)
+	return __target;
+
+      // Execute merge; maybe parallel, depending on the number of merged
+      // elements and the number of sequences and global thresholds in
+      // Settings.
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
+            ((__seqs_end - __seqs_begin) >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
+            && ((_SequenceIndex)__length >=
+              __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
+	return parallel_multiway_merge
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   multiway_merge_sampling_splitting</* __stable = */ true,
+	   typename std::iterator_traits<_RAIterPairIterator>
+	   ::value_type*, _Compare, _DifferenceTp>,
+	   static_cast<_DifferenceType>(__length), __comp,
+	   __tag.__get_num_threads());
+      else
+	return __sequential_multiway_merge
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+				    _RAIterPairIterator __seqs_end,
+				    _RAIterOut __target,
+				    _DifferenceTp __length,
+				    _Compare __comp,
+				    parallel_tag __tag = parallel_tag(0))
+    {
+      return stable_multiway_merge_sentinels
+	(__seqs_begin, __seqs_end, __target, __length, __comp,
+	 exact_tag(__tag.__get_num_threads()));
+    }
+
+  // public interface
+  template<typename _RAIterPairIterator,
+	   typename _RAIterOut,
+	   typename _DifferenceTp,
+	   typename _Compare>
+    _RAIterOut
+    stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin,
+				    _RAIterPairIterator __seqs_end,
+				    _RAIterOut __target,
+				    _DifferenceTp __length, _Compare __comp,
+				    default_parallel_tag __tag)
+    {
+      return stable_multiway_merge_sentinels
+	(__seqs_begin, __seqs_end, __target, __length, __comp,
+	 exact_tag(__tag.__get_num_threads()));
+    }
+}; // namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_MULTIWAY_MERGE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/multiway_mergesort.h b/gcc-4.9/libstdc++-v3/include/parallel/multiway_mergesort.h
new file mode 100644
index 0000000..d88929d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/multiway_mergesort.h
@@ -0,0 +1,480 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/multiway_mergesort.h
+ *  @brief Parallel multiway merge sort.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_MULTIWAY_MERGESORT_H
+#define _GLIBCXX_PARALLEL_MULTIWAY_MERGESORT_H 1
+
+#include <vector>
+
+#include <parallel/basic_iterator.h>
+#include <bits/stl_algo.h>
+#include <parallel/parallel.h>
+#include <parallel/multiway_merge.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Subsequence description. */
+  template<typename _DifferenceTp>
+    struct _Piece
+    {
+      typedef _DifferenceTp _DifferenceType;
+
+      /** @brief Begin of subsequence. */
+      _DifferenceType _M_begin;
+
+      /** @brief End of subsequence. */
+      _DifferenceType _M_end;
+    };
+
+  /** @brief Data accessed by all threads.
+   *
+   *  PMWMS = parallel multiway mergesort */
+  template<typename _RAIter>
+    struct _PMWMSSortingData
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      /** @brief Number of threads involved. */
+      _ThreadIndex _M_num_threads;
+
+      /** @brief Input __begin. */
+      _RAIter _M_source;
+
+      /** @brief Start indices, per thread. */
+      _DifferenceType* _M_starts;
+
+      /** @brief Storage in which to sort. */
+      _ValueType** _M_temporary;
+
+      /** @brief Samples. */
+      _ValueType* _M_samples;
+
+      /** @brief Offsets to add to the found positions. */
+      _DifferenceType* _M_offsets;
+
+      /** @brief Pieces of data to merge @c [thread][__sequence] */
+      std::vector<_Piece<_DifferenceType> >* _M_pieces;
+  };
+
+  /**
+   *  @brief Select _M_samples from a sequence.
+   *  @param __sd Pointer to algorithm data. _Result will be placed in
+   *  @c __sd->_M_samples.
+   *  @param __num_samples Number of _M_samples to select.
+   */
+  template<typename _RAIter, typename _DifferenceTp>
+    void
+    __determine_samples(_PMWMSSortingData<_RAIter>* __sd,
+			_DifferenceTp __num_samples)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef _DifferenceTp _DifferenceType;
+
+      _ThreadIndex __iam = omp_get_thread_num();
+
+      _DifferenceType* __es = new _DifferenceType[__num_samples + 2];
+
+      __equally_split(__sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam], 
+		      __num_samples + 1, __es);
+
+      for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
+	::new(&(__sd->_M_samples[__iam * __num_samples + __i]))
+	    _ValueType(__sd->_M_source[__sd->_M_starts[__iam]
+				       + __es[__i + 1]]);
+
+      delete[] __es;
+    }
+
+  /** @brief Split consistently. */
+  template<bool __exact, typename _RAIter,
+	   typename _Compare, typename _SortingPlacesIterator>
+    struct _SplitConsistently
+    { };
+
+  /** @brief Split by exact splitting. */
+  template<typename _RAIter, typename _Compare,
+	   typename _SortingPlacesIterator>
+    struct _SplitConsistently<true, _RAIter, _Compare, _SortingPlacesIterator>
+    {
+      void
+      operator()(const _ThreadIndex __iam,
+		 _PMWMSSortingData<_RAIter>* __sd,
+		 _Compare& __comp,
+		 const typename
+		 std::iterator_traits<_RAIter>::difference_type
+		 __num_samples) const
+      {
+#       pragma omp barrier
+
+	std::vector<std::pair<_SortingPlacesIterator,
+	                      _SortingPlacesIterator> >
+	  __seqs(__sd->_M_num_threads);
+	for (_ThreadIndex __s = 0; __s < __sd->_M_num_threads; __s++)
+	  __seqs[__s] = std::make_pair(__sd->_M_temporary[__s],
+				       __sd->_M_temporary[__s]
+				       + (__sd->_M_starts[__s + 1]
+					  - __sd->_M_starts[__s]));
+
+	std::vector<_SortingPlacesIterator> __offsets(__sd->_M_num_threads);
+
+	// if not last thread
+	if (__iam < __sd->_M_num_threads - 1)
+	  multiseq_partition(__seqs.begin(), __seqs.end(),
+			     __sd->_M_starts[__iam + 1], __offsets.begin(),
+			     __comp);
+
+	for (_ThreadIndex __seq = 0; __seq < __sd->_M_num_threads; __seq++)
+	  {
+	    // for each sequence
+	    if (__iam < (__sd->_M_num_threads - 1))
+	      __sd->_M_pieces[__iam][__seq]._M_end
+		= __offsets[__seq] - __seqs[__seq].first;
+	    else
+	      // very end of this sequence
+	      __sd->_M_pieces[__iam][__seq]._M_end =
+		__sd->_M_starts[__seq + 1] - __sd->_M_starts[__seq];
+	  }
+
+#       pragma omp barrier
+
+	for (_ThreadIndex __seq = 0; __seq < __sd->_M_num_threads; __seq++)
+	  {
+	    // For each sequence.
+	    if (__iam > 0)
+	      __sd->_M_pieces[__iam][__seq]._M_begin =
+		__sd->_M_pieces[__iam - 1][__seq]._M_end;
+	    else
+	      // Absolute beginning.
+	      __sd->_M_pieces[__iam][__seq]._M_begin = 0;
+	  }
+      }
+  };
+
+  /** @brief Split by sampling. */ 
+  template<typename _RAIter, typename _Compare,
+	   typename _SortingPlacesIterator>
+    struct _SplitConsistently<false, _RAIter, _Compare, _SortingPlacesIterator>
+    {
+      void
+      operator()(const _ThreadIndex __iam,
+		 _PMWMSSortingData<_RAIter>* __sd,
+		 _Compare& __comp,
+		 const typename
+		 std::iterator_traits<_RAIter>::difference_type
+		 __num_samples) const
+      {
+	typedef std::iterator_traits<_RAIter> _TraitsType;
+	typedef typename _TraitsType::value_type _ValueType;
+	typedef typename _TraitsType::difference_type _DifferenceType;
+
+	__determine_samples(__sd, __num_samples);
+
+#       pragma omp barrier
+
+#       pragma omp single
+	__gnu_sequential::sort(__sd->_M_samples,
+			       __sd->_M_samples
+			       + (__num_samples * __sd->_M_num_threads),
+			       __comp);
+
+#       pragma omp barrier
+
+	for (_ThreadIndex __s = 0; __s < __sd->_M_num_threads; ++__s)
+	  {
+	    // For each sequence.
+	    if (__num_samples * __iam > 0)
+	      __sd->_M_pieces[__iam][__s]._M_begin =
+                std::lower_bound(__sd->_M_temporary[__s],
+				 __sd->_M_temporary[__s]
+				 + (__sd->_M_starts[__s + 1]
+				    - __sd->_M_starts[__s]),
+				 __sd->_M_samples[__num_samples * __iam],
+				 __comp)
+                - __sd->_M_temporary[__s];
+	    else
+	      // Absolute beginning.
+	      __sd->_M_pieces[__iam][__s]._M_begin = 0;
+
+	    if ((__num_samples * (__iam + 1)) <
+		(__num_samples * __sd->_M_num_threads))
+	      __sd->_M_pieces[__iam][__s]._M_end =
+                std::lower_bound(__sd->_M_temporary[__s],
+				 __sd->_M_temporary[__s]
+				 + (__sd->_M_starts[__s + 1]
+				    - __sd->_M_starts[__s]),
+				 __sd->_M_samples[__num_samples * (__iam + 1)],
+				 __comp)
+                - __sd->_M_temporary[__s];
+	    else
+	      // Absolute end.
+	      __sd->_M_pieces[__iam][__s]._M_end = (__sd->_M_starts[__s + 1]
+						    - __sd->_M_starts[__s]);
+	  }
+      }
+  };
+  
+  template<bool __stable, typename _RAIter, typename _Compare>
+    struct __possibly_stable_sort
+    { };
+
+  template<typename _RAIter, typename _Compare>
+    struct __possibly_stable_sort<true, _RAIter, _Compare>
+    {
+      void operator()(const _RAIter& __begin,
+		      const _RAIter& __end, _Compare& __comp) const
+      { __gnu_sequential::stable_sort(__begin, __end, __comp); }
+    };
+
+  template<typename _RAIter, typename _Compare>
+    struct __possibly_stable_sort<false, _RAIter, _Compare>
+    {
+      void operator()(const _RAIter __begin,
+		      const _RAIter __end, _Compare& __comp) const
+      { __gnu_sequential::sort(__begin, __end, __comp); }
+    };
+
+  template<bool __stable, typename Seq_RAIter,
+	   typename _RAIter, typename _Compare,
+	   typename DiffType>
+    struct __possibly_stable_multiway_merge
+    { };
+
+  template<typename Seq_RAIter, typename _RAIter,
+	   typename _Compare, typename _DiffType>
+    struct __possibly_stable_multiway_merge<true, Seq_RAIter,
+					    _RAIter, _Compare, _DiffType>
+    {
+      void operator()(const Seq_RAIter& __seqs_begin,
+		      const Seq_RAIter& __seqs_end,
+		      const _RAIter& __target,
+		      _Compare& __comp,
+		      _DiffType __length_am) const
+      { stable_multiway_merge(__seqs_begin, __seqs_end, __target,
+			      __length_am, __comp, sequential_tag()); }
+    };
+
+  template<typename Seq_RAIter, typename _RAIter,
+	   typename _Compare, typename _DiffType>
+    struct __possibly_stable_multiway_merge<false, Seq_RAIter,
+					    _RAIter, _Compare, _DiffType>
+    {
+      void operator()(const Seq_RAIter& __seqs_begin,
+                      const Seq_RAIter& __seqs_end,
+                      const _RAIter& __target,
+                      _Compare& __comp,
+                      _DiffType __length_am) const
+      { multiway_merge(__seqs_begin, __seqs_end, __target, __length_am,
+		       __comp, sequential_tag()); }
+    };
+
+  /** @brief PMWMS code executed by each thread.
+   *  @param __sd Pointer to algorithm data.
+   *  @param __comp Comparator.
+   */
+  template<bool __stable, bool __exact, typename _RAIter,
+	   typename _Compare>
+    void
+    parallel_sort_mwms_pu(_PMWMSSortingData<_RAIter>* __sd,
+			  _Compare& __comp)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _ThreadIndex __iam = omp_get_thread_num();
+
+      // Length of this thread's chunk, before merging.
+      _DifferenceType __length_local =
+	__sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam];
+
+      // Sort in temporary storage, leave space for sentinel.
+
+      typedef _ValueType* _SortingPlacesIterator;
+
+      __sd->_M_temporary[__iam] =
+        static_cast<_ValueType*>(::operator new(sizeof(_ValueType)
+						* (__length_local + 1)));
+
+      // Copy there.
+      std::uninitialized_copy(__sd->_M_source + __sd->_M_starts[__iam],
+			      __sd->_M_source + __sd->_M_starts[__iam]
+			      + __length_local,
+			      __sd->_M_temporary[__iam]);
+
+      __possibly_stable_sort<__stable, _SortingPlacesIterator, _Compare>()
+        (__sd->_M_temporary[__iam],
+	 __sd->_M_temporary[__iam] + __length_local,
+         __comp);
+
+      // Invariant: locally sorted subsequence in sd->_M_temporary[__iam],
+      // __sd->_M_temporary[__iam] + __length_local.
+
+      // No barrier here: Synchronization is done by the splitting routine.
+
+      _DifferenceType __num_samples =
+        _Settings::get().sort_mwms_oversampling * __sd->_M_num_threads - 1;
+      _SplitConsistently<__exact, _RAIter, _Compare, _SortingPlacesIterator>()
+        (__iam, __sd, __comp, __num_samples);
+
+      // Offset from __target __begin, __length after merging.
+      _DifferenceType __offset = 0, __length_am = 0;
+      for (_ThreadIndex __s = 0; __s < __sd->_M_num_threads; __s++)
+	{
+	  __length_am += (__sd->_M_pieces[__iam][__s]._M_end
+			  - __sd->_M_pieces[__iam][__s]._M_begin);
+	  __offset += __sd->_M_pieces[__iam][__s]._M_begin;
+	}
+
+      typedef std::vector<
+        std::pair<_SortingPlacesIterator, _SortingPlacesIterator> >
+        _SeqVector;
+      _SeqVector __seqs(__sd->_M_num_threads);
+
+      for (_ThreadIndex __s = 0; __s < __sd->_M_num_threads; ++__s)
+	{
+	  __seqs[__s] =
+	    std::make_pair(__sd->_M_temporary[__s]
+			   + __sd->_M_pieces[__iam][__s]._M_begin,
+			   __sd->_M_temporary[__s]
+			   + __sd->_M_pieces[__iam][__s]._M_end);
+	}
+
+      __possibly_stable_multiway_merge<
+        __stable, typename _SeqVector::iterator,
+	_RAIter, _Compare, _DifferenceType>()(__seqs.begin(), __seqs.end(),
+				     __sd->_M_source + __offset, __comp,
+				     __length_am);
+
+#     pragma omp barrier
+
+      for (_DifferenceType __i = 0; __i < __length_local; ++__i)
+	__sd->_M_temporary[__iam][__i].~_ValueType();
+      ::operator delete(__sd->_M_temporary[__iam]);
+    }
+
+  /** @brief PMWMS main call.
+   *  @param __begin Begin iterator of sequence.
+   *  @param __end End iterator of sequence.
+   *  @param __comp Comparator.
+   *  @param __num_threads Number of threads to use.
+   */
+  template<bool __stable, bool __exact, typename _RAIter,
+           typename _Compare>
+    void
+    parallel_sort_mwms(_RAIter __begin, _RAIter __end,
+		       _Compare __comp,
+		       _ThreadIndex __num_threads)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __n = __end - __begin;
+
+      if (__n <= 1)
+	return;
+
+      // at least one element per thread
+      if (__num_threads > __n)
+	__num_threads = static_cast<_ThreadIndex>(__n);
+
+      // shared variables
+      _PMWMSSortingData<_RAIter> __sd;
+      _DifferenceType* __starts;
+      _DifferenceType __size;
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+        __num_threads = omp_get_num_threads(); //no more threads than requested
+
+#       pragma omp single
+	{
+	  __sd._M_num_threads = __num_threads;
+	  __sd._M_source = __begin;
+	  
+	  __sd._M_temporary = new _ValueType*[__num_threads];
+
+	  if (!__exact)
+	    {
+	      __size =
+		(_Settings::get().sort_mwms_oversampling * __num_threads - 1)
+		* __num_threads;
+	      __sd._M_samples = static_cast<_ValueType*>
+		(::operator new(__size * sizeof(_ValueType)));
+	    }
+	  else
+	    __sd._M_samples = 0;
+
+	  __sd._M_offsets = new _DifferenceType[__num_threads - 1];
+	  __sd._M_pieces
+	    = new std::vector<_Piece<_DifferenceType> >[__num_threads];
+	  for (_ThreadIndex __s = 0; __s < __num_threads; ++__s)
+	    __sd._M_pieces[__s].resize(__num_threads);
+	  __starts = __sd._M_starts = new _DifferenceType[__num_threads + 1];
+
+	  _DifferenceType __chunk_length = __n / __num_threads;
+	  _DifferenceType __split = __n % __num_threads;
+	  _DifferenceType __pos = 0;
+	  for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	    {
+	      __starts[__i] = __pos;
+	      __pos += ((__i < __split)
+			? (__chunk_length + 1) : __chunk_length);
+	    }
+	  __starts[__num_threads] = __pos;
+	} //single
+
+        // Now sort in parallel.
+        parallel_sort_mwms_pu<__stable, __exact>(&__sd, __comp);
+      } //parallel
+
+      delete[] __starts;
+      delete[] __sd._M_temporary;
+
+      if (!__exact)
+	{
+	  for (_DifferenceType __i = 0; __i < __size; ++__i)
+	    __sd._M_samples[__i].~_ValueType();
+	  ::operator delete(__sd._M_samples);
+	}
+
+      delete[] __sd._M_offsets;
+      delete[] __sd._M_pieces;
+    }
+
+} //namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_MULTIWAY_MERGESORT_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/numeric b/gcc-4.9/libstdc++-v3/include/parallel/numeric
new file mode 100644
index 0000000..8254635
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/numeric
@@ -0,0 +1,514 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file parallel/numeric
+*
+ * @brief Parallel STL function calls corresponding to stl_numeric.h.
+ * The functions defined here mainly do case switches and
+ * call the actual parallelized versions in other files.
+ * Inlining policy: Functions that basically only contain one function call,
+ * are declared inline.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler and Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_NUMERIC_H
+#define _GLIBCXX_PARALLEL_NUMERIC_H 1
+
+#include <numeric>
+#include <bits/stl_function.h>
+#include <parallel/numericfwd.h>
+#include <parallel/iterator.h>
+#include <parallel/for_each.h>
+#include <parallel/for_each_selectors.h>
+#include <parallel/partial_sum.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __parallel
+{
+  // Sequential fallback.
+  template<typename _IIter, typename _Tp>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
+               __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::accumulate(__begin, __end, __init); }
+
+  template<typename _IIter, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init,
+               _BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::accumulate(__begin, __end, __init, __binary_op); }
+
+  // Sequential fallback for input iterator case.
+  template<typename _IIter, typename _Tp, typename _IteratorTag>
+    inline _Tp
+    __accumulate_switch(_IIter __begin, _IIter __end,
+                      _Tp __init, _IteratorTag) 
+    { return accumulate(__begin, __end, __init,
+			__gnu_parallel::sequential_tag()); }
+
+  template<typename _IIter, typename _Tp, typename _BinaryOperation,
+           typename _IteratorTag>
+    inline _Tp
+    __accumulate_switch(_IIter __begin, _IIter __end, _Tp __init, 
+                      _BinaryOperation __binary_op, _IteratorTag)
+    { return accumulate(__begin, __end, __init, __binary_op, 
+                        __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename __RAIter, typename _Tp, typename _BinaryOperation>
+    _Tp
+    __accumulate_switch(__RAIter __begin, __RAIter __end, 
+                      _Tp __init, _BinaryOperation __binary_op, 
+                      random_access_iterator_tag, 
+                      __gnu_parallel::_Parallelism __parallelism_tag  
+                      = __gnu_parallel::parallel_unbalanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().accumulate_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          _Tp __res = __init;
+          __gnu_parallel::__accumulate_selector<__RAIter>
+            __my_selector;
+          __gnu_parallel::
+            __for_each_template_random_access_ed(__begin, __end,
+						 __gnu_parallel::_Nothing(),
+						 __my_selector,
+						 __gnu_parallel::
+						 __accumulate_binop_reduct
+					       <_BinaryOperation>(__binary_op),
+						 __res, __res, -1);
+          return __res;
+        }
+      else
+        return accumulate(__begin, __end, __init, __binary_op, 
+                          __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface.
+  template<typename _IIter, typename _Tp>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
+               __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::value_type _ValueType;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+
+      return __accumulate_switch(__begin, __end, __init,
+				 __gnu_parallel::_Plus<_Tp, _ValueType>(),
+				 _IteratorCategory(), __parallelism_tag);
+    }
+
+  template<typename _IIter, typename _Tp>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init)
+    {
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::value_type _ValueType;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+
+      return __accumulate_switch(__begin, __end, __init,
+				 __gnu_parallel::_Plus<_Tp, _ValueType>(),
+				 _IteratorCategory());
+    }
+
+  template<typename _IIter, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
+               _BinaryOperation __binary_op, 
+               __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __accumulate_switch(__begin, __end, __init, __binary_op, 
+				 _IteratorCategory(), __parallelism_tag);
+    }
+
+  template<typename _IIter, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
+               _BinaryOperation __binary_op) 
+    {
+      typedef iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __accumulate_switch(__begin, __end, __init, __binary_op, 
+				 _IteratorCategory());
+    }
+
+
+  // Sequential fallback.
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+                  _IIter2 __first2, _Tp __init,
+                  __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::inner_product(
+                               __first1, __last1, __first2, __init); }
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename _BinaryFunction1, typename _BinaryFunction2>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1,
+                  _IIter2 __first2, _Tp __init, _BinaryFunction1 __binary_op1, 
+                  _BinaryFunction2 __binary_op2,
+                  __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::inner_product(__first1, __last1, __first2, __init,
+                                           __binary_op1, __binary_op2); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Tp, typename _BinaryFunction1, typename _BinaryFunction2>
+    _Tp
+    __inner_product_switch(_RAIter1 __first1,
+			   _RAIter1 __last1,
+			   _RAIter2 __first2, _Tp __init,
+			   _BinaryFunction1 __binary_op1,
+			   _BinaryFunction2 __binary_op2,
+			   random_access_iterator_tag,
+			   random_access_iterator_tag,
+			   __gnu_parallel::_Parallelism __parallelism_tag
+			   = __gnu_parallel::parallel_unbalanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION((__last1 - __first1)
+                                      >= __gnu_parallel::_Settings::get().
+                                      accumulate_minimal_n
+                                      && __gnu_parallel::
+                                      __is_parallel(__parallelism_tag)))
+        {
+          _Tp __res = __init;
+          __gnu_parallel::
+            __inner_product_selector<_RAIter1,
+            _RAIter2, _Tp> __my_selector(__first1, __first2);
+          __gnu_parallel::
+            __for_each_template_random_access_ed(
+                __first1, __last1, __binary_op2, __my_selector, __binary_op1,
+                __res, __res, -1);
+          return __res;
+        }
+      else
+        return inner_product(__first1, __last1, __first2, __init, 
+                             __gnu_parallel::sequential_tag());
+    }
+
+  // No parallelism for input iterators.
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename _BinaryFunction1, typename _BinaryFunction2,
+           typename _IteratorTag1, typename _IteratorTag2>
+    inline _Tp
+    __inner_product_switch(_IIter1 __first1, _IIter1 __last1, 
+			   _IIter2 __first2, _Tp __init, 
+			   _BinaryFunction1 __binary_op1,
+			   _BinaryFunction2 __binary_op2, 
+			   _IteratorTag1, _IteratorTag2)
+    { return inner_product(__first1, __last1, __first2, __init, __binary_op1,
+			   __binary_op2, __gnu_parallel::sequential_tag()); }
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename _BinaryFunction1, typename _BinaryFunction2>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+                  _IIter2 __first2, _Tp __init, _BinaryFunction1 __binary_op1, 
+                  _BinaryFunction2 __binary_op2, 
+                  __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
+
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
+
+      return __inner_product_switch(__first1, __last1, __first2, __init,
+				    __binary_op1, __binary_op2,
+				    _IteratorCategory1(), _IteratorCategory2(),
+				    __parallelism_tag);
+    }
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename _BinaryFunction1, typename _BinaryFunction2>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+                  _IIter2 __first2, _Tp __init, _BinaryFunction1 __binary_op1, 
+                  _BinaryFunction2 __binary_op2)
+    {
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
+
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
+
+      return __inner_product_switch(__first1, __last1, __first2, __init,
+				    __binary_op1, __binary_op2,
+				    _IteratorCategory1(),
+				    _IteratorCategory2());
+    }
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+                  _IIter2 __first2, _Tp __init, 
+                  __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::value_type _ValueType1;
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::value_type _ValueType2;
+
+      typedef typename
+        __gnu_parallel::_Multiplies<_ValueType1, _ValueType2>::result_type
+        _MultipliesResultType;
+      return __gnu_parallel::inner_product(__first1, __last1, __first2, __init,
+                           __gnu_parallel::_Plus<_Tp, _MultipliesResultType>(),
+                           __gnu_parallel::
+                           _Multiplies<_ValueType1, _ValueType2>(),
+                           __parallelism_tag);
+    }
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+                  _IIter2 __first2, _Tp __init)
+    {
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::value_type _ValueType1;
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::value_type _ValueType2;
+
+      typedef typename
+        __gnu_parallel::_Multiplies<_ValueType1, _ValueType2>::result_type
+        _MultipliesResultType;
+      return __gnu_parallel::inner_product(__first1, __last1, __first2, __init,
+                           __gnu_parallel::_Plus<_Tp, _MultipliesResultType>(),
+                           __gnu_parallel::
+                           _Multiplies<_ValueType1, _ValueType2>());
+    }
+
+  // Sequential fallback.
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
+                __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result); }
+
+  // Sequential fallback.
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
+                _BinaryOperation __bin_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result, __bin_op); }
+
+  // Sequential fallback for input iterator case.
+  template<typename _IIter, typename _OutputIterator,
+           typename _BinaryOperation, typename _IteratorTag1,
+           typename _IteratorTag2>
+    inline _OutputIterator
+    __partial_sum_switch(_IIter __begin, _IIter __end,
+			 _OutputIterator __result, _BinaryOperation __bin_op,
+			 _IteratorTag1, _IteratorTag2)
+    { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result, __bin_op); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _IIter, typename _OutputIterator,
+           typename _BinaryOperation>
+    _OutputIterator
+    __partial_sum_switch(_IIter __begin, _IIter __end,
+			 _OutputIterator __result, _BinaryOperation __bin_op,
+			 random_access_iterator_tag,
+			 random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().partial_sum_minimal_n))
+        return __gnu_parallel::__parallel_partial_sum(__begin, __end,
+						      __result, __bin_op);
+      else
+        return partial_sum(__begin, __end, __result, __bin_op,
+                           __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface.
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_IIter>::value_type _ValueType;
+      return __gnu_parallel::partial_sum(__begin, __end,
+                                         __result, std::plus<_ValueType>());
+    }
+
+  // Public interface
+  template<typename _IIter, typename _OutputIterator,
+           typename _BinaryOperation>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
+                _BinaryOperation __binary_op)
+    {
+      typedef iterator_traits<_IIter> _ITraitsType;
+      typedef typename _ITraitsType::iterator_category _IIteratorCategory;
+
+      typedef iterator_traits<_OutputIterator> _OTraitsType;
+      typedef typename _OTraitsType::iterator_category _OIterCategory;
+
+      return __partial_sum_switch(__begin, __end, __result, __binary_op,
+				  _IIteratorCategory(), _OIterCategory());
+    }
+
+  // Sequential fallback.
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end, _OutputIterator __result,
+                        __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::adjacent_difference(__begin, __end, __result); }
+
+  // Sequential fallback.
+  template<typename _IIter, typename _OutputIterator,
+           typename _BinaryOperation>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+                        _OutputIterator __result, _BinaryOperation __bin_op,
+                        __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_A::adjacent_difference(__begin, __end,
+						 __result, __bin_op); }
+
+  // Sequential fallback for input iterator case.
+  template<typename _IIter, typename _OutputIterator,
+           typename _BinaryOperation, typename _IteratorTag1,
+           typename _IteratorTag2>
+    inline _OutputIterator
+    __adjacent_difference_switch(_IIter __begin, _IIter __end,
+				 _OutputIterator __result,
+				 _BinaryOperation __bin_op, _IteratorTag1,
+				 _IteratorTag2)
+    { return adjacent_difference(__begin, __end, __result, __bin_op,
+                                 __gnu_parallel::sequential_tag()); }
+
+  // Parallel algorithm for random access iterators.
+  template<typename _IIter, typename _OutputIterator,
+           typename _BinaryOperation>
+    _OutputIterator
+    __adjacent_difference_switch(_IIter __begin, _IIter __end,
+				 _OutputIterator __result,
+				 _BinaryOperation __bin_op,
+				 random_access_iterator_tag,
+				 random_access_iterator_tag,
+				 __gnu_parallel::_Parallelism
+				 __parallelism_tag
+				 = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
+            >= __gnu_parallel::_Settings::get().adjacent_difference_minimal_n
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
+        {
+          bool __dummy = true;
+          typedef __gnu_parallel::_IteratorPair<_IIter, _OutputIterator,
+            random_access_iterator_tag> _ItTrip;
+          *__result = *__begin;
+          _ItTrip __begin_pair(__begin + 1, __result + 1),
+            __end_pair(__end, __result + (__end - __begin));
+          __gnu_parallel::__adjacent_difference_selector<_ItTrip>
+                                                            __functionality;
+          __gnu_parallel::
+            __for_each_template_random_access_ed(
+                __begin_pair, __end_pair, __bin_op, __functionality,
+                __gnu_parallel::_DummyReduct(), __dummy, __dummy, -1);
+          return __functionality._M_finish_iterator;
+        }
+      else
+        return adjacent_difference(__begin, __end, __result, __bin_op, 
+                                   __gnu_parallel::sequential_tag());
+    }
+
+  // Public interface.
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+                        _OutputIterator __result,
+                        __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      return adjacent_difference(__begin, __end, __result,
+				 std::minus<_ValueType>(),
+				 __parallelism_tag);
+    }
+
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+                        _OutputIterator __result)
+    {
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      return adjacent_difference(__begin, __end, __result,
+				 std::minus<_ValueType>());
+    }
+
+  template<typename _IIter, typename _OutputIterator,
+           typename _BinaryOperation>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+                        _OutputIterator __result, _BinaryOperation __binary_op,
+                        __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef iterator_traits<_IIter> _ITraitsType;
+      typedef typename _ITraitsType::iterator_category _IIteratorCategory;
+
+      typedef iterator_traits<_OutputIterator> _OTraitsType;
+      typedef typename _OTraitsType::iterator_category _OIterCategory;
+
+      return __adjacent_difference_switch(__begin, __end, __result,
+					  __binary_op,
+					  _IIteratorCategory(),
+					  _OIterCategory(),
+					  __parallelism_tag);
+    }
+
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+			_OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef iterator_traits<_IIter> _ITraitsType;
+      typedef typename _ITraitsType::iterator_category _IIteratorCategory;
+
+      typedef iterator_traits<_OutputIterator> _OTraitsType;
+      typedef typename _OTraitsType::iterator_category _OIterCategory;
+
+      return __adjacent_difference_switch(__begin, __end, __result,
+					  __binary_op,
+					  _IIteratorCategory(),
+					  _OIterCategory());
+    }
+} // end namespace
+} // end namespace
+
+#endif /* _GLIBCXX_NUMERIC_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/numericfwd.h b/gcc-4.9/libstdc++-v3/include/parallel/numericfwd.h
new file mode 100644
index 0000000..28cd4a0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/numericfwd.h
@@ -0,0 +1,203 @@
+// <parallel/numeric> Forward declarations -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/numericfwd.h
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PARALLEL_NUMERICFWD_H
+#define _GLIBCXX_PARALLEL_NUMERICFWD_H 1
+
+#pragma GCC system_header
+
+#include <parallel/tags.h>
+#include <parallel/settings.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __parallel
+{
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp);
+
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _Tp, typename _Tag>
+    _Tp
+    __accumulate_switch(_IIter, _IIter, _Tp, _Tag);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper,
+               __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper,
+               __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper,
+           typename _Tag>
+    _Tp
+    __accumulate_switch(_IIter, _IIter, _Tp, _BinaryOper, _Tag);
+
+  template<typename _RAIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    __accumulate_switch(_RAIter, _RAIter, _Tp, _BinaryOper,
+                      random_access_iterator_tag,
+                      __gnu_parallel::_Parallelism __parallelism
+                      = __gnu_parallel::parallel_unbalanced);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper>
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter,
+                        __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper>
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
+                        __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter,
+                        __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper>
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
+                        __gnu_parallel::_Parallelism);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper,
+           typename _Tag1, typename _Tag2>
+    _OIter
+    __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper,
+                               _Tag1, _Tag2);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper>
+    _OIter
+    __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, 
+                               random_access_iterator_tag, 
+                               random_access_iterator_tag, 
+                               __gnu_parallel::_Parallelism __parallelism
+                               = __gnu_parallel::parallel_unbalanced);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
+                  __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
+                  __gnu_parallel::_Parallelism);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename _BinaryFunction1, typename _BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
+                  _BinaryFunction1, _BinaryFunction2);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename _BinaryFunction1, typename _BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1,
+                  _BinaryFunction2, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename BinaryFunction1, typename BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp, BinaryFunction1,
+                  BinaryFunction2, __gnu_parallel::_Parallelism);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Tp,
+           typename BinaryFunction1, typename BinaryFunction2>
+    _Tp
+    __inner_product_switch(_RAIter1, _RAIter1, _RAIter2, _Tp, BinaryFunction1,
+                         BinaryFunction2, random_access_iterator_tag, 
+                         random_access_iterator_tag, 
+                         __gnu_parallel::_Parallelism
+                         = __gnu_parallel::parallel_unbalanced);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+           typename _BinaryFunction1, typename _BinaryFunction2,
+           typename _Tag1, typename _Tag2>
+    _Tp
+    __inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, 
+                         _BinaryFunction2, _Tag1, _Tag2);
+
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper>
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter, _BinaryOper,
+                __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter __result);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper>
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter, _BinaryOper);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper,
+           typename _Tag1, typename _Tag2>
+    _OIter
+    __partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
+
+  template<typename _IIter, typename _OIter, typename _BinaryOper>
+    _OIter
+    __partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper,
+                       random_access_iterator_tag, random_access_iterator_tag);
+} // end namespace
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_NUMERICFWD_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/omp_loop.h b/gcc-4.9/libstdc++-v3/include/parallel/omp_loop.h
new file mode 100644
index 0000000..e82f9d5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/omp_loop.h
@@ -0,0 +1,115 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/omp_loop.h
+ *  @brief Parallelization of embarrassingly parallel execution by
+ *  means of an OpenMP for loop.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_OMP_LOOP_H
+#define _GLIBCXX_PARALLEL_OMP_LOOP_H 1
+
+#include <omp.h>
+
+#include <parallel/settings.h>
+#include <parallel/basic_iterator.h>
+#include <parallel/base.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Embarrassingly parallel algorithm for random access
+   * iterators, using an OpenMP for loop.
+   *
+   *  @param __begin Begin iterator of element sequence.
+   *  @param __end End iterator of element sequence.
+   *  @param __o User-supplied functor (comparator, predicate, adding
+   *  functor, etc.).
+   *  @param __f Functor to @a process an element with __op (depends on
+   *  desired functionality, e. g. for std::for_each(), ...).
+   *  @param __r Functor to @a add a single __result to the already
+   *  processed elements (depends on functionality).
+   *  @param __base Base value for reduction.
+   *  @param __output Pointer to position where final result is written to
+   *  @param __bound Maximum number of elements processed (e. g. for
+   *  std::count_n()).
+   *  @return User-supplied functor (that may contain a part of the result).
+   */
+  template<typename _RAIter,
+	   typename _Op,
+	   typename _Fu,
+	   typename _Red,
+	   typename _Result>
+    _Op
+    __for_each_template_random_access_omp_loop(_RAIter __begin, _RAIter __end,
+					       _Op __o, _Fu& __f, _Red __r,
+					       _Result __base,
+					       _Result& __output,
+      typename std::iterator_traits<_RAIter>::difference_type __bound)
+    {
+      typedef typename std::iterator_traits<_RAIter>::difference_type
+        _DifferenceType;
+
+      _DifferenceType __length = __end - __begin;
+      _ThreadIndex __num_threads = __gnu_parallel::min<_DifferenceType>
+	(__get_max_threads(), __length);
+
+      _Result *__thread_results;
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+	  __thread_results = new _Result[__num_threads];
+
+	  for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	    __thread_results[__i] = _Result();
+	}
+
+        _ThreadIndex __iam = omp_get_thread_num();
+
+#pragma omp for schedule(dynamic, _Settings::get().workstealing_chunk_size)
+        for (_DifferenceType __pos = 0; __pos < __length; ++__pos)
+          __thread_results[__iam] = __r(__thread_results[__iam],
+					__f(__o, __begin+__pos));
+      } //parallel
+
+      for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+        __output = __r(__output, __thread_results[__i]);
+
+      delete [] __thread_results;
+
+      // Points to last element processed (needed as return value for
+      // some algorithms like transform).
+      __f._M_finish_iterator = __begin + __length;
+
+      return __o;
+    }
+
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_OMP_LOOP_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/omp_loop_static.h b/gcc-4.9/libstdc++-v3/include/parallel/omp_loop_static.h
new file mode 100644
index 0000000..a401017
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/omp_loop_static.h
@@ -0,0 +1,115 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/omp_loop_static.h
+ *  @brief Parallelization of embarrassingly parallel execution by
+ *  means of an OpenMP for loop with static scheduling.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_OMP_LOOP_STATIC_H
+#define _GLIBCXX_PARALLEL_OMP_LOOP_STATIC_H 1
+
+#include <omp.h>
+
+#include <parallel/settings.h>
+#include <parallel/basic_iterator.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Embarrassingly parallel algorithm for random access
+   * iterators, using an OpenMP for loop with static scheduling.
+   *
+   *  @param __begin Begin iterator of element sequence.
+   *  @param __end End iterator of element sequence.
+   *  @param __o User-supplied functor (comparator, predicate, adding
+   *  functor, ...).
+   *  @param __f Functor to @a process an element with __op (depends on
+   *  desired functionality, e. g. for std::for_each(), ...).
+   *  @param __r Functor to @a add a single __result to the already processed
+   *  __elements (depends on functionality).
+   *  @param __base Base value for reduction.
+   *  @param __output Pointer to position where final result is written to
+   *  @param __bound Maximum number of elements processed (e. g. for
+   *  std::count_n()).
+   *  @return User-supplied functor (that may contain a part of the result).
+   */
+  template<typename _RAIter,
+	   typename _Op,
+	   typename _Fu,
+	   typename _Red,
+	   typename _Result>
+    _Op
+    __for_each_template_random_access_omp_loop_static(_RAIter __begin,
+						      _RAIter __end, _Op __o,
+						      _Fu& __f, _Red __r,
+						      _Result __base,
+						      _Result& __output,
+      typename std::iterator_traits<_RAIter>::difference_type __bound)
+    {
+      typedef typename std::iterator_traits<_RAIter>::difference_type
+	_DifferenceType;
+
+      _DifferenceType __length = __end - __begin;
+      _ThreadIndex __num_threads = std::min<_DifferenceType>
+	(__get_max_threads(), __length);
+
+      _Result *__thread_results;
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+	  __thread_results = new _Result[__num_threads];
+
+	  for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	    __thread_results[__i] = _Result();
+	}
+
+        _ThreadIndex __iam = omp_get_thread_num();
+
+#pragma omp for schedule(static, _Settings::get().workstealing_chunk_size)
+        for (_DifferenceType __pos = 0; __pos < __length; ++__pos)
+          __thread_results[__iam] = __r(__thread_results[__iam],
+                                        __f(__o, __begin+__pos));
+      } //parallel
+
+      for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	__output = __r(__output, __thread_results[__i]);
+
+      delete [] __thread_results;
+
+      // Points to last element processed (needed as return value for
+      // some algorithms like transform).
+      __f.finish_iterator = __begin + __length;
+
+      return __o;
+    }
+
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_OMP_LOOP_STATIC_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/par_loop.h b/gcc-4.9/libstdc++-v3/include/parallel/par_loop.h
new file mode 100644
index 0000000..0ed57c3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/par_loop.h
@@ -0,0 +1,139 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/par_loop.h
+ *  @brief Parallelization of embarrassingly parallel execution by
+ *  means of equal splitting.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_PAR_LOOP_H
+#define _GLIBCXX_PARALLEL_PAR_LOOP_H 1
+
+#include <omp.h>
+#include <parallel/settings.h>
+#include <parallel/base.h>
+#include <parallel/equally_split.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Embarrassingly parallel algorithm for random access
+   * iterators, using hand-crafted parallelization by equal splitting
+   * the work.
+   *
+   *  @param __begin Begin iterator of element sequence.
+   *  @param __end End iterator of element sequence.
+   *  @param __o User-supplied functor (comparator, predicate, adding
+   *  functor, ...)
+   *  @param __f Functor to "process" an element with __op (depends on
+   *  desired functionality, e. g. for std::for_each(), ...).
+   *  @param __r Functor to "add" a single __result to the already
+   *  processed elements (depends on functionality).
+   *  @param __base Base value for reduction.
+   *  @param __output Pointer to position where final result is written to
+   *  @param __bound Maximum number of elements processed (e. g. for
+   *  std::count_n()).
+   *  @return User-supplied functor (that may contain a part of the result).
+   */
+  template<typename _RAIter,
+	   typename _Op,
+	   typename _Fu,
+	   typename _Red,
+	   typename _Result>
+    _Op
+    __for_each_template_random_access_ed(_RAIter __begin, _RAIter __end,
+					 _Op __o, _Fu& __f, _Red __r,
+					 _Result __base, _Result& __output,
+      typename std::iterator_traits<_RAIter>::difference_type __bound)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      const _DifferenceType __length = __end - __begin;
+      _Result *__thread_results;
+      bool* __constructed;
+
+      _ThreadIndex __num_threads = __gnu_parallel::min<_DifferenceType>
+	(__get_max_threads(), __length);
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+	  __thread_results = static_cast<_Result*>
+	    (::operator new(__num_threads * sizeof(_Result)));
+	  __constructed = new bool[__num_threads];
+	}
+
+	_ThreadIndex __iam = omp_get_thread_num();
+
+	// Neutral element.
+	_Result* __reduct;
+
+	_DifferenceType
+	  __start = __equally_split_point(__length, __num_threads, __iam),
+	  __stop = __equally_split_point(__length, __num_threads, __iam + 1);
+
+	if (__start < __stop)
+	  {
+	    __reduct = new _Result(__f(__o, __begin + __start));
+	    ++__start;
+	    __constructed[__iam] = true;
+	  }
+	else
+	  __constructed[__iam] = false;
+
+	for (; __start < __stop; ++__start)
+	  *__reduct = __r(*__reduct, __f(__o, __begin + __start));
+
+	if (__constructed[__iam])
+	  {
+	    ::new(&__thread_results[__iam]) _Result(*__reduct);
+	    delete __reduct;
+	  }
+      } //parallel
+
+      for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	if (__constructed[__i])
+	  {
+	    __output = __r(__output, __thread_results[__i]);
+	    __thread_results[__i].~_Result();
+	  }
+
+      // Points to last element processed (needed as return value for
+      // some algorithms like transform).
+      __f._M_finish_iterator = __begin + __length;
+
+      ::operator delete(__thread_results);
+
+      delete[] __constructed;
+
+      return __o;
+    }
+
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_PAR_LOOP_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/parallel.h b/gcc-4.9/libstdc++-v3/include/parallel/parallel.h
new file mode 100644
index 0000000..72b91be
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/parallel.h
@@ -0,0 +1,42 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/parallel.h
+ *  @brief End-user include file. Provides advanced settings and
+ *  tuning options.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze and Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_PARALLEL_H
+#define _GLIBCXX_PARALLEL_PARALLEL_H 1
+
+#include <parallel/features.h>
+#include <parallel/compiletime_settings.h>
+#include <parallel/types.h>
+#include <parallel/tags.h>
+#include <parallel/settings.h>
+
+#endif /* _GLIBCXX_PARALLEL_PARALLEL_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/partial_sum.h b/gcc-4.9/libstdc++-v3/include/parallel/partial_sum.h
new file mode 100644
index 0000000..5792d02
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/partial_sum.h
@@ -0,0 +1,230 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/partial_sum.h
+ *  @brief Parallel implementation of std::partial_sum(), i.e. prefix
+*  sums.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_PARTIAL_SUM_H
+#define _GLIBCXX_PARALLEL_PARTIAL_SUM_H 1
+
+#include <omp.h>
+#include <new>
+#include <bits/stl_algobase.h>
+#include <parallel/parallel.h>
+#include <parallel/numericfwd.h>
+
+namespace __gnu_parallel
+{
+  // Problem: there is no 0-element given.
+
+  /** @brief Base case prefix sum routine.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __result Begin iterator of output sequence.
+   *  @param __bin_op Associative binary function.
+   *  @param __value Start value. Must be passed since the neutral
+   *  element is unknown in general.
+   *  @return End iterator of output sequence. */
+  template<typename _IIter,
+	   typename _OutputIterator,
+	   typename _BinaryOperation>
+    _OutputIterator
+    __parallel_partial_sum_basecase(_IIter __begin, _IIter __end,
+				    _OutputIterator __result,
+				    _BinaryOperation __bin_op,
+      typename std::iterator_traits <_IIter>::value_type __value)
+    {
+      if (__begin == __end)
+	return __result;
+
+      while (__begin != __end)
+	{
+	  __value = __bin_op(__value, *__begin);
+	  *__result = __value;
+	  ++__result;
+	  ++__begin;
+	}
+      return __result;
+    }
+
+  /** @brief Parallel partial sum implementation, two-phase approach,
+      no recursion.
+      *  @param __begin Begin iterator of input sequence.
+      *  @param __end End iterator of input sequence.
+      *  @param __result Begin iterator of output sequence.
+      *  @param __bin_op Associative binary function.
+      *  @param __n Length of sequence.
+      *  @return End iterator of output sequence.
+      */
+  template<typename _IIter,
+	   typename _OutputIterator,
+	   typename _BinaryOperation>
+    _OutputIterator
+    __parallel_partial_sum_linear(_IIter __begin, _IIter __end,
+				  _OutputIterator __result,
+				  _BinaryOperation __bin_op,
+      typename std::iterator_traits<_IIter>::difference_type __n)
+    {
+      typedef std::iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      if (__begin == __end)
+	return __result;
+
+      _ThreadIndex __num_threads =
+        std::min<_DifferenceType>(__get_max_threads(), __n - 1);
+
+      if (__num_threads < 2)
+	{
+	  *__result = *__begin;
+	  return __parallel_partial_sum_basecase(__begin + 1, __end,
+						 __result + 1, __bin_op,
+						 *__begin);
+	}
+
+      _DifferenceType* __borders;
+      _ValueType* __sums;
+
+      const _Settings& __s = _Settings::get();
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+	    
+	  __borders = new _DifferenceType[__num_threads + 2];
+
+	  if (__s.partial_sum_dilation == 1.0f)
+	    __equally_split(__n, __num_threads + 1, __borders);
+	  else
+	    {
+	      _DifferenceType __first_part_length =
+		  std::max<_DifferenceType>(1,
+		    __n / (1.0f + __s.partial_sum_dilation * __num_threads));
+	      _DifferenceType __chunk_length =
+		  (__n - __first_part_length) / __num_threads;
+	      _DifferenceType __borderstart =
+		  __n - __num_threads * __chunk_length;
+	      __borders[0] = 0;
+	      for (_ThreadIndex __i = 1; __i < (__num_threads + 1); ++__i)
+		{
+		  __borders[__i] = __borderstart;
+		  __borderstart += __chunk_length;
+		}
+	      __borders[__num_threads + 1] = __n;
+	    }
+
+	  __sums = static_cast<_ValueType*>(::operator new(sizeof(_ValueType)
+                                                           * __num_threads));
+	  _OutputIterator __target_end;
+	} //single
+
+        _ThreadIndex __iam = omp_get_thread_num();
+        if (__iam == 0)
+          {
+            *__result = *__begin;
+            __parallel_partial_sum_basecase(__begin + 1,
+					    __begin + __borders[1],
+					    __result + 1,
+					    __bin_op, *__begin);
+            ::new(&(__sums[__iam])) _ValueType(*(__result + __borders[1] - 1));
+          }
+        else
+          {
+            ::new(&(__sums[__iam]))
+              _ValueType(__gnu_parallel::accumulate(
+                                         __begin + __borders[__iam] + 1,
+                                         __begin + __borders[__iam + 1],
+                                         *(__begin + __borders[__iam]),
+                                         __bin_op,
+                                         __gnu_parallel::sequential_tag()));
+          }
+
+#       pragma omp barrier
+
+#       pragma omp single
+	__parallel_partial_sum_basecase(__sums + 1, __sums + __num_threads,
+					__sums + 1, __bin_op, __sums[0]);
+
+#       pragma omp barrier
+
+	// Still same team.
+        __parallel_partial_sum_basecase(__begin + __borders[__iam + 1],
+					__begin + __borders[__iam + 2],
+					__result + __borders[__iam + 1],
+					__bin_op, __sums[__iam]);
+      } //parallel
+
+      for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	__sums[__i].~_ValueType();
+      ::operator delete(__sums);
+
+      delete[] __borders;
+
+      return __result + __n;
+    }
+
+  /** @brief Parallel partial sum front-__end.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __result Begin iterator of output sequence.
+   *  @param __bin_op Associative binary function.
+   *  @return End iterator of output sequence. */
+  template<typename _IIter,
+	   typename _OutputIterator,
+	   typename _BinaryOperation>
+    _OutputIterator
+    __parallel_partial_sum(_IIter __begin, _IIter __end,
+			   _OutputIterator __result, _BinaryOperation __bin_op)
+    {
+      _GLIBCXX_CALL(__begin - __end)
+
+      typedef std::iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __n = __end - __begin;
+
+      switch (_Settings::get().partial_sum_algorithm)
+	{
+	case LINEAR:
+	  // Need an initial offset.
+	  return __parallel_partial_sum_linear(__begin, __end, __result,
+					       __bin_op, __n);
+	default:
+	  // Partial_sum algorithm not implemented.
+	  _GLIBCXX_PARALLEL_ASSERT(0);
+	  return __result + __n;
+	}
+    }
+}
+
+#endif /* _GLIBCXX_PARALLEL_PARTIAL_SUM_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/partition.h b/gcc-4.9/libstdc++-v3/include/parallel/partition.h
new file mode 100644
index 0000000..5a9b7d3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/partition.h
@@ -0,0 +1,434 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/partition.h
+ *  @brief Parallel implementation of std::partition(),
+ *  std::nth_element(), and std::partial_sort().
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler and Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_PARTITION_H
+#define _GLIBCXX_PARALLEL_PARTITION_H 1
+
+#include <parallel/basic_iterator.h>
+#include <parallel/sort.h>
+#include <parallel/random_number.h>
+#include <bits/stl_algo.h>
+#include <parallel/parallel.h>
+
+/** @brief Decide whether to declare certain variables volatile. */
+#define _GLIBCXX_VOLATILE volatile
+
+namespace __gnu_parallel
+{
+  /** @brief Parallel implementation of std::partition.
+    *  @param __begin Begin iterator of input sequence to split.
+    *  @param __end End iterator of input sequence to split.
+    *  @param __pred Partition predicate, possibly including some kind
+    *         of pivot.
+    *  @param __num_threads Maximum number of threads to use for this task.
+    *  @return Number of elements not fulfilling the predicate. */
+  template<typename _RAIter, typename _Predicate>
+    typename std::iterator_traits<_RAIter>::difference_type
+    __parallel_partition(_RAIter __begin, _RAIter __end,
+			 _Predicate __pred, _ThreadIndex __num_threads)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __n = __end - __begin;
+
+      _GLIBCXX_CALL(__n)
+
+      const _Settings& __s = _Settings::get();
+
+      // shared
+      _GLIBCXX_VOLATILE _DifferenceType __left = 0, __right = __n - 1,
+                                        __dist = __n,
+                                        __leftover_left, __leftover_right,
+                                        __leftnew, __rightnew;
+
+      // just 0 or 1, but int to allow atomic operations
+      int* __reserved_left = 0, * __reserved_right = 0;
+
+      _DifferenceType __chunk_size = __s.partition_chunk_size;
+
+      //at least two chunks per thread
+      if (__dist >= 2 * __num_threads * __chunk_size)
+#       pragma omp parallel num_threads(__num_threads)
+	{
+#         pragma omp single
+	  {
+	    __num_threads = omp_get_num_threads();
+	    __reserved_left = new int[__num_threads];
+	    __reserved_right = new int[__num_threads];
+
+	    if (__s.partition_chunk_share > 0.0)
+	      __chunk_size = std::max<_DifferenceType>
+		(__s.partition_chunk_size, (double)__n 
+		 * __s.partition_chunk_share / (double)__num_threads);
+	    else
+	      __chunk_size = __s.partition_chunk_size;
+	  }
+
+	  while (__dist >= 2 * __num_threads * __chunk_size)
+	    {
+#             pragma omp single
+	      {
+		_DifferenceType __num_chunks = __dist / __chunk_size;
+
+		for (_ThreadIndex __r = 0; __r < __num_threads; ++__r)
+		  {
+		    __reserved_left [__r] = 0; // false
+		    __reserved_right[__r] = 0; // false
+		  }
+		__leftover_left = 0;
+		__leftover_right = 0;
+	      } //implicit barrier
+
+	      // Private.
+	      _DifferenceType __thread_left, __thread_left_border,
+		              __thread_right, __thread_right_border;
+
+	      __thread_left = __left + 1;
+	      // Just to satisfy the condition below.
+	      __thread_left_border = __thread_left - 1;
+
+	      __thread_right = __n - 1;
+             // Just to satisfy the condition below.
+	      __thread_right_border = __thread_right + 1;
+
+	      bool __iam_finished = false;
+	      while (!__iam_finished)
+		{
+		  if (__thread_left > __thread_left_border)
+		    {
+                      _DifferenceType __former_dist =
+                              __fetch_and_add(&__dist, -__chunk_size);
+                      if (__former_dist < __chunk_size)
+                        {
+                          __fetch_and_add(&__dist, __chunk_size);
+                          __iam_finished = true;
+                          break;
+                        }
+                      else
+                        {
+                          __thread_left =
+                                  __fetch_and_add(&__left, __chunk_size);
+                          __thread_left_border =
+                                  __thread_left + (__chunk_size - 1);
+                        }
+		    }
+
+		  if (__thread_right < __thread_right_border)
+		    {
+                      _DifferenceType __former_dist =
+                              __fetch_and_add(&__dist, -__chunk_size);
+                      if (__former_dist < __chunk_size)
+                        {
+                          __fetch_and_add(&__dist, __chunk_size);
+                          __iam_finished = true;
+                          break;
+                        }
+                      else
+                        {
+                          __thread_right =
+                                  __fetch_and_add(&__right, -__chunk_size);
+                          __thread_right_border =
+                                  __thread_right - (__chunk_size - 1);
+                        }
+		    }
+
+		  // Swap as usual.
+		  while (__thread_left < __thread_right)
+		    {
+		      while (__pred(__begin[__thread_left])
+			     && __thread_left <= __thread_left_border)
+			++__thread_left;
+		      while (!__pred(__begin[__thread_right])
+			     && __thread_right >= __thread_right_border)
+			--__thread_right;
+
+		      if (__thread_left > __thread_left_border
+			  || __thread_right < __thread_right_border)
+			// Fetch new chunk(__s).
+			break;
+
+		      std::iter_swap(__begin + __thread_left,
+                             __begin + __thread_right);
+		      ++__thread_left;
+		      --__thread_right;
+		    }
+		}
+
+	      // Now swap the leftover chunks to the right places.
+	      if (__thread_left <= __thread_left_border)
+#               pragma omp atomic
+		++__leftover_left;
+	      if (__thread_right >= __thread_right_border)
+#               pragma omp atomic
+		++__leftover_right;
+
+#             pragma omp barrier
+
+              _DifferenceType
+                    __leftold = __left,
+                    __leftnew = __left - __leftover_left * __chunk_size,
+                    __rightold = __right,
+                    __rightnew = __right + __leftover_right * __chunk_size;
+
+	      // <=> __thread_left_border + (__chunk_size - 1) >= __leftnew
+	      if (__thread_left <= __thread_left_border
+		  && __thread_left_border >= __leftnew)
+		{
+		  // Chunk already in place, reserve spot.
+		__reserved_left[(__left - (__thread_left_border + 1))
+				/ __chunk_size] = 1;
+		}
+
+	      // <=> __thread_right_border - (__chunk_size - 1) <= __rightnew
+	      if (__thread_right >= __thread_right_border
+		  && __thread_right_border <= __rightnew)
+		{
+		  // Chunk already in place, reserve spot.
+		  __reserved_right[((__thread_right_border - 1) - __right)
+				   / __chunk_size] = 1;
+		}
+
+#             pragma omp barrier
+
+	      if (__thread_left <= __thread_left_border
+		  && __thread_left_border < __leftnew)
+		{
+		  // Find spot and swap.
+		  _DifferenceType __swapstart = -1;
+                  for (int __r = 0; __r < __leftover_left; ++__r)
+                    if (__reserved_left[__r] == 0
+                        && __compare_and_swap(&(__reserved_left[__r]), 0, 1))
+                      {
+                        __swapstart = __leftold - (__r + 1) * __chunk_size;
+                        break;
+                      }
+
+#if _GLIBCXX_ASSERTIONS
+		  _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1);
+#endif
+
+		  std::swap_ranges(__begin + __thread_left_border
+				   - (__chunk_size - 1),
+				   __begin + __thread_left_border + 1,
+				   __begin + __swapstart);
+		}
+
+	      if (__thread_right >= __thread_right_border
+		  && __thread_right_border > __rightnew)
+		{
+		  // Find spot and swap
+		  _DifferenceType __swapstart = -1;
+                  for (int __r = 0; __r < __leftover_right; ++__r)
+                    if (__reserved_right[__r] == 0
+                        && __compare_and_swap(&(__reserved_right[__r]), 0, 1))
+                      {
+                        __swapstart = __rightold + __r * __chunk_size + 1;
+                        break;
+                      }
+
+#if _GLIBCXX_ASSERTIONS
+		  _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1);
+#endif
+
+		  std::swap_ranges(__begin + __thread_right_border,
+				   __begin + __thread_right_border
+				   + __chunk_size, __begin + __swapstart);
+	      }
+#if _GLIBCXX_ASSERTIONS
+#             pragma omp barrier
+
+#             pragma omp single
+	      {
+		for (_DifferenceType __r = 0; __r < __leftover_left; ++__r)
+		  _GLIBCXX_PARALLEL_ASSERT(__reserved_left[__r] == 1);
+		for (_DifferenceType __r = 0; __r < __leftover_right; ++__r)
+		  _GLIBCXX_PARALLEL_ASSERT(__reserved_right[__r] == 1);
+	      }
+#endif
+
+	      __left = __leftnew;
+	      __right = __rightnew;
+              __dist = __right - __left + 1;
+	    }
+
+#           pragma omp flush(__left, __right)
+	} // end "recursion" //parallel
+
+        _DifferenceType __final_left = __left, __final_right = __right;
+
+	while (__final_left < __final_right)
+	  {
+	    // Go right until key is geq than pivot.
+	    while (__pred(__begin[__final_left])
+		   && __final_left < __final_right)
+	      ++__final_left;
+
+	    // Go left until key is less than pivot.
+	    while (!__pred(__begin[__final_right])
+		   && __final_left < __final_right)
+	      --__final_right;
+
+	    if (__final_left == __final_right)
+	      break;
+	    std::iter_swap(__begin + __final_left, __begin + __final_right);
+	    ++__final_left;
+	    --__final_right;
+	  }
+
+	// All elements on the left side are < piv, all elements on the
+	// right are >= piv
+	delete[] __reserved_left;
+	delete[] __reserved_right;
+
+	// Element "between" __final_left and __final_right might not have
+	// been regarded yet
+	if (__final_left < __n && !__pred(__begin[__final_left]))
+	  // Really swapped.
+	  return __final_left;
+	else
+	  return __final_left + 1;
+    }
+
+  /**
+    *  @brief Parallel implementation of std::nth_element().
+    *  @param __begin Begin iterator of input sequence.
+    *  @param __nth _Iterator of element that must be in position afterwards.
+    *  @param __end End iterator of input sequence.
+    *  @param __comp Comparator.
+    */
+  template<typename _RAIter, typename _Compare>
+    void 
+    __parallel_nth_element(_RAIter __begin, _RAIter __nth, 
+			   _RAIter __end, _Compare __comp)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _GLIBCXX_CALL(__end - __begin)
+
+      _RAIter __split;
+      _RandomNumber __rng;
+
+      const _Settings& __s = _Settings::get();
+      _DifferenceType __minimum_length = std::max<_DifferenceType>(2,
+        std::max(__s.nth_element_minimal_n, __s.partition_minimal_n));
+
+      // Break if input range to small.
+      while (static_cast<_SequenceIndex>(__end - __begin) >= __minimum_length)
+	{
+          _DifferenceType __n = __end - __begin;
+
+          _RAIter __pivot_pos = __begin + __rng(__n);
+
+          // Swap __pivot_pos value to end.
+          if (__pivot_pos != (__end - 1))
+            std::iter_swap(__pivot_pos, __end - 1);
+          __pivot_pos = __end - 1;
+
+          // _Compare must have first_value_type, second_value_type,
+          // result_type
+          // _Compare ==
+          // __gnu_parallel::_Lexicographic<S, int,
+	  //                                __gnu_parallel::_Less<S, S> >
+          // __pivot_pos == std::pair<S, int>*
+          __gnu_parallel::__binder2nd<_Compare, _ValueType, _ValueType, bool>
+            __pred(__comp, *__pivot_pos);
+
+          // Divide, leave pivot unchanged in last place.
+          _RAIter __split_pos1, __split_pos2;
+          __split_pos1 = __begin + __parallel_partition(__begin, __end - 1,
+							__pred,
+							__get_max_threads());
+
+          // Left side: < __pivot_pos; __right side: >= __pivot_pos
+
+          // Swap pivot back to middle.
+          if (__split_pos1 != __pivot_pos)
+            std::iter_swap(__split_pos1, __pivot_pos);
+          __pivot_pos = __split_pos1;
+
+          // In case all elements are equal, __split_pos1 == 0
+          if ((__split_pos1 + 1 - __begin) < (__n >> 7)
+              || (__end - __split_pos1) < (__n >> 7))
+            {
+              // Very unequal split, one part smaller than one 128th
+              // elements not strictly larger than the pivot.
+              __gnu_parallel::__unary_negate<__gnu_parallel::
+        	__binder1st<_Compare, _ValueType,
+		            _ValueType, bool>, _ValueType>
+        	__pred(__gnu_parallel::__binder1st<_Compare, _ValueType,
+		       _ValueType, bool>(__comp, *__pivot_pos));
+
+              // Find other end of pivot-equal range.
+              __split_pos2 = __gnu_sequential::partition(__split_pos1 + 1,
+							 __end, __pred);
+            }
+          else
+            // Only skip the pivot.
+            __split_pos2 = __split_pos1 + 1;
+
+          // Compare iterators.
+          if (__split_pos2 <= __nth)
+            __begin = __split_pos2;
+          else if (__nth < __split_pos1)
+            __end = __split_pos1;
+          else
+            break;
+	}
+
+      // Only at most _Settings::partition_minimal_n __elements __left.
+      __gnu_sequential::nth_element(__begin, __nth, __end, __comp);
+    }
+
+  /** @brief Parallel implementation of std::partial_sort().
+  *  @param __begin Begin iterator of input sequence.
+  *  @param __middle Sort until this position.
+  *  @param __end End iterator of input sequence.
+  *  @param __comp Comparator. */
+  template<typename _RAIter, typename _Compare>
+    void
+    __parallel_partial_sort(_RAIter __begin,
+			    _RAIter __middle,
+			    _RAIter __end, _Compare __comp)
+    {
+      __parallel_nth_element(__begin, __middle, __end, __comp);
+      std::sort(__begin, __middle, __comp);
+    }
+
+} //namespace __gnu_parallel
+
+#undef _GLIBCXX_VOLATILE
+
+#endif /* _GLIBCXX_PARALLEL_PARTITION_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/queue.h b/gcc-4.9/libstdc++-v3/include/parallel/queue.h
new file mode 100644
index 0000000..d76edc4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/queue.h
@@ -0,0 +1,155 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/queue.h
+ *  @brief Lock-free double-ended queue.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_QUEUE_H
+#define _GLIBCXX_PARALLEL_QUEUE_H 1
+
+#include <parallel/types.h>
+#include <parallel/base.h>
+#include <parallel/compatibility.h>
+
+/** @brief Decide whether to declare certain variable volatile in this file. */
+#define _GLIBCXX_VOLATILE volatile
+
+namespace __gnu_parallel
+{
+  /**@brief Double-ended queue of bounded size, allowing lock-free
+   *  atomic access.  push_front() and pop_front() must not be called
+   *  concurrently to each other, while pop_back() can be called
+   *  concurrently at all times.
+   *  @c empty(), @c size(), and @c top() are intentionally not provided.
+   *  Calling them would not make sense in a concurrent setting.
+   *  @param _Tp Contained element type. */
+  template<typename _Tp>
+    class _RestrictedBoundedConcurrentQueue
+    {
+    private:
+      /** @brief Array of elements, seen as cyclic buffer. */
+      _Tp* _M_base;
+
+      /** @brief Maximal number of elements contained at the same time. */
+      _SequenceIndex _M_max_size;
+
+      /** @brief Cyclic __begin and __end pointers contained in one
+          atomically changeable value. */
+      _GLIBCXX_VOLATILE _CASable _M_borders;
+
+    public:
+      /** @brief Constructor. Not to be called concurrent, of course.
+       *  @param __max_size Maximal number of elements to be contained. */
+      _RestrictedBoundedConcurrentQueue(_SequenceIndex __max_size)
+      {
+        _M_max_size = __max_size;
+        _M_base = new _Tp[__max_size];
+        _M_borders = __encode2(0, 0);
+#pragma omp flush
+      }
+
+      /** @brief Destructor. Not to be called concurrent, of course. */
+      ~_RestrictedBoundedConcurrentQueue()
+      { delete[] _M_base; }
+
+      /** @brief Pushes one element into the queue at the front end.
+       *  Must not be called concurrently with pop_front(). */
+      void
+      push_front(const _Tp& __t)
+      {
+        _CASable __former_borders = _M_borders;
+        int __former_front, __former_back;
+        __decode2(__former_borders, __former_front, __former_back);
+        *(_M_base + __former_front % _M_max_size) = __t;
+#if _GLIBCXX_ASSERTIONS
+        // Otherwise: front - back > _M_max_size eventually.
+        _GLIBCXX_PARALLEL_ASSERT(((__former_front + 1) - __former_back)
+                                 <= _M_max_size);
+#endif
+        __fetch_and_add(&_M_borders, __encode2(1, 0));
+      }
+
+      /** @brief Pops one element from the queue at the front end.
+       *  Must not be called concurrently with pop_front(). */
+      bool
+      pop_front(_Tp& __t)
+      {
+        int __former_front, __former_back;
+#pragma omp flush
+        __decode2(_M_borders, __former_front, __former_back);
+        while (__former_front > __former_back)
+          {
+            // Chance.
+            _CASable __former_borders = __encode2(__former_front,
+						  __former_back);
+            _CASable __new_borders = __encode2(__former_front - 1,
+					       __former_back);
+            if (__compare_and_swap(&_M_borders, __former_borders,
+				   __new_borders))
+              {
+                __t = *(_M_base + (__former_front - 1) % _M_max_size);
+                return true;
+              }
+#pragma omp flush
+            __decode2(_M_borders, __former_front, __former_back);
+          }
+        return false;
+      }
+
+      /** @brief Pops one element from the queue at the front end.
+       *  Must not be called concurrently with pop_front(). */
+      bool
+      pop_back(_Tp& __t)        //queue behavior
+      {
+        int __former_front, __former_back;
+#pragma omp flush
+        __decode2(_M_borders, __former_front, __former_back);
+        while (__former_front > __former_back)
+          {
+            // Chance.
+            _CASable __former_borders = __encode2(__former_front,
+						  __former_back);
+            _CASable __new_borders = __encode2(__former_front,
+					       __former_back + 1);
+            if (__compare_and_swap(&_M_borders, __former_borders,
+				   __new_borders))
+              {
+                __t = *(_M_base + __former_back % _M_max_size);
+                return true;
+              }
+#pragma omp flush
+            __decode2(_M_borders, __former_front, __former_back);
+          }
+        return false;
+      }
+  };
+}       //namespace __gnu_parallel
+
+#undef _GLIBCXX_VOLATILE
+
+#endif /* _GLIBCXX_PARALLEL_QUEUE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/quicksort.h b/gcc-4.9/libstdc++-v3/include/parallel/quicksort.h
new file mode 100644
index 0000000..98150f8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/quicksort.h
@@ -0,0 +1,176 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/quicksort.h
+ *  @brief Implementation of a unbalanced parallel quicksort (in-place).
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_QUICKSORT_H
+#define _GLIBCXX_PARALLEL_QUICKSORT_H 1
+
+#include <parallel/parallel.h>
+#include <parallel/partition.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Unbalanced quicksort divide step.
+   *  @param __begin Begin iterator of subsequence.
+   *  @param __end End iterator of subsequence.
+   *  @param __comp Comparator.
+   *  @param __pivot_rank Desired __rank of the pivot.
+   *  @param __num_samples Choose pivot from that many samples.
+   *  @param __num_threads Number of threads that are allowed to work on
+   *  this part.
+   */
+  template<typename _RAIter, typename _Compare>
+    typename std::iterator_traits<_RAIter>::difference_type
+    __parallel_sort_qs_divide(_RAIter __begin, _RAIter __end,
+			      _Compare __comp, typename std::iterator_traits
+			      <_RAIter>::difference_type __pivot_rank,
+			      typename std::iterator_traits
+			      <_RAIter>::difference_type
+			      __num_samples, _ThreadIndex __num_threads)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __n = __end - __begin;
+      __num_samples = std::min(__num_samples, __n);
+
+      // Allocate uninitialized, to avoid default constructor.
+      _ValueType* __samples = static_cast<_ValueType*>
+	(::operator new(__num_samples * sizeof(_ValueType)));
+
+      for (_DifferenceType __s = 0; __s < __num_samples; ++__s)
+        {
+          const unsigned long long __index = static_cast<unsigned long long>
+	    (__s) * __n / __num_samples;
+          ::new(&(__samples[__s])) _ValueType(__begin[__index]);
+        }
+
+      __gnu_sequential::sort(__samples, __samples + __num_samples, __comp);
+
+      _ValueType& __pivot = __samples[__pivot_rank * __num_samples / __n];
+
+      __gnu_parallel::__binder2nd<_Compare, _ValueType, _ValueType, bool>
+        __pred(__comp, __pivot);
+      _DifferenceType __split = __parallel_partition(__begin, __end,
+						     __pred, __num_threads);
+
+      for (_DifferenceType __s = 0; __s < __num_samples; ++__s)
+	__samples[__s].~_ValueType();
+      ::operator delete(__samples);
+
+      return __split;
+    }
+
+  /** @brief Unbalanced quicksort conquer step.
+   *  @param __begin Begin iterator of subsequence.
+   *  @param __end End iterator of subsequence.
+   *  @param __comp Comparator.
+   *  @param __num_threads Number of threads that are allowed to work on
+   *  this part.
+   */
+  template<typename _RAIter, typename _Compare>
+    void
+    __parallel_sort_qs_conquer(_RAIter __begin, _RAIter __end,
+			       _Compare __comp,
+			       _ThreadIndex __num_threads)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      if (__num_threads <= 1)
+        {
+          __gnu_sequential::sort(__begin, __end, __comp);
+          return;
+        }
+
+      _DifferenceType __n = __end - __begin, __pivot_rank;
+
+      if (__n <= 1)
+        return;
+
+      _ThreadIndex __num_threads_left;
+
+      if ((__num_threads % 2) == 1)
+        __num_threads_left = __num_threads / 2 + 1;
+      else
+        __num_threads_left = __num_threads / 2;
+
+      __pivot_rank = __n * __num_threads_left / __num_threads;
+
+      _DifferenceType __split = __parallel_sort_qs_divide
+	(__begin, __end, __comp, __pivot_rank,
+	 _Settings::get().sort_qs_num_samples_preset, __num_threads);
+
+#pragma omp parallel sections num_threads(2)
+      {
+#pragma omp section
+        __parallel_sort_qs_conquer(__begin, __begin + __split,
+				   __comp, __num_threads_left);
+#pragma omp section
+        __parallel_sort_qs_conquer(__begin + __split, __end,
+				   __comp, __num_threads - __num_threads_left);
+      }
+    }
+
+
+  /** @brief Unbalanced quicksort main call.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator input sequence, ignored.
+   *  @param __comp Comparator.
+   *  @param __num_threads Number of threads that are allowed to work on
+   *  this part.
+   */
+  template<typename _RAIter, typename _Compare>
+    void
+    __parallel_sort_qs(_RAIter __begin, _RAIter __end,
+		       _Compare __comp,
+		       _ThreadIndex __num_threads)
+    {
+      _GLIBCXX_CALL(__n)
+
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __n = __end - __begin;
+
+      // At least one element per processor.
+      if (__num_threads > __n)
+        __num_threads = static_cast<_ThreadIndex>(__n);
+
+      __parallel_sort_qs_conquer(
+        __begin, __begin + __n, __comp, __num_threads);
+    }
+
+} //namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_QUICKSORT_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/random_number.h b/gcc-4.9/libstdc++-v3/include/parallel/random_number.h
new file mode 100644
index 0000000..7e51d8b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/random_number.h
@@ -0,0 +1,125 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/random_number.h
+ *  @brief Random number generator based on the Mersenne twister.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_RANDOM_NUMBER_H
+#define _GLIBCXX_PARALLEL_RANDOM_NUMBER_H 1
+
+#include <parallel/types.h>
+#include <tr1/random>
+#include <limits>
+
+namespace __gnu_parallel
+{
+  /** @brief Random number generator, based on the Mersenne twister. */
+  class _RandomNumber
+  {
+  private:
+    std::tr1::mt19937   _M_mt;
+    uint64_t            _M_supremum;
+    uint64_t            _M_rand_sup;
+    double              _M_supremum_reciprocal;
+    double              _M_rand_sup_reciprocal;
+
+    // Assumed to be twice as long as the usual random number.
+    uint64_t              __cache;
+
+    // Bit results.
+    int __bits_left;
+    
+    static uint32_t
+    __scale_down(uint64_t __x,
+#if _GLIBCXX_SCALE_DOWN_FPU
+               uint64_t /*_M_supremum*/, double _M_supremum_reciprocal)
+#else
+               uint64_t _M_supremum, double /*_M_supremum_reciprocal*/)
+#endif
+        {
+#if _GLIBCXX_SCALE_DOWN_FPU
+          return uint32_t(__x * _M_supremum_reciprocal);
+#else
+          return static_cast<uint32_t>(__x % _M_supremum);
+#endif
+        }
+
+  public:
+    /** @brief Default constructor. Seed with 0. */
+    _RandomNumber()
+    : _M_mt(0), _M_supremum(0x100000000ULL),
+      _M_rand_sup(1ULL << std::numeric_limits<uint32_t>::digits),
+      _M_supremum_reciprocal(double(_M_supremum) / double(_M_rand_sup)),
+      _M_rand_sup_reciprocal(1.0 / double(_M_rand_sup)),
+      __cache(0), __bits_left(0) { }
+
+    /** @brief Constructor.
+     *  @param __seed Random __seed.
+     *  @param _M_supremum Generate integer random numbers in the
+     *                  interval @c [0,_M_supremum). */
+    _RandomNumber(uint32_t __seed, uint64_t _M_supremum = 0x100000000ULL)
+    : _M_mt(__seed), _M_supremum(_M_supremum),
+      _M_rand_sup(1ULL << std::numeric_limits<uint32_t>::digits),
+      _M_supremum_reciprocal(double(_M_supremum) / double(_M_rand_sup)),
+      _M_rand_sup_reciprocal(1.0 / double(_M_rand_sup)),
+      __cache(0), __bits_left(0) { }
+
+    /** @brief Generate unsigned random 32-bit integer. */
+    uint32_t
+    operator()()
+    { return __scale_down(_M_mt(), _M_supremum, _M_supremum_reciprocal); }
+
+    /** @brief Generate unsigned random 32-bit integer in the
+        interval @c [0,local_supremum). */
+    uint32_t
+    operator()(uint64_t local_supremum)
+    {
+      return __scale_down(_M_mt(), local_supremum,
+                        double(local_supremum * _M_rand_sup_reciprocal));
+    }
+
+    /** @brief Generate a number of random bits, run-time parameter.
+     *  @param __bits Number of bits to generate. */
+    unsigned long
+    __genrand_bits(int __bits)
+    {
+      unsigned long __res = __cache & ((1 << __bits) - 1);
+      __cache = __cache >> __bits;
+      __bits_left -= __bits;
+      if (__bits_left < 32)
+        {
+          __cache |= ((uint64_t(_M_mt())) << __bits_left);
+          __bits_left += 32;
+        }
+      return __res;
+    }
+};
+
+} // namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_RANDOM_NUMBER_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/random_shuffle.h b/gcc-4.9/libstdc++-v3/include/parallel/random_shuffle.h
new file mode 100644
index 0000000..27c023c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/random_shuffle.h
@@ -0,0 +1,533 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/random_shuffle.h
+ *  @brief Parallel implementation of std::random_shuffle().
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_RANDOM_SHUFFLE_H
+#define _GLIBCXX_PARALLEL_RANDOM_SHUFFLE_H 1
+
+#include <limits>
+#include <bits/stl_numeric.h>
+#include <parallel/parallel.h>
+#include <parallel/random_number.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Type to hold the index of a bin.
+    *
+    *  Since many variables of this type are allocated, it should be
+    *  chosen as small as possible.
+    */
+  typedef unsigned short _BinIndex;
+
+  /** @brief Data known to every thread participating in
+      __gnu_parallel::__parallel_random_shuffle(). */
+  template<typename _RAIter>
+    struct _DRandomShufflingGlobalData
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      /** @brief Begin iterator of the __source. */
+      _RAIter& _M_source;
+
+      /** @brief Temporary arrays for each thread. */
+      _ValueType** _M_temporaries;
+
+      /** @brief Two-dimensional array to hold the thread-bin distribution.
+       *
+       *  Dimensions (_M_num_threads + 1) __x (_M_num_bins + 1). */
+      _DifferenceType** _M_dist;
+
+      /** @brief Start indexes of the threads' __chunks. */
+      _DifferenceType* _M_starts;
+
+      /** @brief Number of the thread that will further process the
+          corresponding bin. */
+      _ThreadIndex* _M_bin_proc;
+
+      /** @brief Number of bins to distribute to. */
+      int _M_num_bins;
+
+      /** @brief Number of bits needed to address the bins. */
+      int _M_num_bits;
+
+      /** @brief Constructor. */
+      _DRandomShufflingGlobalData(_RAIter& __source)
+      : _M_source(__source) { }
+    };
+
+  /** @brief Local data for a thread participating in
+      __gnu_parallel::__parallel_random_shuffle().
+    */
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    struct _DRSSorterPU
+    {
+      /** @brief Number of threads participating in total. */
+      int _M_num_threads;
+
+      /** @brief Begin index for bins taken care of by this thread. */
+      _BinIndex _M_bins_begin;
+
+      /** @brief End index for bins taken care of by this thread. */
+      _BinIndex __bins_end;
+
+      /** @brief Random _M_seed for this thread. */
+      uint32_t _M_seed;
+
+      /** @brief Pointer to global data. */
+      _DRandomShufflingGlobalData<_RAIter>* _M_sd;
+    };
+
+  /** @brief Generate a random number in @c [0,2^__logp).
+    *  @param __logp Logarithm (basis 2) of the upper range __bound.
+    *  @param __rng Random number generator to use.
+    */
+  template<typename _RandomNumberGenerator>
+    inline int
+    __random_number_pow2(int __logp, _RandomNumberGenerator& __rng)
+    { return __rng.__genrand_bits(__logp); }
+
+  /** @brief Random shuffle code executed by each thread.
+    *  @param __pus Array of thread-local data records. */
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    void 
+    __parallel_random_shuffle_drs_pu(_DRSSorterPU<_RAIter,
+				     _RandomNumberGenerator>* __pus)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _ThreadIndex __iam = omp_get_thread_num();
+      _DRSSorterPU<_RAIter, _RandomNumberGenerator>* __d = &__pus[__iam];
+      _DRandomShufflingGlobalData<_RAIter>* __sd = __d->_M_sd;
+
+      // Indexing: _M_dist[bin][processor]
+      _DifferenceType __length = (__sd->_M_starts[__iam + 1]
+				  - __sd->_M_starts[__iam]);
+      _BinIndex* __oracles = new _BinIndex[__length];
+      _DifferenceType* __dist = new _DifferenceType[__sd->_M_num_bins + 1];
+      _BinIndex* __bin_proc = new _BinIndex[__sd->_M_num_bins];
+      _ValueType** __temporaries = new _ValueType*[__d->_M_num_threads];
+
+      // Compute oracles and count appearances.
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins + 1; ++__b)
+	__dist[__b] = 0;
+      int __num_bits = __sd->_M_num_bits;
+
+      _RandomNumber __rng(__d->_M_seed);
+
+      // First main loop.
+      for (_DifferenceType __i = 0; __i < __length; ++__i)
+	{
+          _BinIndex __oracle = __random_number_pow2(__num_bits, __rng);
+          __oracles[__i] = __oracle;
+
+          // To allow prefix (partial) sum.
+          ++(__dist[__oracle + 1]);
+	}
+
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins + 1; ++__b)
+	__sd->_M_dist[__b][__iam + 1] = __dist[__b];
+
+#     pragma omp barrier
+
+#     pragma omp single
+      {
+	// Sum up bins, __sd->_M_dist[__s + 1][__d->_M_num_threads] now
+	// contains the total number of items in bin __s
+	for (_BinIndex __s = 0; __s < __sd->_M_num_bins; ++__s)
+          __gnu_sequential::partial_sum(__sd->_M_dist[__s + 1],
+					__sd->_M_dist[__s + 1]
+					+ __d->_M_num_threads + 1,
+					__sd->_M_dist[__s + 1]);
+      }
+
+#     pragma omp barrier
+
+      _SequenceIndex __offset = 0, __global_offset = 0;
+      for (_BinIndex __s = 0; __s < __d->_M_bins_begin; ++__s)
+	__global_offset += __sd->_M_dist[__s + 1][__d->_M_num_threads];
+
+#     pragma omp barrier
+
+      for (_BinIndex __s = __d->_M_bins_begin; __s < __d->__bins_end; ++__s)
+	{
+          for (int __t = 0; __t < __d->_M_num_threads + 1; ++__t)
+            __sd->_M_dist[__s + 1][__t] += __offset;
+          __offset = __sd->_M_dist[__s + 1][__d->_M_num_threads];
+	}
+
+      __sd->_M_temporaries[__iam] = static_cast<_ValueType*>
+	(::operator new(sizeof(_ValueType) * __offset));
+
+#     pragma omp barrier
+
+      // Draw local copies to avoid false sharing.
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins + 1; ++__b)
+	__dist[__b] = __sd->_M_dist[__b][__iam];
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins; ++__b)
+	__bin_proc[__b] = __sd->_M_bin_proc[__b];
+      for (_ThreadIndex __t = 0; __t < __d->_M_num_threads; ++__t)
+	__temporaries[__t] = __sd->_M_temporaries[__t];
+
+      _RAIter __source = __sd->_M_source;
+      _DifferenceType __start = __sd->_M_starts[__iam];
+
+      // Distribute according to oracles, second main loop.
+      for (_DifferenceType __i = 0; __i < __length; ++__i)
+	{
+          _BinIndex __target_bin = __oracles[__i];
+          _ThreadIndex __target_p = __bin_proc[__target_bin];
+
+          // Last column [__d->_M_num_threads] stays unchanged.
+	  ::new(&(__temporaries[__target_p][__dist[__target_bin + 1]++]))
+              _ValueType(*(__source + __i + __start));
+	}
+
+      delete[] __oracles;
+      delete[] __dist;
+      delete[] __bin_proc;
+      delete[] __temporaries;
+
+#     pragma omp barrier
+
+      // Shuffle bins internally.
+      for (_BinIndex __b = __d->_M_bins_begin; __b < __d->__bins_end; ++__b)
+	{
+          _ValueType* __begin =
+	    (__sd->_M_temporaries[__iam]
+	     + (__b == __d->_M_bins_begin
+		? 0 : __sd->_M_dist[__b][__d->_M_num_threads])),
+	    *__end = (__sd->_M_temporaries[__iam]
+		      + __sd->_M_dist[__b + 1][__d->_M_num_threads]);
+
+          __sequential_random_shuffle(__begin, __end, __rng);
+          std::copy(__begin, __end, __sd->_M_source + __global_offset
+		    + (__b == __d->_M_bins_begin
+		       ? 0 : __sd->_M_dist[__b][__d->_M_num_threads]));
+	}
+
+      for (_SequenceIndex __i = 0; __i < __offset; ++__i)
+	__sd->_M_temporaries[__iam][__i].~_ValueType();
+      ::operator delete(__sd->_M_temporaries[__iam]);
+    }
+
+  /** @brief Round up to the next greater power of 2.
+    *  @param __x _Integer to round up */
+  template<typename _Tp>
+    _Tp 
+    __round_up_to_pow2(_Tp __x)
+    {
+      if (__x <= 1)
+	return 1;
+      else
+	return (_Tp)1 << (__rd_log2(__x - 1) + 1);
+    }
+
+  /** @brief Main parallel random shuffle step.
+    *  @param __begin Begin iterator of sequence.
+    *  @param __end End iterator of sequence.
+    *  @param __n Length of sequence.
+    *  @param __num_threads Number of threads to use.
+    *  @param __rng Random number generator to use.
+    */
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    void
+    __parallel_random_shuffle_drs(_RAIter __begin, _RAIter __end,
+				  typename std::iterator_traits
+				  <_RAIter>::difference_type __n,
+				  _ThreadIndex __num_threads,
+				  _RandomNumberGenerator& __rng)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _GLIBCXX_CALL(__n)
+
+      const _Settings& __s = _Settings::get();
+
+      if (__num_threads > __n)
+	__num_threads = static_cast<_ThreadIndex>(__n);
+
+      _BinIndex __num_bins, __num_bins_cache;
+
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
+      // Try the L1 cache first.
+
+      // Must fit into L1.
+      __num_bins_cache =
+	std::max<_DifferenceType>(1, __n / (__s.L1_cache_size_lb
+					    / sizeof(_ValueType)));
+      __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
+
+      // No more buckets than TLB entries, power of 2
+      // Power of 2 and at least one element per bin, at most the TLB size.
+      __num_bins = std::min<_DifferenceType>(__n, __num_bins_cache);
+
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
+      // 2 TLB entries needed per bin.
+      __num_bins = std::min<_DifferenceType>(__s.TLB_size / 2, __num_bins);
+#endif
+      __num_bins = __round_up_to_pow2(__num_bins);
+
+      if (__num_bins < __num_bins_cache)
+	{
+#endif
+          // Now try the L2 cache
+          // Must fit into L2
+          __num_bins_cache = static_cast<_BinIndex>
+	    (std::max<_DifferenceType>(1, __n / (__s.L2_cache_size
+						 / sizeof(_ValueType))));
+          __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
+
+          // No more buckets than TLB entries, power of 2.
+          __num_bins = static_cast<_BinIndex>
+	    (std::min(__n, static_cast<_DifferenceType>(__num_bins_cache)));
+          // Power of 2 and at least one element per bin, at most the TLB size.
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
+          // 2 TLB entries needed per bin.
+          __num_bins = std::min(static_cast<_DifferenceType>(__s.TLB_size / 2),
+				__num_bins);
+#endif
+            __num_bins = __round_up_to_pow2(__num_bins);
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
+	}
+#endif
+
+      __num_bins = __round_up_to_pow2(
+                        std::max<_BinIndex>(__num_threads, __num_bins));
+
+      if (__num_threads <= 1)
+      {
+        _RandomNumber __derived_rng(
+                            __rng(std::numeric_limits<uint32_t>::max()));
+	__sequential_random_shuffle(__begin, __end, __derived_rng);
+        return;
+      }
+
+      _DRandomShufflingGlobalData<_RAIter> __sd(__begin);
+      _DRSSorterPU<_RAIter, _RandomNumber >* __pus;
+      _DifferenceType* __starts;
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+	_ThreadIndex __num_threads = omp_get_num_threads();
+#       pragma omp single
+	{
+	  __pus = new _DRSSorterPU<_RAIter, _RandomNumber>[__num_threads];
+	  
+	  __sd._M_temporaries = new _ValueType*[__num_threads];
+	  __sd._M_dist = new _DifferenceType*[__num_bins + 1];
+	  __sd._M_bin_proc = new _ThreadIndex[__num_bins];
+	  for (_BinIndex __b = 0; __b < __num_bins + 1; ++__b)
+	    __sd._M_dist[__b] = new _DifferenceType[__num_threads + 1];
+	  for (_BinIndex __b = 0; __b < (__num_bins + 1); ++__b)
+	    {
+	      __sd._M_dist[0][0] = 0;
+	      __sd._M_dist[__b][0] = 0;
+	    }
+	  __starts = __sd._M_starts = new _DifferenceType[__num_threads + 1];
+	  int __bin_cursor = 0;
+	  __sd._M_num_bins = __num_bins;
+	  __sd._M_num_bits = __rd_log2(__num_bins);
+
+	  _DifferenceType __chunk_length = __n / __num_threads,
+	                         __split = __n % __num_threads,
+	                         __start = 0;
+	  _DifferenceType __bin_chunk_length = __num_bins / __num_threads,
+	                         __bin_split = __num_bins % __num_threads;
+	  for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	    {
+	      __starts[__i] = __start;
+	      __start += (__i < __split
+			  ? (__chunk_length + 1) : __chunk_length);
+	      int __j = __pus[__i]._M_bins_begin = __bin_cursor;
+
+	      // Range of bins for this processor.
+	      __bin_cursor += (__i < __bin_split
+			       ? (__bin_chunk_length + 1)
+			       : __bin_chunk_length);
+	      __pus[__i].__bins_end = __bin_cursor;
+	      for (; __j < __bin_cursor; ++__j)
+		__sd._M_bin_proc[__j] = __i;
+	      __pus[__i]._M_num_threads = __num_threads;
+	      __pus[__i]._M_seed = __rng(std::numeric_limits<uint32_t>::max());
+	      __pus[__i]._M_sd = &__sd;
+	    }
+	  __starts[__num_threads] = __start;
+	} //single
+          // Now shuffle in parallel.
+	__parallel_random_shuffle_drs_pu(__pus);
+      }  // parallel
+
+      delete[] __starts;
+      delete[] __sd._M_bin_proc;
+      for (int __s = 0; __s < (__num_bins + 1); ++__s)
+	delete[] __sd._M_dist[__s];
+      delete[] __sd._M_dist;
+      delete[] __sd._M_temporaries;
+
+      delete[] __pus;
+    }
+
+  /** @brief Sequential cache-efficient random shuffle.
+   *  @param __begin Begin iterator of sequence.
+   *  @param __end End iterator of sequence.
+   *  @param __rng Random number generator to use.
+   */
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    void
+    __sequential_random_shuffle(_RAIter __begin, _RAIter __end,
+				_RandomNumberGenerator& __rng)
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __n = __end - __begin;
+      const _Settings& __s = _Settings::get();
+
+      _BinIndex __num_bins, __num_bins_cache;
+
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
+      // Try the L1 cache first, must fit into L1.
+      __num_bins_cache = std::max<_DifferenceType>
+	(1, __n / (__s.L1_cache_size_lb / sizeof(_ValueType)));
+      __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
+
+      // No more buckets than TLB entries, power of 2
+      // Power of 2 and at least one element per bin, at most the TLB size
+      __num_bins = std::min(__n, (_DifferenceType)__num_bins_cache);
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
+      // 2 TLB entries needed per bin
+      __num_bins = std::min((_DifferenceType)__s.TLB_size / 2, __num_bins);
+#endif
+      __num_bins = __round_up_to_pow2(__num_bins);
+
+      if (__num_bins < __num_bins_cache)
+	{
+#endif
+          // Now try the L2 cache, must fit into L2.
+          __num_bins_cache = static_cast<_BinIndex>
+	    (std::max<_DifferenceType>(1, __n / (__s.L2_cache_size
+						 / sizeof(_ValueType))));
+          __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
+
+          // No more buckets than TLB entries, power of 2
+          // Power of 2 and at least one element per bin, at most the TLB size.
+          __num_bins = static_cast<_BinIndex>
+	    (std::min(__n, static_cast<_DifferenceType>(__num_bins_cache)));
+
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
+          // 2 TLB entries needed per bin
+          __num_bins = std::min<_DifferenceType>(__s.TLB_size / 2, __num_bins);
+#endif
+          __num_bins = __round_up_to_pow2(__num_bins);
+#if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
+	}
+#endif
+
+      int __num_bits = __rd_log2(__num_bins);
+
+      if (__num_bins > 1)
+	{
+          _ValueType* __target =
+	    static_cast<_ValueType*>(::operator new(sizeof(_ValueType) * __n));
+          _BinIndex* __oracles = new _BinIndex[__n];
+          _DifferenceType* __dist0 = new _DifferenceType[__num_bins + 1],
+                	 * __dist1 = new _DifferenceType[__num_bins + 1];
+
+          for (int __b = 0; __b < __num_bins + 1; ++__b)
+            __dist0[__b] = 0;
+
+          _RandomNumber __bitrng(__rng(0xFFFFFFFF));
+
+          for (_DifferenceType __i = 0; __i < __n; ++__i)
+            {
+              _BinIndex __oracle = __random_number_pow2(__num_bits, __bitrng);
+              __oracles[__i] = __oracle;
+
+              // To allow prefix (partial) sum.
+              ++(__dist0[__oracle + 1]);
+            }
+
+          // Sum up bins.
+          __gnu_sequential::partial_sum(__dist0, __dist0 + __num_bins + 1,
+					__dist0);
+
+          for (int __b = 0; __b < __num_bins + 1; ++__b)
+            __dist1[__b] = __dist0[__b];
+
+          // Distribute according to oracles.
+          for (_DifferenceType __i = 0; __i < __n; ++__i)
+            ::new(&(__target[(__dist0[__oracles[__i]])++])) 
+		_ValueType(*(__begin + __i));
+
+          for (int __b = 0; __b < __num_bins; ++__b)
+	    __sequential_random_shuffle(__target + __dist1[__b],
+					__target + __dist1[__b + 1], __rng);
+
+          // Copy elements back.
+          std::copy(__target, __target + __n, __begin);
+
+          delete[] __dist0;
+          delete[] __dist1;
+          delete[] __oracles;
+	  
+	  for (_DifferenceType __i = 0; __i < __n; ++__i)
+	    __target[__i].~_ValueType();
+          ::operator delete(__target);
+	}
+      else
+	__gnu_sequential::random_shuffle(__begin, __end, __rng);
+    }
+
+  /** @brief Parallel random public call.
+   *  @param __begin Begin iterator of sequence.
+   *  @param __end End iterator of sequence.
+   *  @param __rng Random number generator to use.
+   */
+  template<typename _RAIter, typename _RandomNumberGenerator>
+    inline void
+    __parallel_random_shuffle(_RAIter __begin, _RAIter __end,
+			      _RandomNumberGenerator __rng = _RandomNumber())
+    {
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      _DifferenceType __n = __end - __begin;
+      __parallel_random_shuffle_drs(__begin, __end, __n,
+				    __get_max_threads(), __rng);
+    }
+}
+
+#endif /* _GLIBCXX_PARALLEL_RANDOM_SHUFFLE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/search.h b/gcc-4.9/libstdc++-v3/include/parallel/search.h
new file mode 100644
index 0000000..092422d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/search.h
@@ -0,0 +1,172 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/search.h
+ *  @brief Parallel implementation base for std::search() and
+ *  std::search_n().
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_SEARCH_H
+#define _GLIBCXX_PARALLEL_SEARCH_H 1
+
+#include <bits/stl_algobase.h>
+
+#include <parallel/parallel.h>
+#include <parallel/equally_split.h>
+
+namespace __gnu_parallel
+{
+  /**
+   *  @brief Precalculate __advances for Knuth-Morris-Pratt algorithm.
+   *  @param __elements Begin iterator of sequence to search for.
+   *  @param __length Length of sequence to search for.
+   *  @param __off Returned __offsets. 
+   */
+  template<typename _RAIter, typename _DifferenceTp>
+    void
+    __calc_borders(_RAIter __elements, _DifferenceTp __length, 
+		   _DifferenceTp* __off)
+    {
+      typedef _DifferenceTp _DifferenceType;
+
+      __off[0] = -1;
+      if (__length > 1)
+	__off[1] = 0;
+      _DifferenceType __k = 0;
+      for (_DifferenceType __j = 2; __j <= __length; __j++)
+	{
+          while ((__k >= 0) && !(__elements[__k] == __elements[__j-1]))
+            __k = __off[__k];
+          __off[__j] = ++__k;
+	}
+    }
+
+  // Generic parallel find algorithm (requires random access iterator).
+
+  /** @brief Parallel std::search.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence.
+   *  @param __end2 End iterator of second sequence.
+   *  @param __pred Find predicate.
+   *  @return Place of finding in first sequences. */
+  template<typename __RAIter1,
+           typename __RAIter2,
+           typename _Pred>
+    __RAIter1
+    __search_template(__RAIter1 __begin1, __RAIter1 __end1,
+		      __RAIter2 __begin2, __RAIter2 __end2,
+		      _Pred __pred)
+    {
+      typedef std::iterator_traits<__RAIter1> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _GLIBCXX_CALL((__end1 - __begin1) + (__end2 - __begin2));
+
+      _DifferenceType __pattern_length = __end2 - __begin2;
+
+      // Pattern too short.
+      if(__pattern_length <= 0)
+	return __end1;
+
+      // Last point to start search.
+      _DifferenceType __input_length = (__end1 - __begin1) - __pattern_length;
+
+      // Where is first occurrence of pattern? defaults to end.
+      _DifferenceType __result = (__end1 - __begin1);
+      _DifferenceType *__splitters;
+
+      // Pattern too long.
+      if (__input_length < 0)
+	return __end1;
+
+      omp_lock_t __result_lock;
+      omp_init_lock(&__result_lock);
+
+      _ThreadIndex __num_threads = std::max<_DifferenceType>
+	(1, std::min<_DifferenceType>(__input_length,
+				      __get_max_threads()));
+
+      _DifferenceType __advances[__pattern_length];
+      __calc_borders(__begin2, __pattern_length, __advances);
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+	  __splitters = new _DifferenceType[__num_threads + 1];
+	  __equally_split(__input_length, __num_threads, __splitters);
+	}
+
+	_ThreadIndex __iam = omp_get_thread_num();
+
+	_DifferenceType __start = __splitters[__iam],
+	                 __stop = __splitters[__iam + 1];
+
+	_DifferenceType __pos_in_pattern = 0;
+	bool __found_pattern = false;
+
+	while (__start <= __stop && !__found_pattern)
+	  {
+	    // Get new value of result.
+#pragma omp flush(__result)
+	    // No chance for this thread to find first occurrence.
+	    if (__result < __start)
+	      break;
+	    while (__pred(__begin1[__start + __pos_in_pattern],
+			  __begin2[__pos_in_pattern]))
+	      {
+		++__pos_in_pattern;
+		if (__pos_in_pattern == __pattern_length)
+		  {
+		    // Found new candidate for result.
+		    omp_set_lock(&__result_lock);
+		    __result = std::min(__result, __start);
+		    omp_unset_lock(&__result_lock);
+
+		    __found_pattern = true;
+		    break;
+		  }
+	      }
+	    // Make safe jump.
+	    __start += (__pos_in_pattern - __advances[__pos_in_pattern]);
+	    __pos_in_pattern = (__advances[__pos_in_pattern] < 0
+				? 0 : __advances[__pos_in_pattern]);
+	  }
+      } //parallel
+
+      omp_destroy_lock(&__result_lock);
+
+      delete[] __splitters;
+      
+      // Return iterator on found element.
+      return (__begin1 + __result);
+    }
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_SEARCH_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/set_operations.h b/gcc-4.9/libstdc++-v3/include/parallel/set_operations.h
new file mode 100644
index 0000000..5018ef4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/set_operations.h
@@ -0,0 +1,529 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file parallel/set_operations.h
+ * @brief Parallel implementations of set operations for random-access
+ * iterators.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Marius Elvert and Felix Bondarenko.
+
+#ifndef _GLIBCXX_PARALLEL_SET_OPERATIONS_H
+#define _GLIBCXX_PARALLEL_SET_OPERATIONS_H 1
+
+#include <omp.h>
+
+#include <parallel/settings.h>
+#include <parallel/multiseq_selection.h>
+
+namespace __gnu_parallel
+{
+  template<typename _IIter, typename _OutputIterator>
+    _OutputIterator
+    __copy_tail(std::pair<_IIter, _IIter> __b,
+		std::pair<_IIter, _IIter> __e, _OutputIterator __r)
+    {
+      if (__b.first != __e.first)
+	{
+          do
+            {
+              *__r++ = *__b.first++;
+            }
+          while (__b.first != __e.first);
+	}
+      else
+	{
+          while (__b.second != __e.second)
+            *__r++ = *__b.second++;
+	}
+      return __r;
+    }
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Compare>
+    struct __symmetric_difference_func
+    {
+      typedef std::iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef typename std::pair<_IIter, _IIter> _IteratorPair;
+
+      __symmetric_difference_func(_Compare __comp) : _M_comp(__comp) {}
+
+      _Compare _M_comp;
+
+      _OutputIterator
+      _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter __d,
+		_OutputIterator __r) const
+      {
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              {
+        	*__r = *__a;
+        	++__a;
+        	++__r;
+              }
+            else if (_M_comp(*__c, *__a))
+              {
+        	*__r = *__c;
+        	++__c;
+        	++__r;
+              }
+            else
+              {
+        	++__a;
+        	++__c;
+              }
+          }
+	return std::copy(__c, __d, std::copy(__a, __b, __r));
+      }
+
+      _DifferenceType
+      __count(_IIter __a, _IIter __b, _IIter __c, _IIter __d) const
+      {
+	_DifferenceType __counter = 0;
+
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              {
+        	++__a;
+        	++__counter;
+              }
+            else if (_M_comp(*__c, *__a))
+              {
+        	++__c;
+        	++__counter;
+              }
+            else
+              {
+        	++__a;
+        	++__c;
+              }
+          }
+
+	return __counter + (__b - __a) + (__d - __c);
+      }
+
+      _OutputIterator
+      __first_empty(_IIter __c, _IIter __d, _OutputIterator __out) const
+      { return std::copy(__c, __d, __out); }
+
+      _OutputIterator
+      __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+      { return std::copy(__a, __b, __out); }
+    };
+
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Compare>
+    struct __difference_func
+    {
+      typedef std::iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef typename std::pair<_IIter, _IIter> _IteratorPair;
+
+      __difference_func(_Compare __comp) : _M_comp(__comp) {}
+
+      _Compare _M_comp;
+
+      _OutputIterator
+      _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter __d,
+		_OutputIterator __r) const
+      {
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              {
+        	*__r = *__a;
+        	++__a;
+        	++__r;
+              }
+            else if (_M_comp(*__c, *__a))
+              { ++__c; }
+            else
+              {
+        	++__a;
+        	++__c;
+              }
+          }
+	return std::copy(__a, __b, __r);
+      }
+
+      _DifferenceType
+      __count(_IIter __a, _IIter __b,
+	      _IIter __c, _IIter __d) const
+      {
+	_DifferenceType __counter = 0;
+
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              {
+        	++__a;
+        	++__counter;
+              }
+            else if (_M_comp(*__c, *__a))
+              { ++__c; }
+            else
+              { ++__a; ++__c; }
+          }
+
+	return __counter + (__b - __a);
+      }
+
+      _OutputIterator
+      __first_empty(_IIter, _IIter, _OutputIterator __out) const
+      { return __out; }
+
+      _OutputIterator
+      __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+      { return std::copy(__a, __b, __out); }
+    };
+
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Compare>
+    struct __intersection_func
+    {
+      typedef std::iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef typename std::pair<_IIter, _IIter> _IteratorPair;
+
+      __intersection_func(_Compare __comp) : _M_comp(__comp) {}
+
+      _Compare _M_comp;
+
+      _OutputIterator
+      _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter __d,
+		_OutputIterator __r) const
+      {
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              { ++__a; }
+            else if (_M_comp(*__c, *__a))
+              { ++__c; }
+            else
+              {
+        	*__r = *__a;
+        	++__a;
+        	++__c;
+        	++__r;
+              }
+          }
+
+	return __r;
+      }
+
+      _DifferenceType
+      __count(_IIter __a, _IIter __b, _IIter __c, _IIter __d) const
+      {
+	_DifferenceType __counter = 0;
+
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              { ++__a; }
+            else if (_M_comp(*__c, *__a))
+              { ++__c; }
+            else
+              {
+        	++__a;
+        	++__c;
+        	++__counter;
+              }
+          }
+
+	return __counter;
+      }
+
+      _OutputIterator
+      __first_empty(_IIter, _IIter, _OutputIterator __out) const
+      { return __out; }
+
+      _OutputIterator
+      __second_empty(_IIter, _IIter, _OutputIterator __out) const
+      { return __out; }
+    };
+
+  template<class _IIter, class _OutputIterator, class _Compare>
+    struct __union_func
+    {
+      typedef typename std::iterator_traits<_IIter>::difference_type
+      _DifferenceType;
+
+      __union_func(_Compare __comp) : _M_comp(__comp) {}
+
+      _Compare _M_comp;
+
+      _OutputIterator
+      _M_invoke(_IIter __a, const _IIter __b, _IIter __c,
+		const _IIter __d, _OutputIterator __r) const
+      {
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              {
+        	*__r = *__a;
+        	++__a;
+              }
+            else if (_M_comp(*__c, *__a))
+              {
+        	*__r = *__c;
+        	++__c;
+              }
+            else
+              {
+        	*__r = *__a;
+        	++__a;
+        	++__c;
+              }
+            ++__r;
+          }
+	return std::copy(__c, __d, std::copy(__a, __b, __r));
+      }
+
+      _DifferenceType
+      __count(_IIter __a, _IIter __b, _IIter __c, _IIter __d) const
+      {
+	_DifferenceType __counter = 0;
+
+	while (__a != __b && __c != __d)
+          {
+            if (_M_comp(*__a, *__c))
+              { ++__a; }
+            else if (_M_comp(*__c, *__a))
+              { ++__c; }
+            else
+              {
+        	++__a;
+        	++__c;
+              }
+            ++__counter;
+          }
+
+	__counter += (__b - __a);
+	__counter += (__d - __c);
+	return __counter;
+      }
+
+      _OutputIterator
+      __first_empty(_IIter __c, _IIter __d, _OutputIterator __out) const
+      { return std::copy(__c, __d, __out); }
+
+      _OutputIterator
+      __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+      { return std::copy(__a, __b, __out); }
+    };
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Operation>
+    _OutputIterator
+    __parallel_set_operation(_IIter __begin1, _IIter __end1,
+			     _IIter __begin2, _IIter __end2,
+			     _OutputIterator __result, _Operation __op)
+    {
+      _GLIBCXX_CALL((__end1 - __begin1) + (__end2 - __begin2))
+
+      typedef std::iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef typename std::pair<_IIter, _IIter> _IteratorPair;
+
+      if (__begin1 == __end1)
+	return __op.__first_empty(__begin2, __end2, __result);
+
+      if (__begin2 == __end2)
+	return __op.__second_empty(__begin1, __end1, __result);
+
+      const _DifferenceType __size = (__end1 - __begin1) + (__end2 - __begin2);
+
+      const _IteratorPair __sequence[2] = { std::make_pair(__begin1, __end1),
+					    std::make_pair(__begin2, __end2) };
+      _OutputIterator __return_value = __result;
+      _DifferenceType *__borders;
+      _IteratorPair *__block_begins;
+      _DifferenceType* __lengths;
+
+      _ThreadIndex __num_threads =
+          std::min<_DifferenceType>(__get_max_threads(),
+              std::min(__end1 - __begin1, __end2 - __begin2));
+
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+
+	  __borders = new _DifferenceType[__num_threads + 2];
+	  __equally_split(__size, __num_threads + 1, __borders);
+	  __block_begins = new _IteratorPair[__num_threads + 1];
+	  // Very __start.
+	  __block_begins[0] = std::make_pair(__begin1, __begin2);
+	  __lengths = new _DifferenceType[__num_threads];
+	} //single
+
+	_ThreadIndex __iam = omp_get_thread_num();
+
+	// _Result from multiseq_partition.
+	_IIter __offset[2];
+	const _DifferenceType __rank = __borders[__iam + 1];
+
+	multiseq_partition(__sequence, __sequence + 2,
+			   __rank, __offset, __op._M_comp);
+
+	// allowed to read?
+	// together
+	// *(__offset[ 0 ] - 1) == *__offset[ 1 ]
+	if (__offset[ 0 ] != __begin1 && __offset[1] != __end2
+	    && !__op._M_comp(*(__offset[0] - 1), *__offset[1])
+	    && !__op._M_comp(*__offset[1], *(__offset[0] - 1)))
+	  {
+	    // Avoid split between globally equal elements: move one to
+	    // front in first sequence.
+              --__offset[0];
+	  }
+
+	_IteratorPair __block_end = __block_begins[__iam + 1] =
+	  _IteratorPair(__offset[0], __offset[1]);
+
+	// Make sure all threads have their block_begin result written out.
+#       pragma omp barrier
+
+	_IteratorPair __block_begin = __block_begins[__iam];
+
+	// Begin working for the first block, while the others except
+	// the last start to count.
+	if (__iam == 0)
+	  {
+	    // The first thread can copy already.
+	    __lengths[ __iam ] =
+	      __op._M_invoke(__block_begin.first, __block_end.first,
+			     __block_begin.second, __block_end.second,
+			     __result) - __result;
+	  }
+	else
+	  {
+	    __lengths[ __iam ] =
+	      __op.__count(__block_begin.first, __block_end.first,
+			   __block_begin.second, __block_end.second);
+	  }
+
+	// Make sure everyone wrote their lengths.
+#       pragma omp barrier
+
+	_OutputIterator __r = __result;
+
+	if (__iam == 0)
+	  {
+	    // Do the last block.
+	    for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+	      __r += __lengths[__i];
+
+	    __block_begin = __block_begins[__num_threads];
+
+	    // Return the result iterator of the last block.
+	    __return_value =
+	      __op._M_invoke(__block_begin.first, __end1,
+			     __block_begin.second, __end2, __r);
+
+	  }
+          else
+            {
+              for (_ThreadIndex __i = 0; __i < __iam; ++__i)
+        	__r += __lengths[ __i ];
+
+              // Reset begins for copy pass.
+              __op._M_invoke(__block_begin.first, __block_end.first,
+			     __block_begin.second, __block_end.second, __r);
+            }
+	}
+      return __return_value;
+    }
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Compare>
+    inline _OutputIterator
+    __parallel_set_union(_IIter __begin1, _IIter __end1,
+			 _IIter __begin2, _IIter __end2,
+			 _OutputIterator __result, _Compare __comp)
+    {
+      return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
+				      __result,
+				      __union_func< _IIter, _OutputIterator,
+				      _Compare>(__comp));
+    }
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Compare>
+    inline _OutputIterator
+    __parallel_set_intersection(_IIter __begin1, _IIter __end1,
+                        	_IIter __begin2, _IIter __end2,
+                        	_OutputIterator __result, _Compare __comp)
+    {
+      return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
+				      __result,
+				      __intersection_func<_IIter,
+				      _OutputIterator, _Compare>(__comp));
+    }
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Compare>
+    inline _OutputIterator
+    __parallel_set_difference(_IIter __begin1, _IIter __end1,
+                              _IIter __begin2, _IIter __end2,
+                              _OutputIterator __result, _Compare __comp)
+    {
+      return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
+				      __result,
+				      __difference_func<_IIter,
+				      _OutputIterator, _Compare>(__comp));
+    }
+
+  template<typename _IIter,
+           typename _OutputIterator,
+           typename _Compare>
+    inline _OutputIterator
+    __parallel_set_symmetric_difference(_IIter __begin1, _IIter __end1,
+                                	_IIter __begin2, _IIter __end2,
+                                	_OutputIterator __result,
+                                	_Compare __comp)
+    {
+      return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
+				      __result,
+				      __symmetric_difference_func<_IIter,
+				      _OutputIterator, _Compare>(__comp));
+    }
+}
+
+#endif /* _GLIBCXX_PARALLEL_SET_OPERATIONS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/settings.h b/gcc-4.9/libstdc++-v3/include/parallel/settings.h
new file mode 100644
index 0000000..c823d3a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/settings.h
@@ -0,0 +1,343 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/settings.h
+ *  @brief Runtime settings and tuning parameters, heuristics to decide
+ *  whether to use parallelized algorithms.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ *
+ *  @section parallelization_decision 
+ *  The decision whether to run an algorithm in parallel.
+ *
+ *  There are several ways the user can switch on and __off the parallel
+ *  execution of an algorithm, both at compile- and run-time.
+ *
+ *  Only sequential execution can be forced at compile-time.  This
+ *  reduces code size and protects code parts that have
+ *  non-thread-safe side effects.
+ *
+ *  Ultimately, forcing parallel execution at compile-time makes
+ *  sense.  Often, the sequential algorithm implementation is used as
+ *  a subroutine, so no reduction in code size can be achieved.  Also,
+ *  the machine the program is run on might have only one processor
+ *  core, so to avoid overhead, the algorithm is executed
+ *  sequentially.
+ *
+ *  To force sequential execution of an algorithm ultimately at
+ *  compile-time, the user must add the tag
+*  gnu_parallel::sequential_tag() to the end of the parameter list,
+ *  e. g.
+ *
+ *  \code
+ *  std::sort(__v.begin(), __v.end(), __gnu_parallel::sequential_tag());
+ *  \endcode
+ *
+ *  This is compatible with all overloaded algorithm variants.  No
+ *  additional code will be instantiated, at all.  The same holds for
+ *  most algorithm calls with iterators not providing random access.
+ *
+ *  If the algorithm call is not forced to be executed sequentially
+ *  at compile-time, the decision is made at run-time.
+ *  The global variable __gnu_parallel::_Settings::algorithm_strategy
+ *  is checked. _It is a tristate variable corresponding to:
+ *
+ *  a. force_sequential, meaning the sequential algorithm is executed.
+*  b. force_parallel, meaning the parallel algorithm is executed.
+*  c. heuristic
+ *
+ *  For heuristic, the parallel algorithm implementation is called
+ *  only if the input size is sufficiently large.  For most
+ *  algorithms, the input size is the (combined) length of the input
+*  sequence(__s).  The threshold can be set by the user, individually
+ *  for each algorithm.  The according variables are called
+*  gnu_parallel::_Settings::[algorithm]_minimal_n .
+ *
+ *  For some of the algorithms, there are even more tuning options,
+ *  e. g. the ability to choose from multiple algorithm variants.  See
+ *  below for details.
+ */
+
+// Written by Johannes Singler and Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_SETTINGS_H
+#define _GLIBCXX_PARALLEL_SETTINGS_H 1
+
+#include <parallel/types.h>
+
+/** 
+  * @brief Determine at compile(?)-time if the parallel variant of an
+  * algorithm should be called.
+  * @param __c A condition that is convertible to bool that is overruled by
+  * __gnu_parallel::_Settings::algorithm_strategy. Usually a decision
+  * based on the input size.
+  */
+#define _GLIBCXX_PARALLEL_CONDITION(__c) \
+  (__gnu_parallel::_Settings::get().algorithm_strategy \
+    != __gnu_parallel::force_sequential \
+  && ((__gnu_parallel::__get_max_threads() > 1 && (__c)) \
+     || __gnu_parallel::_Settings::get().algorithm_strategy \
+        == __gnu_parallel::force_parallel))
+
+/*
+inline bool
+parallel_condition(bool __c)
+{
+  bool ret = false;
+  const _Settings& __s = _Settings::get();
+  if (__s.algorithm_strategy != force_seqential)
+    {
+      if (__s.algorithm_strategy == force_parallel)
+        ret = true;
+      else
+        ret = __get_max_threads() > 1 && __c;
+    }
+  return ret;
+}
+*/
+
+namespace __gnu_parallel
+{
+  /// class _Settings
+  /// Run-time settings for the parallel mode including all tunable parameters.
+  struct _Settings
+  {
+    _AlgorithmStrategy          algorithm_strategy;
+    
+    _SortAlgorithm              sort_algorithm;
+    _PartialSumAlgorithm        partial_sum_algorithm;
+    _MultiwayMergeAlgorithm     multiway_merge_algorithm;
+    _FindAlgorithm              find_algorithm;
+
+    _SplittingAlgorithm         sort_splitting;
+    _SplittingAlgorithm         merge_splitting;
+    _SplittingAlgorithm         multiway_merge_splitting;
+
+    // Per-algorithm settings.
+
+    /// Minimal input size for accumulate.
+    _SequenceIndex              accumulate_minimal_n;
+
+    /// Minimal input size for adjacent_difference.
+    unsigned int                adjacent_difference_minimal_n;
+
+    /// Minimal input size for count and count_if.
+    _SequenceIndex              count_minimal_n;
+
+    /// Minimal input size for fill.
+    _SequenceIndex              fill_minimal_n;
+
+    /// Block size increase factor for find.
+    double                      find_increasing_factor;
+
+    /// Initial block size for find.
+    _SequenceIndex              find_initial_block_size;
+
+    /// Maximal block size for find.
+    _SequenceIndex              find_maximum_block_size;
+
+    /// Start with looking for this many elements sequentially, for find.
+    _SequenceIndex              find_sequential_search_size;
+
+    /// Minimal input size for for_each.
+    _SequenceIndex              for_each_minimal_n;
+
+    /// Minimal input size for generate.
+    _SequenceIndex              generate_minimal_n;
+
+    /// Minimal input size for max_element.
+    _SequenceIndex              max_element_minimal_n;
+
+    /// Minimal input size for merge.
+    _SequenceIndex              merge_minimal_n;
+
+    /// Oversampling factor for merge.
+    unsigned int                merge_oversampling;
+
+    /// Minimal input size for min_element.
+    _SequenceIndex              min_element_minimal_n;
+
+    /// Minimal input size for multiway_merge.
+    _SequenceIndex              multiway_merge_minimal_n;
+
+    /// Oversampling factor for multiway_merge.
+    int                         multiway_merge_minimal_k;
+
+    /// Oversampling factor for multiway_merge.
+    unsigned int                multiway_merge_oversampling;
+
+    /// Minimal input size for nth_element.
+    _SequenceIndex              nth_element_minimal_n;
+
+    /// Chunk size for partition.
+    _SequenceIndex              partition_chunk_size;
+
+    /// Chunk size for partition, relative to input size.  If > 0.0,
+    /// this value overrides partition_chunk_size.
+    double                      partition_chunk_share;
+
+    /// Minimal input size for partition.
+    _SequenceIndex              partition_minimal_n;
+
+    /// Minimal input size for partial_sort.
+    _SequenceIndex              partial_sort_minimal_n;
+
+    /// Ratio for partial_sum. Assume "sum and write result" to be
+    /// this factor slower than just "sum".
+    float                       partial_sum_dilation;
+
+    /// Minimal input size for partial_sum.
+    unsigned int                partial_sum_minimal_n;
+
+    /// Minimal input size for random_shuffle.
+    unsigned int                random_shuffle_minimal_n;
+
+    /// Minimal input size for replace and replace_if.
+    _SequenceIndex              replace_minimal_n;
+
+    /// Minimal input size for set_difference.
+    _SequenceIndex              set_difference_minimal_n;
+
+    /// Minimal input size for set_intersection.
+    _SequenceIndex              set_intersection_minimal_n;
+
+    /// Minimal input size for set_symmetric_difference.
+    _SequenceIndex              set_symmetric_difference_minimal_n;
+
+    /// Minimal input size for set_union.
+    _SequenceIndex              set_union_minimal_n;
+
+    /// Minimal input size for parallel sorting.
+    _SequenceIndex              sort_minimal_n;
+
+    /// Oversampling factor for parallel std::sort (MWMS).
+    unsigned int                sort_mwms_oversampling;
+
+    /// Such many samples to take to find a good pivot (quicksort).
+    unsigned int                sort_qs_num_samples_preset;
+
+    /// Maximal subsequence __length to switch to unbalanced __base case.
+    /// Applies to std::sort with dynamically load-balanced quicksort.
+    _SequenceIndex              sort_qsb_base_case_maximal_n;
+
+    /// Minimal input size for parallel std::transform.
+    _SequenceIndex              transform_minimal_n;
+
+    /// Minimal input size for unique_copy. 
+    _SequenceIndex              unique_copy_minimal_n;
+
+    _SequenceIndex              workstealing_chunk_size;
+
+    // Hardware dependent tuning parameters.
+
+    /// size of the L1 cache in bytes (underestimation).
+    unsigned long long          L1_cache_size;
+
+    /// size of the L2 cache in bytes (underestimation).
+    unsigned long long          L2_cache_size;
+
+    /// size of the Translation Lookaside Buffer (underestimation).
+    unsigned int                TLB_size;
+
+    /// Overestimation of cache line size.  Used to avoid false
+    /// sharing, i.e. elements of different threads are at least this
+    /// amount apart.
+    unsigned int                cache_line_size;
+
+    // Statistics.
+
+    /// The number of stolen ranges in load-balanced quicksort.
+    _SequenceIndex              qsb_steals;
+
+    /// Minimal input size for search and search_n.
+    _SequenceIndex              search_minimal_n;
+
+    /// Block size scale-down factor with respect to current position.
+    float                       find_scale_factor;
+
+    /// Get the global settings.
+    _GLIBCXX_CONST static const _Settings&
+    get() throw();
+
+    /// Set the global settings.
+    static void
+    set(_Settings&) throw();
+
+    explicit 
+    _Settings() :
+            algorithm_strategy(heuristic),
+            sort_algorithm(MWMS),
+            partial_sum_algorithm(LINEAR),
+            multiway_merge_algorithm(LOSER_TREE),
+            find_algorithm(CONSTANT_SIZE_BLOCKS),
+            sort_splitting(EXACT),
+            merge_splitting(EXACT),
+            multiway_merge_splitting(EXACT),
+            accumulate_minimal_n(1000),
+            adjacent_difference_minimal_n(1000),
+            count_minimal_n(1000),
+            fill_minimal_n(1000),
+            find_increasing_factor(2.0),
+            find_initial_block_size(256),
+            find_maximum_block_size(8192),
+            find_sequential_search_size(256),
+            for_each_minimal_n(1000),
+            generate_minimal_n(1000),
+            max_element_minimal_n(1000),
+            merge_minimal_n(1000),
+            merge_oversampling(10),
+            min_element_minimal_n(1000),
+            multiway_merge_minimal_n(1000),
+            multiway_merge_minimal_k(2), multiway_merge_oversampling(10),
+            nth_element_minimal_n(1000),
+            partition_chunk_size(1000),
+            partition_chunk_share(0.0),
+            partition_minimal_n(1000),
+            partial_sort_minimal_n(1000),
+            partial_sum_dilation(1.0f),
+            partial_sum_minimal_n(1000),
+            random_shuffle_minimal_n(1000),
+            replace_minimal_n(1000),
+            set_difference_minimal_n(1000),
+            set_intersection_minimal_n(1000),
+            set_symmetric_difference_minimal_n(1000),
+            set_union_minimal_n(1000),
+            sort_minimal_n(1000),
+            sort_mwms_oversampling(10),
+            sort_qs_num_samples_preset(100),
+            sort_qsb_base_case_maximal_n(100),
+            transform_minimal_n(1000),
+            unique_copy_minimal_n(10000),
+            workstealing_chunk_size(100),
+            L1_cache_size(16 << 10),
+            L2_cache_size(256 << 10),
+            TLB_size(128),
+            cache_line_size(64),
+            qsb_steals(0),
+            search_minimal_n(1000),
+            find_scale_factor(0.01f)
+    { }
+  };
+}
+
+#endif /* _GLIBCXX_PARALLEL_SETTINGS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/sort.h b/gcc-4.9/libstdc++-v3/include/parallel/sort.h
new file mode 100644
index 0000000..d9be80f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/sort.h
@@ -0,0 +1,238 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/sort.h
+ *  @brief Parallel sorting algorithm switch.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler.
+
+#ifndef _GLIBCXX_PARALLEL_SORT_H
+#define _GLIBCXX_PARALLEL_SORT_H 1
+
+#include <parallel/basic_iterator.h>
+#include <parallel/features.h>
+#include <parallel/parallel.h>
+
+#if _GLIBCXX_ASSERTIONS
+#include <parallel/checkers.h>
+#endif
+
+#if _GLIBCXX_MERGESORT
+#include <parallel/multiway_mergesort.h>
+#endif
+
+#if _GLIBCXX_QUICKSORT
+#include <parallel/quicksort.h>
+#endif
+
+#if _GLIBCXX_BAL_QUICKSORT
+#include <parallel/balanced_quicksort.h>
+#endif
+
+namespace __gnu_parallel
+{
+  //prototype
+  template<bool __stable, typename _RAIter,
+           typename _Compare, typename _Parallelism>
+    void
+    __parallel_sort(_RAIter __begin, _RAIter __end,
+		    _Compare __comp, _Parallelism __parallelism);
+        
+  /** 
+   *  @brief Choose multiway mergesort, splitting variant at run-time,
+   *  for parallel sorting.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @tparam __stable Sort stable.
+   *  @callgraph 
+   */
+  template<bool __stable, typename _RAIter, typename _Compare>
+    inline void
+    __parallel_sort(_RAIter __begin, _RAIter __end,
+		    _Compare __comp, multiway_mergesort_tag __parallelism)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      if(_Settings::get().sort_splitting == EXACT)
+	parallel_sort_mwms<__stable, true>
+	  (__begin, __end, __comp, __parallelism.__get_num_threads());
+      else
+	parallel_sort_mwms<__stable, false>
+	  (__begin, __end, __comp, __parallelism.__get_num_threads());
+    }
+
+  /** 
+   *  @brief Choose multiway mergesort with exact splitting,
+   *  for parallel sorting.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @tparam __stable Sort stable.
+   *  @callgraph 
+   */
+  template<bool __stable, typename _RAIter, typename _Compare>
+    inline void
+    __parallel_sort(_RAIter __begin, _RAIter __end,
+		    _Compare __comp,
+		    multiway_mergesort_exact_tag __parallelism)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      parallel_sort_mwms<__stable, true>
+        (__begin, __end, __comp, __parallelism.__get_num_threads());
+    }
+
+  /** 
+   *  @brief Choose multiway mergesort with splitting by sampling,
+   *  for parallel sorting.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @tparam __stable Sort stable.
+   *  @callgraph 
+   */
+  template<bool __stable, typename _RAIter, typename _Compare>
+    inline void
+    __parallel_sort(_RAIter __begin, _RAIter __end,
+		    _Compare __comp,
+		    multiway_mergesort_sampling_tag __parallelism)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      parallel_sort_mwms<__stable, false>
+      (__begin, __end, __comp, __parallelism.__get_num_threads());
+    }
+
+  /**
+   *  @brief Choose quicksort for parallel sorting.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @tparam __stable Sort stable.
+   *  @callgraph 
+   */
+  template<bool __stable, typename _RAIter, typename _Compare>
+    inline void
+    __parallel_sort(_RAIter __begin, _RAIter __end,
+		    _Compare __comp, quicksort_tag __parallelism)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      _GLIBCXX_PARALLEL_ASSERT(__stable == false);
+
+      __parallel_sort_qs(__begin, __end, __comp,
+			 __parallelism.__get_num_threads());
+    }
+
+  /**
+   *  @brief Choose balanced quicksort for parallel sorting.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @tparam __stable Sort stable.
+   *  @callgraph 
+   */
+   template<bool __stable, typename _RAIter, typename _Compare>
+     inline void
+     __parallel_sort(_RAIter __begin, _RAIter __end,
+		     _Compare __comp, balanced_quicksort_tag __parallelism)
+     {
+       _GLIBCXX_CALL(__end - __begin)
+
+       _GLIBCXX_PARALLEL_ASSERT(__stable == false);
+
+       __parallel_sort_qsb(__begin, __end, __comp,
+			   __parallelism.__get_num_threads());
+     }
+
+  /** 
+   *  @brief Choose multiway mergesort with exact splitting,
+   *  for parallel sorting.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @tparam __stable Sort stable.
+   *  @callgraph 
+   */
+  template<bool __stable, typename _RAIter, typename _Compare>
+    inline void
+    __parallel_sort(_RAIter __begin, _RAIter __end,
+		    _Compare __comp, default_parallel_tag __parallelism)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      __parallel_sort<__stable>
+	(__begin, __end, __comp,
+	 multiway_mergesort_exact_tag(__parallelism.__get_num_threads()));
+    }
+
+  /**
+   *  @brief Choose a parallel sorting algorithm.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @tparam __stable Sort stable.
+   *  @callgraph 
+   */
+  template<bool __stable, typename _RAIter, typename _Compare>
+    inline void
+    __parallel_sort(_RAIter __begin, _RAIter __end,
+		    _Compare __comp, parallel_tag __parallelism)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      if (false) ;
+#if _GLIBCXX_MERGESORT
+      else if (__stable || _Settings::get().sort_algorithm == MWMS)
+        {
+          if(_Settings::get().sort_splitting == EXACT)
+            parallel_sort_mwms<__stable, true>
+              (__begin, __end, __comp, __parallelism.__get_num_threads());
+          else
+            parallel_sort_mwms<false, false>
+              (__begin, __end, __comp, __parallelism.__get_num_threads());
+        }
+#endif
+#if _GLIBCXX_QUICKSORT
+      else if (_Settings::get().sort_algorithm == QS)
+        __parallel_sort_qs(__begin, __end, __comp,
+                           __parallelism.__get_num_threads());
+#endif
+#if _GLIBCXX_BAL_QUICKSORT
+      else if (_Settings::get().sort_algorithm == QS_BALANCED)
+        __parallel_sort_qsb(__begin, __end, __comp,
+                            __parallelism.__get_num_threads());
+#endif
+      else
+        __gnu_sequential::sort(__begin, __end, __comp);
+    }
+} // end namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_SORT_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/tags.h b/gcc-4.9/libstdc++-v3/include/parallel/tags.h
new file mode 100644
index 0000000..0287070
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/tags.h
@@ -0,0 +1,185 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file parallel/tags.h
+ * @brief Tags for compile-time selection.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler and Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_TAGS_H
+#define _GLIBCXX_PARALLEL_TAGS_H 1
+
+#include <omp.h>
+#include <parallel/types.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Forces sequential execution at compile time. */
+  struct sequential_tag { };
+
+  /** @brief Recommends parallel execution at compile time,
+   *  optionally using a user-specified number of threads. */
+  struct parallel_tag
+  {
+    private:
+      _ThreadIndex _M_num_threads;
+
+    public:
+      /** @brief Default constructor. Use default number of threads. */
+      parallel_tag()
+      { _M_num_threads = 0; }
+
+      /** @brief Default constructor. Recommend number of threads to use.
+       *  @param __num_threads Desired number of threads. */
+      parallel_tag(_ThreadIndex __num_threads)
+      { _M_num_threads = __num_threads; }
+
+      /** @brief Find out desired number of threads.
+       *  @return Desired number of threads. */
+      _ThreadIndex __get_num_threads()
+      {
+        if(_M_num_threads == 0)
+          return omp_get_max_threads();
+        else
+          return _M_num_threads;
+      }
+
+      /** @brief Set the desired number of threads.
+       *  @param __num_threads Desired number of threads. */
+      void set_num_threads(_ThreadIndex __num_threads)
+      { _M_num_threads = __num_threads; }
+  };
+
+  /** @brief Recommends parallel execution using the
+      default parallel algorithm. */
+  struct default_parallel_tag : public parallel_tag
+  {
+    default_parallel_tag() { }
+    default_parallel_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+  /** @brief Recommends parallel execution using dynamic
+      load-balancing at compile time. */
+  struct balanced_tag : public parallel_tag { };
+
+  /** @brief Recommends parallel execution using static
+      load-balancing at compile time. */
+  struct unbalanced_tag : public parallel_tag { };
+
+  /** @brief Recommends parallel execution using OpenMP dynamic
+      load-balancing at compile time. */
+  struct omp_loop_tag : public parallel_tag { };
+
+  /** @brief Recommends parallel execution using OpenMP static
+      load-balancing at compile time. */
+  struct omp_loop_static_tag : public parallel_tag { };
+
+
+  /** @brief Base class for for std::find() variants. */
+  struct find_tag { };
+
+
+  /** @brief Forces parallel merging
+   *  with exact splitting, at compile time. */
+  struct exact_tag : public parallel_tag
+  {
+    exact_tag() { }
+    exact_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+  /** @brief Forces parallel merging
+   *  with exact splitting, at compile time. */
+  struct sampling_tag : public parallel_tag
+  {
+    sampling_tag() { }
+    sampling_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+
+  /** @brief Forces parallel sorting using multiway mergesort
+   *  at compile time. */
+  struct multiway_mergesort_tag : public parallel_tag
+  {
+    multiway_mergesort_tag() { }
+    multiway_mergesort_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+  /** @brief Forces parallel sorting using multiway mergesort
+   *  with exact splitting at compile time. */
+  struct multiway_mergesort_exact_tag : public parallel_tag
+  {
+    multiway_mergesort_exact_tag() { }
+    multiway_mergesort_exact_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+  /** @brief Forces parallel sorting using multiway mergesort
+   *  with splitting by sampling at compile time. */
+  struct multiway_mergesort_sampling_tag : public parallel_tag
+  {
+    multiway_mergesort_sampling_tag() { }
+    multiway_mergesort_sampling_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+  /** @brief Forces parallel sorting using unbalanced quicksort
+   *  at compile time. */
+  struct quicksort_tag : public parallel_tag
+  {
+    quicksort_tag() { }
+    quicksort_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+  /** @brief Forces parallel sorting using balanced quicksort
+   *  at compile time. */
+  struct balanced_quicksort_tag : public parallel_tag
+  {
+    balanced_quicksort_tag() { }
+    balanced_quicksort_tag(_ThreadIndex __num_threads)
+    : parallel_tag(__num_threads) { }
+  };
+
+
+  /** @brief Selects the growing block size variant for std::find().
+      @see _GLIBCXX_FIND_GROWING_BLOCKS */
+  struct growing_blocks_tag : public find_tag { };
+
+  /** @brief Selects the constant block size variant for std::find().
+      @see _GLIBCXX_FIND_CONSTANT_SIZE_BLOCKS */
+  struct constant_size_blocks_tag : public find_tag { };
+
+  /** @brief Selects the equal splitting variant for std::find().
+      @see _GLIBCXX_FIND_EQUAL_SPLIT */
+  struct equal_split_tag : public find_tag { };
+}
+
+#endif /* _GLIBCXX_PARALLEL_TAGS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/types.h b/gcc-4.9/libstdc++-v3/include/parallel/types.h
new file mode 100644
index 0000000..cd5e73d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/types.h
@@ -0,0 +1,137 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/types.h
+ *  @brief Basic types and typedefs.
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Johannes Singler and Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_TYPES_H
+#define _GLIBCXX_PARALLEL_TYPES_H 1
+
+#include <cstdlib>
+#include <limits>
+#include <tr1/cstdint>
+
+namespace __gnu_parallel
+{
+  // Enumerated types.
+
+  /// Run-time equivalents for the compile-time tags.
+  enum _Parallelism
+    {
+      /// Not parallel.
+      sequential,
+
+      /// Parallel unbalanced (equal-sized chunks).
+      parallel_unbalanced,
+
+      /// Parallel balanced (work-stealing).
+      parallel_balanced,
+
+      /// Parallel with OpenMP dynamic load-balancing.
+      parallel_omp_loop,
+
+      /// Parallel with OpenMP static load-balancing.
+      parallel_omp_loop_static,
+
+      /// Parallel with OpenMP taskqueue construct.
+      parallel_taskqueue
+    };
+
+  /// Strategies for run-time algorithm selection: 
+  // force_sequential, force_parallel, heuristic.
+  enum _AlgorithmStrategy
+    {
+      heuristic,
+      force_sequential,
+      force_parallel
+    };
+
+  /// Sorting algorithms: 
+  // multi-way mergesort, quicksort, load-balanced quicksort.
+  enum _SortAlgorithm 
+    { 
+      MWMS, 
+      QS, 
+      QS_BALANCED 
+    };
+
+  /// Merging algorithms: 
+  // bubblesort-alike, loser-tree variants, enum __sentinel.
+  enum _MultiwayMergeAlgorithm
+    {
+      LOSER_TREE
+    };
+
+  /// Partial sum algorithms: recursive, linear.
+  enum _PartialSumAlgorithm 
+    { 
+      RECURSIVE, 
+      LINEAR 
+    };
+
+  /// Sorting/merging algorithms: sampling, __exact.
+  enum _SplittingAlgorithm 
+    { 
+      SAMPLING, 
+      EXACT 
+    };
+
+  /// Find algorithms:
+  // growing blocks, equal-sized blocks, equal splitting.
+  enum _FindAlgorithm 
+    { 
+      GROWING_BLOCKS, 
+      CONSTANT_SIZE_BLOCKS, 
+      EQUAL_SPLIT 
+    };
+
+  /**
+   * @brief Unsigned integer to index __elements.
+   * The total number of elements for each algorithm must fit into this type.
+   */
+  typedef uint64_t _SequenceIndex;
+
+  /**
+   * @brief Unsigned integer to index a thread number.
+   * The maximum thread number (for each processor) must fit into this type.
+   */
+  typedef uint16_t _ThreadIndex;
+
+  // XXX atomics interface?
+  /// Longest compare-and-swappable integer type on this platform.
+  typedef int64_t _CASable;
+
+  /// Number of bits of _CASable.
+  static const int _CASable_bits = std::numeric_limits<_CASable>::digits;
+
+  /// ::_CASable with the right half of bits set to 1.
+  static const _CASable _CASable_mask =
+                            ((_CASable(1) << (_CASable_bits / 2)) - 1);
+}
+
+#endif /* _GLIBCXX_PARALLEL_TYPES_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/unique_copy.h b/gcc-4.9/libstdc++-v3/include/parallel/unique_copy.h
new file mode 100644
index 0000000..5fc22cf
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/unique_copy.h
@@ -0,0 +1,197 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/unique_copy.h
+ *  @brief Parallel implementations of std::unique_copy().
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Robert Geisberger and Robin Dapp.
+
+#ifndef _GLIBCXX_PARALLEL_UNIQUE_COPY_H
+#define _GLIBCXX_PARALLEL_UNIQUE_COPY_H 1
+
+#include <parallel/parallel.h>
+#include <parallel/multiseq_selection.h>
+
+namespace __gnu_parallel
+{
+  /** @brief Parallel std::unique_copy(), w/__o explicit equality predicate.
+    *  @param __first Begin iterator of input sequence.
+    *  @param __last End iterator of input sequence.
+    *  @param __result Begin iterator of result __sequence.
+    *  @param __binary_pred Equality predicate.
+    *  @return End iterator of result __sequence. */
+  template<typename _IIter,
+           class _OutputIterator,
+           class _BinaryPredicate>
+    _OutputIterator
+    __parallel_unique_copy(_IIter __first, _IIter __last,
+			   _OutputIterator __result,
+			   _BinaryPredicate __binary_pred)
+    {
+      _GLIBCXX_CALL(__last - __first)
+
+      typedef std::iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      _DifferenceType __size = __last - __first;
+
+      if (__size == 0)
+	return __result;
+
+      // Let the first thread process two parts.
+      _DifferenceType *__counter;
+      _DifferenceType *__borders;
+
+      _ThreadIndex __num_threads = __get_max_threads();
+      // First part contains at least one element.
+#     pragma omp parallel num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+	  __borders = new _DifferenceType[__num_threads + 2];
+	  __equally_split(__size, __num_threads + 1, __borders);
+	  __counter = new _DifferenceType[__num_threads + 1];
+	}
+
+	_ThreadIndex __iam = omp_get_thread_num();
+
+	_DifferenceType __begin, __end;
+
+	// Check for length without duplicates
+	// Needed for position in output
+	_DifferenceType __i = 0;
+	_OutputIterator __out = __result;
+
+	if (__iam == 0)
+          {
+            __begin = __borders[0] + 1;   // == 1
+            __end = __borders[__iam + 1];
+
+            ++__i;
+            *__out++ = *__first;
+
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
+              {
+        	if (!__binary_pred(*__iter, *(__iter - 1)))
+                  {
+                    ++__i;
+                    *__out++ = *__iter;
+                  }
+              }
+          }
+	else
+          {
+            __begin = __borders[__iam]; //one part
+            __end = __borders[__iam + 1];
+
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
+              {
+        	if (!__binary_pred(*__iter, *(__iter - 1)))
+                  ++__i;
+              }
+          }
+	__counter[__iam] = __i;
+
+	// Last part still untouched.
+	_DifferenceType __begin_output;
+
+#       pragma omp barrier
+
+	// Store result in output on calculated positions.
+	__begin_output = 0;
+
+	if (__iam == 0)
+          {
+            for (_ThreadIndex __t = 0; __t < __num_threads; ++__t)
+              __begin_output += __counter[__t];
+
+            __i = 0;
+
+            _OutputIterator __iter_out = __result + __begin_output;
+
+            __begin = __borders[__num_threads];
+            __end = __size;
+
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
+              {
+        	if (__iter == __first
+		    || !__binary_pred(*__iter, *(__iter - 1)))
+                  {
+                    ++__i;
+                    *__iter_out++ = *__iter;
+                  }
+              }
+
+            __counter[__num_threads] = __i;
+          }
+	else
+          {
+            for (_ThreadIndex __t = 0; __t < __iam; __t++)
+              __begin_output += __counter[__t];
+
+            _OutputIterator __iter_out = __result + __begin_output;
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
+              {
+        	if (!__binary_pred(*__iter, *(__iter - 1)))
+                  *__iter_out++ = *__iter;
+              }
+          }
+      }
+
+      _DifferenceType __end_output = 0;
+      for (_ThreadIndex __t = 0; __t < __num_threads + 1; __t++)
+	__end_output += __counter[__t];
+
+      delete[] __borders;
+
+      return __result + __end_output;
+    }
+
+  /** @brief Parallel std::unique_copy(), without explicit equality predicate
+    *  @param __first Begin iterator of input sequence.
+    *  @param __last End iterator of input sequence.
+    *  @param __result Begin iterator of result __sequence.
+    *  @return End iterator of result __sequence. */
+  template<typename _IIter, class _OutputIterator>
+    inline _OutputIterator
+    __parallel_unique_copy(_IIter __first, _IIter __last,
+			   _OutputIterator __result)
+    {
+      typedef typename std::iterator_traits<_IIter>::value_type
+	_ValueType;
+      return __parallel_unique_copy(__first, __last, __result,
+				    std::equal_to<_ValueType>());
+    }
+
+}//namespace __gnu_parallel
+
+#endif /* _GLIBCXX_PARALLEL_UNIQUE_COPY_H */
diff --git a/gcc-4.9/libstdc++-v3/include/parallel/workstealing.h b/gcc-4.9/libstdc++-v3/include/parallel/workstealing.h
new file mode 100644
index 0000000..7dfcbed
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/parallel/workstealing.h
@@ -0,0 +1,312 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 3, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file parallel/workstealing.h
+ *  @brief Parallelization of embarrassingly parallel execution by
+ *  means of work-stealing.
+ *
+ *  Work stealing is described in
+ *
+ *  R. D. Blumofe and C. E. Leiserson.
+ *  Scheduling multithreaded computations by work stealing.
+ *  Journal of the ACM, 46(5):720–748, 1999.
+ *
+ *  This file is a GNU parallel extension to the Standard C++ Library.
+ */
+
+// Written by Felix Putze.
+
+#ifndef _GLIBCXX_PARALLEL_WORKSTEALING_H
+#define _GLIBCXX_PARALLEL_WORKSTEALING_H 1
+
+#include <parallel/parallel.h>
+#include <parallel/random_number.h>
+#include <parallel/compatibility.h>
+
+namespace __gnu_parallel
+{
+
+#define _GLIBCXX_JOB_VOLATILE volatile
+
+  /** @brief One __job for a certain thread. */
+  template<typename _DifferenceTp>
+    struct _Job
+    {
+      typedef _DifferenceTp _DifferenceType;
+
+      /** @brief First element.
+       *
+       *  Changed by owning and stealing thread. By stealing thread,
+       *  always incremented. */
+      _GLIBCXX_JOB_VOLATILE _DifferenceType _M_first;
+
+      /** @brief Last element.
+       *
+       *  Changed by owning thread only. */
+      _GLIBCXX_JOB_VOLATILE _DifferenceType _M_last;
+
+      /** @brief Number of elements, i.e. @c _M_last-_M_first+1.
+       *
+       *  Changed by owning thread only. */
+      _GLIBCXX_JOB_VOLATILE _DifferenceType _M_load;
+    };
+
+  /** @brief Work stealing algorithm for random access iterators.
+    *
+    *  Uses O(1) additional memory. Synchronization at job lists is
+    *  done with atomic operations.
+    *  @param __begin Begin iterator of element sequence.
+    *  @param __end End iterator of element sequence.
+    *  @param __op User-supplied functor (comparator, predicate, adding
+    *  functor, ...).
+    *  @param __f Functor to @a process an element with __op (depends on
+    *  desired functionality, e. g. for std::for_each(), ...).
+    *  @param __r Functor to @a add a single __result to the already
+    *  processed elements (depends on functionality).
+    *  @param __base Base value for reduction.
+    *  @param __output Pointer to position where final result is written to
+    *  @param __bound Maximum number of elements processed (e. g. for
+    *  std::count_n()).
+    *  @return User-supplied functor (that may contain a part of the result).
+    */
+  template<typename _RAIter,
+           typename _Op,
+           typename _Fu,
+           typename _Red,
+           typename _Result>
+    _Op
+    __for_each_template_random_access_workstealing(_RAIter __begin,
+						   _RAIter __end, _Op __op,
+						   _Fu& __f, _Red __r,
+						   _Result __base,
+						   _Result& __output,
+      typename std::iterator_traits<_RAIter>::difference_type __bound)
+    {
+      _GLIBCXX_CALL(__end - __begin)
+
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+
+      const _Settings& __s = _Settings::get();
+
+      _DifferenceType __chunk_size =
+          static_cast<_DifferenceType>(__s.workstealing_chunk_size);
+
+      // How many jobs?
+      _DifferenceType __length = (__bound < 0) ? (__end - __begin) : __bound;
+
+      // To avoid false sharing in a cache line.
+      const int __stride = (__s.cache_line_size * 10
+			    / sizeof(_Job<_DifferenceType>) + 1);
+
+      // Total number of threads currently working.
+      _ThreadIndex __busy = 0;
+
+      _Job<_DifferenceType> *__job;
+
+      omp_lock_t __output_lock;
+      omp_init_lock(&__output_lock);
+
+      // Write base value to output.
+      __output = __base;
+
+      // No more threads than jobs, at least one thread.
+      _ThreadIndex __num_threads = __gnu_parallel::max<_ThreadIndex>
+	(1, __gnu_parallel::min<_DifferenceType>(__length,
+						 __get_max_threads()));
+
+#     pragma omp parallel shared(__busy) num_threads(__num_threads)
+      {
+#       pragma omp single
+	{
+	  __num_threads = omp_get_num_threads();
+
+	  // Create job description array.
+	  __job = new _Job<_DifferenceType>[__num_threads * __stride];
+	}
+
+	// Initialization phase.
+
+	// Flags for every thread if it is doing productive work.
+	bool __iam_working = false;
+
+	// Thread id.
+	_ThreadIndex __iam = omp_get_thread_num();
+
+	// This job.
+	_Job<_DifferenceType>& __my_job = __job[__iam * __stride];
+
+	// Random number (for work stealing).
+	_ThreadIndex __victim;
+
+	// Local value for reduction.
+	_Result __result = _Result();
+
+	// Number of elements to steal in one attempt.
+	_DifferenceType __steal;
+
+	// Every thread has its own random number generator
+	// (modulo __num_threads).
+	_RandomNumber __rand_gen(__iam, __num_threads);
+
+	// This thread is currently working.
+#       pragma omp atomic
+	++__busy;
+
+	__iam_working = true;
+
+	// How many jobs per thread? last thread gets the rest.
+	__my_job._M_first = static_cast<_DifferenceType>
+	  (__iam * (__length / __num_threads));
+
+	__my_job._M_last = (__iam == (__num_threads - 1)
+			    ? (__length - 1)
+			    : ((__iam + 1) * (__length / __num_threads) - 1));
+	__my_job._M_load = __my_job._M_last - __my_job._M_first + 1;
+
+	// Init result with _M_first value (to have a base value for reduction)
+	if (__my_job._M_first <= __my_job._M_last)
+	  {
+	    // Cannot use volatile variable directly.
+	    _DifferenceType __my_first = __my_job._M_first;
+	    __result = __f(__op, __begin + __my_first);
+	    ++__my_job._M_first;
+	    --__my_job._M_load;
+	  }
+
+	_RAIter __current;
+
+#       pragma omp barrier
+
+	// Actual work phase
+	// Work on own or stolen current start
+	while (__busy > 0)
+	  {
+	    // Work until no productive thread left.
+#           pragma omp flush(__busy)
+
+	    // Thread has own work to do
+	    while (__my_job._M_first <= __my_job._M_last)
+	      {
+		// fetch-and-add call
+		// Reserve current job block (size __chunk_size) in my queue.
+		_DifferenceType __current_job =
+		  __fetch_and_add<_DifferenceType>(&(__my_job._M_first),
+						   __chunk_size);
+
+		// Update _M_load, to make the three values consistent,
+		// _M_first might have been changed in the meantime
+		__my_job._M_load = __my_job._M_last - __my_job._M_first + 1;
+		for (_DifferenceType __job_counter = 0;
+		     __job_counter < __chunk_size
+		       && __current_job <= __my_job._M_last;
+		     ++__job_counter)
+		  {
+		    // Yes: process it!
+		    __current = __begin + __current_job;
+		    ++__current_job;
+
+		    // Do actual work.
+		    __result = __r(__result, __f(__op, __current));
+		  }
+
+#               pragma omp flush(__busy)
+	      }
+
+	    // After reaching this point, a thread's __job list is empty.
+	    if (__iam_working)
+	      {
+		// This thread no longer has work.
+#               pragma omp atomic
+		--__busy;
+
+		__iam_working = false;
+	      }
+
+	    _DifferenceType __supposed_first, __supposed_last,
+	                    __supposed_load;
+	    do
+	      {
+		// Find random nonempty deque (not own), do consistency check.
+		__yield();
+#               pragma omp flush(__busy)
+		__victim = __rand_gen();
+		__supposed_first = __job[__victim * __stride]._M_first;
+		__supposed_last = __job[__victim * __stride]._M_last;
+		__supposed_load = __job[__victim * __stride]._M_load;
+	      }
+	    while (__busy > 0
+		   && ((__supposed_load <= 0)
+		       || ((__supposed_first + __supposed_load - 1)
+			   != __supposed_last)));
+
+	    if (__busy == 0)
+	      break;
+
+	    if (__supposed_load > 0)
+	      {
+		// Has work and work to do.
+		// Number of elements to steal (at least one).
+		__steal = (__supposed_load < 2) ? 1 : __supposed_load / 2;
+
+		// Push __victim's current start forward.
+		_DifferenceType __stolen_first =
+		  __fetch_and_add<_DifferenceType>
+		  (&(__job[__victim * __stride]._M_first), __steal);
+		_DifferenceType __stolen_try = (__stolen_first + __steal
+						- _DifferenceType(1));
+
+		__my_job._M_first = __stolen_first;
+		__my_job._M_last = __gnu_parallel::min(__stolen_try,
+						       __supposed_last);
+		__my_job._M_load = __my_job._M_last - __my_job._M_first + 1;
+
+		// Has potential work again.
+#               pragma omp atomic
+		++__busy;
+		__iam_working = true;
+
+#               pragma omp flush(__busy)
+	      }
+#           pragma omp flush(__busy)
+	  } // end while __busy > 0
+	// Add accumulated result to output.
+	omp_set_lock(&__output_lock);
+	__output = __r(__output, __result);
+	omp_unset_lock(&__output_lock);
+      }
+
+      delete[] __job;
+
+      // Points to last element processed (needed as return value for
+      // some algorithms like transform)
+      __f._M_finish_iterator = __begin + __length;
+
+      omp_destroy_lock(&__output_lock);
+
+      return __op;
+    }
+} // end namespace
+
+#endif /* _GLIBCXX_PARALLEL_WORKSTEALING_H */
diff --git a/gcc-4.9/libstdc++-v3/include/precompiled/extc++.h b/gcc-4.9/libstdc++-v3/include/precompiled/extc++.h
new file mode 100644
index 0000000..516fbe2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/precompiled/extc++.h
@@ -0,0 +1,71 @@
+// C++ includes used for precompiling extensions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file extc++.h
+ *  This is an implementation file for a precompiled header.
+ */
+
+#if __cplusplus < 201103L
+#include <bits/stdtr1c++.h>
+#endif
+
+#include <ext/algorithm>
+#include <ext/array_allocator.h>
+#include <ext/atomicity.h>
+#include <ext/bitmap_allocator.h>
+#include <ext/cast.h>
+#include <ext/concurrence.h>
+#include <ext/debug_allocator.h>
+#include <ext/extptr_allocator.h>
+#include <ext/functional>
+#include <ext/iterator>
+#include <ext/malloc_allocator.h>
+#include <ext/memory>
+#include <ext/mt_allocator.h>
+#include <ext/new_allocator.h>
+#include <ext/numeric>
+#include <ext/pod_char_traits.h>
+#include <ext/pointer.h>
+#include <ext/pool_allocator.h>
+#include <ext/rb_tree>
+#include <ext/rope>
+#include <ext/slist>
+#include <ext/stdio_filebuf.h>
+#include <ext/stdio_sync_filebuf.h>
+#include <ext/throw_allocator.h>
+#include <ext/typelist.h>
+#include <ext/type_traits.h>
+#include <ext/vstring.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/priority_queue.hpp>
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/hash_policy.hpp>
+#include <ext/pb_ds/list_update_policy.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+#include <ext/pb_ds/trie_policy.hpp>
+
+#ifdef _GLIBCXX_HAVE_ICONV
+ #include <ext/codecvt_specializations.h>
+ #include <ext/enc_filebuf.h>
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/precompiled/stdc++.h b/gcc-4.9/libstdc++-v3/include/precompiled/stdc++.h
new file mode 100644
index 0000000..977765a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/precompiled/stdc++.h
@@ -0,0 +1,117 @@
+// C++ includes used for precompiling -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stdc++.h
+ *  This is an implementation file for a precompiled header.
+ */
+
+// 17.4.1.2 Headers
+
+// C
+#ifndef _GLIBCXX_NO_ASSERT
+#include <cassert>
+#endif
+#include <cctype>
+#include <cerrno>
+#include <cfloat>
+#include <ciso646>
+#include <climits>
+#include <clocale>
+#include <cmath>
+#include <csetjmp>
+#include <csignal>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+
+#if __cplusplus >= 201103L
+#include <ccomplex>
+#include <cfenv>
+#include <cinttypes>
+#include <cstdalign>
+#include <cstdbool>
+#include <cstdint>
+#include <ctgmath>
+#include <cwchar>
+#include <cwctype>
+#endif
+
+// C++
+#include <algorithm>
+#include <bitset>
+#include <complex>
+#include <deque>
+#include <exception>
+#include <fstream>
+#include <functional>
+#include <iomanip>
+#include <ios>
+#include <iosfwd>
+#include <iostream>
+#include <istream>
+#include <iterator>
+#include <limits>
+#include <list>
+#include <locale>
+#include <map>
+#include <memory>
+#include <new>
+#include <numeric>
+#include <ostream>
+#include <queue>
+#include <set>
+#include <sstream>
+#include <stack>
+#include <stdexcept>
+#include <streambuf>
+#include <string>
+#include <typeinfo>
+#include <utility>
+#include <valarray>
+#include <vector>
+
+#if __cplusplus >= 201103L
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <forward_list>
+#include <future>
+#include <initializer_list>
+#include <mutex>
+#include <random>
+#include <ratio>
+#include <regex>
+#include <scoped_allocator>
+#include <system_error>
+#include <thread>
+#include <tuple>
+#include <typeindex>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/precompiled/stdtr1c++.h b/gcc-4.9/libstdc++-v3/include/precompiled/stdtr1c++.h
new file mode 100644
index 0000000..119df4e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/precompiled/stdtr1c++.h
@@ -0,0 +1,53 @@
+// C++ includes used for precompiling TR1 -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file stdtr1c++.h
+ *  This is an implementation file for a precompiled header.
+ */
+
+#include <bits/stdc++.h>
+
+#include <tr1/array>
+#include <tr1/cctype>
+#include <tr1/cfenv>
+#include <tr1/cfloat>
+#include <tr1/cinttypes>
+#include <tr1/climits>
+#include <tr1/cmath>
+#include <tr1/complex>
+#include <tr1/cstdarg>
+#include <tr1/cstdbool>
+#include <tr1/cstdint>
+#include <tr1/cstdio>
+#include <tr1/cstdlib>
+#include <tr1/ctgmath>
+#include <tr1/ctime>
+#include <tr1/cwchar>
+#include <tr1/cwctype>
+#include <tr1/functional>
+#include <tr1/random>
+#include <tr1/tuple>
+#include <tr1/unordered_map>
+#include <tr1/unordered_set>
+#include <tr1/utility>
diff --git a/gcc-4.9/libstdc++-v3/include/profile/array b/gcc-4.9/libstdc++-v3/include/profile/array
new file mode 100644
index 0000000..1c38b05
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/array
@@ -0,0 +1,272 @@
+// Profile array implementation -*- C++ -*-
+
+// Copyright (C) 2012-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/array
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_PROFILE_ARRAY
+#define _GLIBCXX_PROFILE_ARRAY 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp 	    			      value_type;
+      typedef value_type*			      pointer;
+      typedef const value_type*                       const_pointer;
+      typedef value_type&                   	      reference;
+      typedef const value_type&             	      const_reference;
+      typedef value_type*                             iterator;
+      typedef const value_type*                       const_iterator;
+      typedef std::size_t                    	      size_type;
+      typedef std::ptrdiff_t                   	      difference_type;
+      typedef std::reverse_iterator<iterator>	      reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+
+      // Support for zero-sized arrays mandatory.
+      typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;
+      typename _AT_Type::_Type                         _M_elems;
+
+      // No explicit construct/copy/destroy for aggregate type.
+
+      // DR 776.
+      void
+      fill(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void
+      swap(array& __other)
+      noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+      // Iterators.
+      iterator
+      begin() noexcept
+      { return iterator(data()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(data()); }
+
+      iterator
+      end() noexcept
+      { return iterator(data() + _Nm); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      reverse_iterator 
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator 
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator 
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(data()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      const_reverse_iterator 
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      // Capacity.
+      constexpr size_type 
+      size() const noexcept { return _Nm; }
+
+      constexpr size_type 
+      max_size() const noexcept { return _Nm; }
+
+      constexpr bool 
+      empty() const noexcept { return size() == 0; }
+
+      // Element access.
+      reference
+      operator[](size_type __n) noexcept
+      {	return _AT_Type::_S_ref(_M_elems, __n); }
+
+      constexpr const_reference
+      operator[](size_type __n) const noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      reference
+      at(size_type __n)
+      {
+	if (__n >= _Nm)
+	  std::__throw_out_of_range_fmt(__N("array::at: __n "
+				            "(which is %zu) >= _Nm "
+					    "(which is %zu)"),
+					__n, _Nm);
+	return _AT_Type::_S_ref(_M_elems, __n);
+      }
+
+      constexpr const_reference
+      at(size_type __n) const
+      {
+	// Result of conditional expression must be an lvalue so use
+	// boolean ? lvalue : (throw-expr, lvalue)
+	return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+	  : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
+					       ">= _Nm (which is %zu)"),
+					   __n, _Nm),
+	     _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      reference 
+      front() noexcept
+      { return *begin(); }
+
+      constexpr const_reference 
+      front() const noexcept
+      { return _AT_Type::_S_ref(_M_elems, 0); }
+
+      reference 
+      back() noexcept
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      constexpr const_reference 
+      back() const noexcept
+      {
+	return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+ 	           : _AT_Type::_S_ref(_M_elems, 0);	  
+      }
+
+      pointer
+      data() noexcept
+      { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
+
+      const_pointer
+      data() const noexcept
+      { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
+    };
+
+  // Array comparisons.
+  template<typename _Tp, std::size_t _Nm>
+    inline bool 
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    { 
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+					  __b.begin(), __b.end()); 
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+  // Specialized algorithms.
+  template<typename _Tp, std::size_t _Nm>
+    inline void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
+	_S_ref(__arr._M_elems, _Int);
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&&
+    get(array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::move(get<_Int>(__arr));
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&
+    get(const array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
+	_S_ref(__arr._M_elems, _Int);
+    }
+} // namespace __profile
+
+  // Tuple interface to class template array.
+
+  /// tuple_size
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<__profile::array<_Tp, _Nm>>
+    : public integral_constant<std::size_t, _Nm> { };
+
+  /// tuple_element
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, __profile::array<_Tp, _Nm>>
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      typedef _Tp type;
+    };
+} // namespace std
+
+#endif // _GLIBCXX_PROFILE_ARRAY
diff --git a/gcc-4.9/libstdc++-v3/include/profile/base.h b/gcc-4.9/libstdc++-v3/include/profile/base.h
new file mode 100644
index 0000000..342bb70
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/base.h
@@ -0,0 +1,59 @@
+// -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/base.h
+ *  @brief Sequential helper functions.
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+// Written by Lixia Liu
+
+#ifndef _GLIBCXX_PROFILE_BASE_H
+#define _GLIBCXX_PROFILE_BASE_H 1
+
+#include <functional>
+#include <profile/impl/profiler.h>
+
+// Profiling mode namespaces.
+
+/**
+ * @namespace std::__profile
+ * @brief GNU profile code, replaces standard behavior with profile behavior.
+ */
+namespace std _GLIBCXX_VISIBILITY(default) 
+{ 
+  namespace __profile { } 
+}
+
+/**
+ * @namespace __gnu_profile
+ * @brief GNU profile code for public use.
+ */
+namespace __gnu_profile
+{
+  // Import all the profile versions of components in namespace std.
+  using namespace std::__profile;
+}
+
+
+#endif /* _GLIBCXX_PROFILE_BASE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/bitset b/gcc-4.9/libstdc++-v3/include/profile/bitset
new file mode 100644
index 0000000..a9f37aa
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/bitset
@@ -0,0 +1,382 @@
+// Profiling bitset implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/bitset
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_BITSET
+#define _GLIBCXX_PROFILE_BITSET
+
+#include <bitset>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /// Class std::bitset wrapper with performance instrumentation.
+  template<size_t _Nb>
+    class bitset
+    : public _GLIBCXX_STD_C::bitset<_Nb>
+    {
+      typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
+
+    public:
+      // bit reference:
+      class reference
+      : private _Base::reference
+      {
+	typedef typename _Base::reference _Base_ref;
+
+	friend class bitset;
+	reference();
+
+	reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT
+	: _Base_ref(__base)
+	{ }
+
+      public:
+	reference(const reference& __x) _GLIBCXX_NOEXCEPT
+	: _Base_ref(__x)
+	{ }
+
+	reference&
+	operator=(bool __x) _GLIBCXX_NOEXCEPT
+	{
+	  *static_cast<_Base_ref*>(this) = __x;
+	  return *this;
+	}
+
+	reference&
+	operator=(const reference& __x) _GLIBCXX_NOEXCEPT
+	{
+	  *static_cast<_Base_ref*>(this) = __x;
+	  return *this;
+	}
+
+	bool
+	operator~() const _GLIBCXX_NOEXCEPT
+	{
+	  return ~(*static_cast<const _Base_ref*>(this));
+	}
+
+	operator bool() const _GLIBCXX_NOEXCEPT
+	{
+	  return *static_cast<const _Base_ref*>(this);
+	}
+
+	reference&
+	flip() _GLIBCXX_NOEXCEPT
+	{
+	  _Base_ref::flip();
+	  return *this;
+	}
+      };
+
+      // 23.3.5.1 constructors:
+      _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
+      : _Base() { }
+
+#if __cplusplus >= 201103L
+      constexpr bitset(unsigned long long __val) noexcept
+#else
+      bitset(unsigned long __val)
+#endif
+      : _Base(__val) { }
+
+      template<typename _CharT, typename _Traits, typename _Alloc>
+        explicit
+        bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __pos = 0,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
+	: _Base(__str, __pos, __n) { }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 396. what are characters zero and one.
+      template<class _CharT, class _Traits, class _Alloc>
+	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __pos,
+	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
+	       __n,
+	       _CharT __zero, _CharT __one = _CharT('1'))
+	: _Base(__str, __pos, __n, __zero, __one) { }
+
+      bitset(const _Base& __x) : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      template<typename _CharT>
+        explicit
+        bitset(const _CharT* __str,
+	       typename std::basic_string<_CharT>::size_type __n
+	       = std::basic_string<_CharT>::npos,
+	       _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
+	: _Base(__str, __n, __zero, __one) { }
+#endif
+
+      // 23.3.5.2 bitset operations:
+      bitset<_Nb>&
+      operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() &= __rhs;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() |= __rhs;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() ^= __rhs;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator<<=(size_t __pos) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() <<= __pos;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator>>=(size_t __pos) _GLIBCXX_NOEXCEPT
+      {
+	_M_base() >>= __pos;
+	return *this;
+      }
+
+      bitset<_Nb>&
+      set() _GLIBCXX_NOEXCEPT
+      {
+	_Base::set();
+	return *this;
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 186. bitset::set() second parameter should be bool
+      bitset<_Nb>&
+      set(size_t __pos, bool __val = true)
+      {
+	_Base::set(__pos, __val);
+	return *this;
+      }
+
+      bitset<_Nb>&
+      reset() _GLIBCXX_NOEXCEPT
+      {
+	_Base::reset();
+	return *this;
+      }
+
+      bitset<_Nb>&
+      reset(size_t __pos)
+      {
+	_Base::reset(__pos);
+	return *this;
+      }
+
+      bitset<_Nb>
+      operator~() const _GLIBCXX_NOEXCEPT
+      { return bitset(~_M_base()); }
+
+      bitset<_Nb>&
+      flip() _GLIBCXX_NOEXCEPT
+      {
+	_Base::flip();
+	return *this;
+      }
+
+      bitset<_Nb>&
+      flip(size_t __pos)
+      {
+	_Base::flip(__pos);
+	return *this;
+      }
+
+      // element access:
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 11. Bitset minor problems
+      reference
+      operator[](size_t __pos)
+      {
+	return reference(_M_base()[__pos], this);
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 11. Bitset minor problems
+      _GLIBCXX_CONSTEXPR bool
+      operator[](size_t __pos) const
+      {
+	return _Base::operator[](__pos);
+      }
+
+      using _Base::to_ulong;
+#if __cplusplus >= 201103L
+      using _Base::to_ullong;
+#endif
+
+      template <typename _CharT, typename _Traits, typename _Alloc>
+        std::basic_string<_CharT, _Traits, _Alloc>
+        to_string() const
+        { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 396. what are characters zero and one.
+      template<class _CharT, class _Traits, class _Alloc>
+	std::basic_string<_CharT, _Traits, _Alloc>
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{
+	  return _M_base().template
+	    to_string<_CharT, _Traits, _Alloc>(__zero, __one);
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 434. bitset::to_string() hard to use.
+      template<typename _CharT, typename _Traits>
+        std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+        to_string() const
+        { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 853. to_string needs updating with zero and one.
+      template<class _CharT, class _Traits>
+	std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{ return to_string<_CharT, _Traits,
+	                   std::allocator<_CharT> >(__zero, __one); }
+
+      template<typename _CharT>
+        std::basic_string<_CharT, std::char_traits<_CharT>,
+                          std::allocator<_CharT> >
+        to_string() const
+        {
+          return to_string<_CharT, std::char_traits<_CharT>,
+                           std::allocator<_CharT> >();
+        }
+
+      template<class _CharT>
+	std::basic_string<_CharT, std::char_traits<_CharT>,
+	                  std::allocator<_CharT> >
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{
+	  return to_string<_CharT, std::char_traits<_CharT>,
+	                   std::allocator<_CharT> >(__zero, __one);
+	}
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string() const
+      {
+	return to_string<char,std::char_traits<char>,std::allocator<char> >();
+      }
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string(char __zero, char __one = '1') const
+      {
+	return to_string<char, std::char_traits<char>,
+	                 std::allocator<char> >(__zero, __one);
+      }
+
+      using _Base::count;
+      using _Base::size;
+
+      bool
+      operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
+      { return _M_base() == __rhs; }
+
+      bool
+      operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
+      { return _M_base() != __rhs; }
+
+      using _Base::test;
+      using _Base::all;
+      using _Base::any;
+      using _Base::none;
+
+      bitset<_Nb>
+      operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT
+      { return bitset<_Nb>(_M_base() << __pos); }
+
+      bitset<_Nb>
+      operator>>(size_t __pos) const _GLIBCXX_NOEXCEPT
+      { return bitset<_Nb>(_M_base() >> __pos); }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT
+      { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT
+      { return *this; }
+    };
+
+  template<size_t _Nb>
+    bitset<_Nb>
+    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    { return bitset<_Nb>(__x) &= __y; }
+
+  template<size_t _Nb>
+    bitset<_Nb>
+    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    { return bitset<_Nb>(__x) |= __y; }
+
+  template<size_t _Nb>
+    bitset<_Nb>
+    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    { return bitset<_Nb>(__x) ^= __y; }
+
+  template<typename _CharT, typename _Traits, size_t _Nb>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
+    { return __is >> __x._M_base(); }
+
+  template<typename _CharT, typename _Traits, size_t _Nb>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const bitset<_Nb>& __x)
+    { return __os << __x._M_base(); }
+} // namespace __profile
+
+#if __cplusplus >= 201103L
+  // DR 1182.
+  /// std::hash specialization for bitset.
+  template<size_t _Nb>
+    struct hash<__profile::bitset<_Nb>>
+    : public __hash_base<size_t, __profile::bitset<_Nb>>
+    {
+      size_t
+      operator()(const __profile::bitset<_Nb>& __b) const noexcept
+      { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
+    };
+#endif
+
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/deque b/gcc-4.9/libstdc++-v3/include/profile/deque
new file mode 100644
index 0000000..2c4f9cb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/deque
@@ -0,0 +1,478 @@
+// Profiling deque implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/deque
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_DEQUE
+#define _GLIBCXX_PROFILE_DEQUE 1
+
+#include <deque>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /// Class std::deque wrapper with performance instrumentation.
+  template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
+    class deque
+    : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>
+    {
+      typedef  _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
+
+    public:
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef typename _Base::iterator             iterator;
+      typedef typename _Base::const_iterator       const_iterator;
+      typedef typename _Base::reverse_iterator     reverse_iterator;
+      typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+
+      typedef _Tp				    value_type;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+
+      // 23.2.1.1 construct/copy/destroy:
+
+      deque()
+      : _Base() { }
+
+      explicit
+      deque(const _Allocator& __a)
+      : _Base(__a) { }
+
+#if __cplusplus >= 201103L
+      explicit
+      deque(size_type __n)
+      : _Base(__n) { }
+
+      deque(size_type __n, const _Tp& __value,
+	    const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) { }
+#else
+      explicit
+      deque(size_type __n, const _Tp& __value = _Tp(),
+	    const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) { }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        deque(_InputIterator __first, _InputIterator __last,
+	      const _Allocator& __a = _Allocator())
+	: _Base(__first, __last, __a)
+        { }
+
+      deque(const deque& __x)
+      : _Base(__x) { }
+
+      deque(const _Base& __x)
+      : _Base(__x) { }
+
+#if __cplusplus >= 201103L
+      deque(deque&& __x)
+      : _Base(std::move(__x))
+      { }
+
+      deque(initializer_list<value_type> __l,
+	    const allocator_type& __a = allocator_type())
+      : _Base(__l, __a) { }
+#endif
+
+      ~deque() _GLIBCXX_NOEXCEPT { }
+
+      deque&
+      operator=(const deque& __x)
+      {
+	*static_cast<_Base*>(this) = __x;
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      deque&
+      operator=(deque&& __x) noexcept
+      {
+	// NB: DR 1204.
+	// NB: DR 675.
+	this->clear();
+	this->swap(__x);
+	return *this;
+      }
+
+      deque&
+      operator=(initializer_list<value_type> __l)
+      {
+	*static_cast<_Base*>(this) = __l;
+	return *this;
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+	  _Base::assign(__first, __last);
+	}
+
+      void
+      assign(size_type __n, const _Tp& __t)
+      {
+	_Base::assign(__n, __t);
+      }
+
+#if __cplusplus >= 201103L
+      void
+      assign(initializer_list<value_type> __l)
+      {
+	_Base::assign(__l);
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin()); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin()); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end()); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end()); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end()); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // 23.2.1.2 capacity:
+      using _Base::size;
+      using _Base::max_size;
+
+#if __cplusplus >= 201103L
+      void
+      resize(size_type __sz)
+      {
+	_Base::resize(__sz);
+      }
+
+      void
+      resize(size_type __sz, const _Tp& __c)
+      {
+	_Base::resize(__sz, __c);
+      }
+#else
+      void
+      resize(size_type __sz, _Tp __c = _Tp())
+      {
+	_Base::resize(__sz, __c);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      using _Base::shrink_to_fit;
+#endif
+
+      using _Base::empty;
+
+      // element access:
+      reference
+      operator[](size_type __n) _GLIBCXX_NOEXCEPT
+      {
+	return _M_base()[__n];
+      }
+
+      const_reference
+      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
+      {
+	return _M_base()[__n];
+      }
+
+      using _Base::at;
+
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      {
+	return _Base::front();
+      }
+
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      {
+	return _Base::front();
+      }
+
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      {
+	return _Base::back();
+      }
+
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      {
+	return _Base::back();
+      }
+
+      // 23.2.1.3 modifiers:
+      void
+      push_front(const _Tp& __x)
+      {
+	_Base::push_front(__x);
+      }
+
+      void
+      push_back(const _Tp& __x)
+      {
+	_Base::push_back(__x);
+      }
+
+#if __cplusplus >= 201103L
+      void
+      push_front(_Tp&& __x)
+      { emplace_front(std::move(__x)); }
+
+      void
+      push_back(_Tp&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_front(_Args&&... __args)
+	{
+	  _Base::emplace_front(std::forward<_Args>(__args)...);
+	}
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args)
+	{
+	  _Base::emplace_back(std::forward<_Args>(__args)...);
+	}
+
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args)
+	{
+	  typename _Base::iterator __res = _Base::emplace(__position,
+					    std::forward<_Args>(__args)...);
+	  return iterator(__res);
+	}
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const _Tp& __x)
+#else
+      insert(iterator __position, const _Tp& __x)
+#endif
+      {
+	typename _Base::iterator __res = _Base::insert(__position, __x);
+	return iterator(__res);
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, _Tp&& __x)
+      { return emplace(__position, std::move(__x)); }
+
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      { return _Base::insert(__p, __l); }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, size_type __n, const _Tp& __x)
+      { return _Base::insert(__position, __n, __x); }
+#else
+      void
+      insert(iterator __position, size_type __n, const _Tp& __x)
+      { _Base::insert(__position, __n, __x); }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert(const_iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        { return _Base::insert(__position, __first, __last); }
+#else
+      template<typename _InputIterator>
+        void
+        insert(iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        { _Base::insert(__position, __first, __last); }
+#endif
+
+      void
+      pop_front() _GLIBCXX_NOEXCEPT
+      {
+	_Base::pop_front();
+      }
+
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      {
+	_Base::pop_back();
+      }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position)
+#else
+      erase(iterator __position)	
+#endif
+      {
+	return _Base::erase(__position);
+      }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last)
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+        return _Base::erase(__first, __last);
+      }
+
+      void
+      swap(deque& __x) _GLIBCXX_NOEXCEPT
+      {
+	_Base::swap(__x);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+	_Base::clear();
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+    };
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const deque<_Tp, _Alloc>& __lhs,
+	      const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const deque<_Tp, _Alloc>& __lhs,
+	       const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const deque<_Tp, _Alloc>& __lhs,
+	      const deque<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __profile
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/forward_list b/gcc-4.9/libstdc++-v3/include/profile/forward_list
new file mode 100644
index 0000000..260f1d6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/forward_list
@@ -0,0 +1,182 @@
+// <forward_list> -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/forward_list
+ *  This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_FORWARD_LIST
+#define _GLIBCXX_PROFILE_FORWARD_LIST 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <forward_list>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /// Class std::forward_list wrapper with performance instrumentation.
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class forward_list
+    : public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc>
+    {
+      typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
+
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type;
+
+      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
+
+    public:
+      typedef typename _Base::size_type             size_type;
+
+      // 23.2.3.1 construct/copy/destroy:
+      explicit
+      forward_list(const _Alloc& __al = _Alloc())
+      : _Base(__al) { }
+
+      forward_list(const forward_list& __list, const _Alloc& __al)
+      : _Base(__list, __al)
+      { }
+
+      forward_list(forward_list&& __list, const _Alloc& __al)
+      : _Base(std::move(__list), __al)
+      { }
+
+      explicit
+      forward_list(size_type __n, const _Alloc& __al = _Alloc())
+      : _Base(__n, __al)
+      { }
+
+      forward_list(size_type __n, const _Tp& __value,
+                   const _Alloc& __al = _Alloc())
+      : _Base(__n, __value, __al)
+      { }
+
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+        forward_list(_InputIterator __first, _InputIterator __last,
+                     const _Alloc& __al = _Alloc())
+        : _Base(__first, __last, __al)
+        { }
+
+      forward_list(const forward_list& __list)
+      : _Base(__list)
+      { }
+
+      forward_list(forward_list&& __list) noexcept
+      : _Base(std::move(__list)) { }
+
+      forward_list(std::initializer_list<_Tp> __il,
+                   const _Alloc& __al = _Alloc())
+      : _Base(__il, __al)
+      { }
+
+      ~forward_list() noexcept
+      { }
+
+      forward_list&
+      operator=(const forward_list& __list)
+      {
+	static_cast<_Base&>(*this) = __list;
+	return *this;
+      }
+
+      forward_list&
+      operator=(forward_list&& __list)
+      noexcept(_Node_alloc_traits::_S_nothrow_move())
+      {
+	static_cast<_Base&>(*this) = std::move(__list);
+	return *this;
+      }
+
+      forward_list&
+      operator=(std::initializer_list<_Tp> __il)
+      {
+	static_cast<_Base&>(*this) = __il;
+        return *this;
+      }
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+    };
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return __lx._M_base() == __ly._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const forward_list<_Tp, _Alloc>& __lx,
+              const forward_list<_Tp, _Alloc>& __ly)
+    { return __lx._M_base() < __ly._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__lx == __ly); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const forward_list<_Tp, _Alloc>& __lx,
+              const forward_list<_Tp, _Alloc>& __ly)
+    { return (__ly < __lx); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__lx < __ly); }
+
+  /// Based on operator<
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const forward_list<_Tp, _Alloc>& __lx,
+               const forward_list<_Tp, _Alloc>& __ly)
+    { return !(__ly < __lx); }
+
+  /// See std::forward_list::swap().
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(forward_list<_Tp, _Alloc>& __lx,
+	 forward_list<_Tp, _Alloc>& __ly)
+    { __lx.swap(__ly); }
+
+} // namespace __profile
+} // namespace std
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler.h
new file mode 100644
index 0000000..cddec07
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler.h
@@ -0,0 +1,405 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler.h
+ *  @brief Interface of the profiling runtime library.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_H
+#define _GLIBCXX_PROFILE_PROFILER_H 1
+
+#include <bits/c++config.h>
+
+// Mechanism to define data with inline linkage.
+#define _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__type, __name)             \
+  inline __type&                                                        \
+  __get_##__name()                                                      \
+  {                                                                     \
+    static __type __name;                                               \
+    return __name;                                                      \
+  }
+#define _GLIBCXX_PROFILE_DEFINE_DATA(__type, __name, __initial_value...) \
+  inline __type& __get_##__name() {                                      \
+    static __type __name(__initial_value);                               \
+    return __name;                                                       \
+  }
+#define _GLIBCXX_PROFILE_DATA(__name) \
+  __get_##__name()
+
+namespace __gnu_profile
+{
+  /** @brief Reentrance guard.
+   *
+   * Mechanism to protect all __gnu_profile operations against recursion,
+   * multithreaded and exception reentrance.
+   */
+  struct __reentrance_guard
+  {
+    static bool
+    __get_in()
+    {
+      if (__inside() == true)
+	return false;
+      else
+	{
+	  __inside() = true;
+	  return true;
+	}
+    }
+
+    static bool&
+    __inside()
+    {
+      static __thread bool _S_inside(false);
+      return _S_inside;
+    }
+
+    __reentrance_guard() { }
+    ~__reentrance_guard() { __inside() = false; }
+  };
+
+#define _GLIBCXX_PROFILE_REENTRANCE_GUARD(__x...)	      	\
+  {                                                             \
+    if (__gnu_profile::__reentrance_guard::__get_in())          \
+    {                                                           \
+      __gnu_profile::__reentrance_guard __get_out; 		\
+      __x;                                                      \
+    }                                                           \
+  }
+
+  // Forward declarations of implementation functions.
+  // Don't use any __gnu_profile:: in user code.
+  // Instead, use the __profcxx... macros, which offer guarded access.
+  bool __turn_on();
+  bool __turn_off();
+  bool __is_invalid();
+  bool __is_on();
+  bool __is_off();
+  void __report(void);
+  void __trace_hashtable_size_resize(const void*, std::size_t, std::size_t);
+  void __trace_hashtable_size_destruct(const void*, std::size_t, std::size_t);
+  void __trace_hashtable_size_construct(const void*, std::size_t);
+  void __trace_vector_size_resize(const void*, std::size_t, std::size_t);
+  void __trace_vector_size_destruct(const void*, std::size_t, std::size_t);
+  void __trace_vector_size_construct(const void*, std::size_t);
+  void __trace_hash_func_destruct(const void*, std::size_t, std::size_t,
+				  std::size_t);
+  void __trace_hash_func_construct(const void*);
+  void __trace_vector_to_list_destruct(const void*);
+  void __trace_vector_to_list_construct(const void*);
+  void __trace_vector_to_list_insert(const void*, std::size_t, std::size_t);
+  void __trace_vector_to_list_iterate(const void*, std::size_t);
+  void __trace_vector_to_list_invalid_operator(const void*);
+  void __trace_vector_to_list_resize(const void*, std::size_t, std::size_t);
+  void __trace_vector_to_list_find(const void*, std::size_t);
+
+  void __trace_list_to_slist_destruct(const void*);
+  void __trace_list_to_slist_construct(const void*);
+  void __trace_list_to_slist_rewind(const void*);
+  void __trace_list_to_slist_operation(const void*);
+
+  void __trace_list_to_vector_destruct(const void*);
+  void __trace_list_to_vector_construct(const void*);
+  void __trace_list_to_vector_insert(const void*, std::size_t, std::size_t);
+  void __trace_list_to_vector_iterate(const void*, std::size_t);
+  void __trace_list_to_vector_invalid_operator(const void*);
+  void __trace_list_to_vector_resize(const void*, std::size_t, std::size_t);
+
+  void __trace_list_to_set_destruct(const void*);
+  void __trace_list_to_set_construct(const void*);
+  void __trace_list_to_set_insert(const void*, std::size_t, std::size_t); 
+  void __trace_list_to_set_iterate(const void*, std::size_t);
+  void __trace_list_to_set_invalid_operator(const void*);
+  void __trace_list_to_set_find(const void*, std::size_t); 
+
+  void __trace_map_to_unordered_map_construct(const void*);
+  void __trace_map_to_unordered_map_invalidate(const void*);
+  void __trace_map_to_unordered_map_insert(const void*, std::size_t,
+					   std::size_t);
+  void __trace_map_to_unordered_map_erase(const void*, std::size_t,
+					  std::size_t);
+  void __trace_map_to_unordered_map_iterate(const void*, std::size_t);
+  void __trace_map_to_unordered_map_find(const void*, std::size_t);
+  void __trace_map_to_unordered_map_destruct(const void*);
+} // namespace __gnu_profile
+
+// Master switch turns on all diagnostics that are not explicitly turned off.
+#ifdef _GLIBCXX_PROFILE
+#ifndef _GLIBCXX_PROFILE_NO_HASHTABLE_TOO_SMALL
+#define _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_HASHTABLE_TOO_LARGE
+#define _GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_VECTOR_TOO_SMALL
+#define _GLIBCXX_PROFILE_VECTOR_TOO_SMALL
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_VECTOR_TOO_LARGE
+#define _GLIBCXX_PROFILE_VECTOR_TOO_LARGE
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_INEFFICIENT_HASH
+#define _GLIBCXX_PROFILE_INEFFICIENT_HASH
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_VECTOR_TO_LIST
+#define _GLIBCXX_PROFILE_VECTOR_TO_LIST
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_LIST_TO_SLIST
+#define _GLIBCXX_PROFILE_LIST_TO_SLIST
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_LIST_TO_VECTOR
+#define _GLIBCXX_PROFILE_LIST_TO_VECTOR
+#endif
+#ifndef _GLIBCXX_PROFILE_NO_MAP_TO_UNORDERED_MAP
+#define _GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP
+#endif
+#endif
+
+// Expose global management routines to user code.
+#ifdef _GLIBCXX_PROFILE
+#define __profcxx_report() \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__report())
+#define __profcxx_turn_on() \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__turn_on())
+#define __profcxx_turn_off() \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__turn_off())
+#define __profcxx_is_invalid() \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_invalid())
+#define __profcxx_is_on() \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_on())
+#define __profcxx_is_off() \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_off())
+#else
+#define __profcxx_report()
+#define __profcxx_turn_on()
+#define __profcxx_turn_off()
+#define __profcxx_is_invalid()
+#define __profcxx_is_on()
+#define __profcxx_is_off()
+#endif
+
+// Turn on/off instrumentation for HASHTABLE_TOO_SMALL and HASHTABLE_TOO_LARGE.
+#if (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \
+     || defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE))
+#define __profcxx_hashtable_resize(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_hashtable_size_resize(__x))
+#define __profcxx_hashtable_destruct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_hashtable_size_destruct(__x))
+#define __profcxx_hashtable_construct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_hashtable_size_construct(__x))
+#else
+#define __profcxx_hashtable_resize(__x...)  
+#define __profcxx_hashtable_destruct(__x...) 
+#define __profcxx_hashtable_construct(__x...)  
+#endif
+
+// Turn on/off instrumentation for VECTOR_TOO_SMALL and VECTOR_TOO_LARGE.
+#if (defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \
+     || defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE))
+#define __profcxx_vector_resize(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_size_resize(__x))
+#define __profcxx_vector_destruct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_size_destruct(__x))
+#define __profcxx_vector_construct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_size_construct(__x))
+#else
+#define __profcxx_vector_resize(__x...)  
+#define __profcxx_vector_destruct(__x...) 
+#define __profcxx_vector_construct(__x...)  
+#endif 
+
+// Turn on/off instrumentation for INEFFICIENT_HASH.
+#if defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH)
+#define __profcxx_inefficient_hash_is_on() \
+  __gnu_profile::__is_on()
+#define __profcxx_hashtable_construct2(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_hash_func_construct(__x))
+#define __profcxx_hashtable_destruct2(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_hash_func_destruct(__x))
+#else
+#define __profcxx_inefficient_hash_is_on() false
+#define __profcxx_hashtable_destruct2(__x...)
+#define __profcxx_hashtable_construct2(__x...)
+#endif
+
+// Turn on/off instrumentation for VECTOR_TO_LIST.
+#if defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST)
+#define __profcxx_vector_construct2(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_to_list_construct(__x))
+#define __profcxx_vector_destruct2(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_to_list_destruct(__x))
+#define __profcxx_vector_insert(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_to_list_insert(__x))
+#define __profcxx_vector_iterate(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_to_list_iterate(__x))
+#define __profcxx_vector_invalid_operator(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_to_list_invalid_operator(__x))
+#define __profcxx_vector_resize2(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_to_list_resize(__x))
+#define __profcxx_vector_find(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_vector_to_list_find(__x))
+#else
+#define __profcxx_vector_destruct2(__x...)
+#define __profcxx_vector_construct2(__x...)
+#define __profcxx_vector_insert(__x...)
+#define __profcxx_vector_iterate(__x...)
+#define __profcxx_vector_invalid_operator(__x...)
+#define __profcxx_vector_resize2(__x...)
+#define __profcxx_vector_find(__x...)
+#endif
+
+// Turn on/off instrumentation for LIST_TO_VECTOR. 
+#if defined(_GLIBCXX_PROFILE_LIST_TO_VECTOR)
+#define __profcxx_list_construct2(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_vector_construct(__x))
+#define __profcxx_list_destruct2(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_vector_destruct(__x))
+#define __profcxx_list_insert(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_vector_insert(__x))
+#define __profcxx_list_iterate(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_vector_iterate(__x))
+#define __profcxx_list_invalid_operator(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_vector_invalid_operator(__x))
+#else
+#define __profcxx_list_destruct2(__x...)
+#define __profcxx_list_construct2(__x...)
+#define __profcxx_list_insert(__x...)
+#define __profcxx_list_iterate(__x...)
+#define __profcxx_list_invalid_operator(__x...)
+#endif
+
+// Turn on/off instrumentation for LIST_TO_SLIST.  
+#if defined(_GLIBCXX_PROFILE_LIST_TO_SLIST)
+#define __profcxx_list_rewind(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_slist_rewind(__x))
+#define __profcxx_list_operation(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_slist_operation(__x))
+#define __profcxx_list_destruct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_slist_destruct(__x))
+#define __profcxx_list_construct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_list_to_slist_construct(__x))
+#else
+#define __profcxx_list_rewind(__x...)  
+#define __profcxx_list_operation(__x...)
+#define __profcxx_list_destruct(__x...) 
+#define __profcxx_list_construct(__x...)  
+#endif 
+
+// Turn on/off instrumentation for MAP_TO_UNORDERED_MAP.
+#if defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP)
+#define __profcxx_map_to_unordered_map_construct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_map_to_unordered_map_construct(__x))
+#define __profcxx_map_to_unordered_map_destruct(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_map_to_unordered_map_destruct(__x))
+#define __profcxx_map_to_unordered_map_insert(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_map_to_unordered_map_insert(__x))
+#define __profcxx_map_to_unordered_map_erase(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_map_to_unordered_map_erase(__x))
+#define __profcxx_map_to_unordered_map_iterate(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_map_to_unordered_map_iterate(__x))
+#define __profcxx_map_to_unordered_map_invalidate(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_map_to_unordered_map_invalidate(__x))
+#define __profcxx_map_to_unordered_map_find(__x...) \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
+      __gnu_profile::__trace_map_to_unordered_map_find(__x))
+#else
+#define __profcxx_map_to_unordered_map_construct(__x...) \
+  
+#define __profcxx_map_to_unordered_map_destruct(__x...)
+#define __profcxx_map_to_unordered_map_insert(__x...)
+#define __profcxx_map_to_unordered_map_erase(__x...)
+#define __profcxx_map_to_unordered_map_iterate(__x...)
+#define __profcxx_map_to_unordered_map_invalidate(__x...)
+#define __profcxx_map_to_unordered_map_find(__x...)
+#endif
+
+// Set default values for compile-time customizable variables.
+#ifndef _GLIBCXX_PROFILE_TRACE_PATH_ROOT
+#define _GLIBCXX_PROFILE_TRACE_PATH_ROOT "libstdcxx-profile"
+#endif
+#ifndef _GLIBCXX_PROFILE_TRACE_ENV_VAR
+#define _GLIBCXX_PROFILE_TRACE_ENV_VAR "_GLIBCXX_PROFILE_TRACE_PATH_ROOT"
+#endif
+#ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR
+#define _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR \
+  "_GLIBCXX_PROFILE_MAX_WARN_COUNT"
+#endif
+#ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT
+#define _GLIBCXX_PROFILE_MAX_WARN_COUNT 10
+#endif
+#ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH
+#define _GLIBCXX_PROFILE_MAX_STACK_DEPTH 32
+#endif
+#ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR
+#define _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR \
+  "_GLIBCXX_PROFILE_MAX_STACK_DEPTH"
+#endif
+#ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC
+#define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC (1 << 28)
+#endif
+#ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR
+#define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR \
+  "_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC"
+#endif
+
+// Instrumentation hook implementations.
+#include "profile/impl/profiler_hash_func.h"
+#include "profile/impl/profiler_hashtable_size.h"
+#include "profile/impl/profiler_map_to_unordered_map.h"
+#include "profile/impl/profiler_vector_size.h"
+#include "profile/impl/profiler_vector_to_list.h"
+#include "profile/impl/profiler_list_to_slist.h"
+#include "profile/impl/profiler_list_to_vector.h"
+
+#endif // _GLIBCXX_PROFILE_PROFILER_H
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_algos.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_algos.h
new file mode 100644
index 0000000..7a34ba7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_algos.h
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_algos.h
+ *  @brief Algorithms used by the profile extension.
+ *
+ *  This file is needed to avoid including \<algorithm\> or \<bits/stl_algo.h\>.
+ *  Including those files would result in recursive includes.
+ *  These implementations are oversimplified.  In general, efficiency may be
+ *  sacrificed to minimize maintenance overhead.
+ */
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_ALGOS_H
+#define _GLIBCXX_PROFILE_PROFILER_ALGOS_H 1
+
+namespace __gnu_profile
+{
+  /* Helper for __top_n.  Insert in sorted vector, but not beyond Nth elem.  */
+  template<typename _Container>
+    void
+    __insert_top_n(_Container& __output,
+		   const typename _Container::value_type& __value,
+		   typename _Container::size_type __n)
+    {
+      typename _Container::iterator __it = __output.begin();
+      typename _Container::size_type __count = 0;
+
+      // Skip up to N - 1 elements larger than VALUE.
+      // XXX: Could do binary search for random iterators.
+      while (true)
+	{
+	  if (__count >= __n)
+	    // VALUE is not in top N.
+	    return;
+
+	  if (__it == __output.end())
+	    break;
+
+	  if (*__it < __value)
+	    break;
+
+	  ++__it;
+	  ++__count;
+	}
+
+      __output.insert(__it, __value);
+    }
+
+  /* Copy the top N elements in INPUT, sorted in reverse order, to OUTPUT.  */
+  template<typename _Container>
+    void
+    __top_n(const _Container& __input, _Container& __output,
+	    typename _Container::size_type __n)
+    {
+      __output.clear();
+      typename _Container::const_iterator __it;
+      for (__it = __input.begin(); __it != __input.end(); ++__it)
+	__insert_top_n(__output, *__it, __n);
+    }
+
+  /* Simplified clone of std::for_each.  */
+  template<typename _InputIterator, typename _Function>
+    _Function 
+    __for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+      for (; __first != __last; ++__first)
+	__f(*__first);
+      return __f;
+    }
+
+  /* Simplified clone of std::remove.  */
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    __remove(_ForwardIterator __first, _ForwardIterator __last,
+	     const _Tp& __value)
+    {
+      if(__first == __last)
+	return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for(; __first != __last; ++__first)
+	if(!(*__first == __value))
+	  {
+	    *__result = *__first;
+	    ++__result;
+	  }
+      return __result;
+    }
+} // namespace __gnu_profile
+
+#endif /* _GLIBCXX_PROFILE_PROFILER_ALGOS_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_container_size.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_container_size.h
new file mode 100644
index 0000000..32311b1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_container_size.h
@@ -0,0 +1,215 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_container_size.h
+ *  @brief Diagnostics for container sizes.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H
+#define _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H 1
+
+#include <sstream>
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+
+namespace __gnu_profile
+{
+  /** @brief A container size instrumentation line in the object table.  */
+  class __container_size_info
+  : public __object_info_base 
+  {
+  public:
+    __container_size_info()
+    : _M_init(0), _M_max(0), _M_min(0), _M_total(0), _M_item_min(0),
+      _M_item_max(0), _M_item_total(0), _M_count(0), _M_resize(0), _M_cost(0) 
+    { }
+
+    __container_size_info(const __container_size_info& __o)
+    : __object_info_base(__o), _M_init(__o._M_init), _M_max(__o._M_max),
+      _M_min(__o._M_min), _M_total(__o._M_total),
+      _M_item_min(__o._M_item_min), _M_item_max(__o._M_item_max),
+      _M_item_total(__o._M_item_total), _M_count(__o._M_count),
+      _M_resize(__o._M_resize), _M_cost(__o._M_cost)
+    { }
+
+    __container_size_info(__stack_t __stack, std::size_t __num)
+    : __object_info_base(__stack), _M_init(__num), _M_max(__num),
+      _M_min(0), _M_total(0), _M_item_min(0), _M_item_max(0),
+      _M_item_total(0), _M_count(0), _M_resize(0), _M_cost(0)
+    { }
+
+    virtual ~__container_size_info() { }
+
+    void
+    __write(FILE* __f) const
+    {
+      std::fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n", 
+		   _M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max,
+		   _M_total, _M_item_min, _M_item_max, _M_item_total);
+    }
+
+    float
+    __magnitude() const
+    { return static_cast<float>(_M_cost); }
+
+    std::string
+    __advice() const
+    {
+      std::stringstream __message;
+      if (_M_init < _M_item_max)
+	__message << "change initial container size from " << _M_init
+		  << " to " << _M_item_max;
+      return __message.str();
+    }
+
+    void
+    __merge(const __container_size_info& __o)
+    {
+      _M_init        = std::max(_M_init, __o._M_init);
+      _M_max         = std::max(_M_max, __o._M_max);
+      _M_item_max    = std::max(_M_item_max, __o._M_item_max);
+      _M_min         = std::min(_M_min, __o._M_min);
+      _M_item_min    = std::min(_M_item_min, __o._M_item_min);
+      _M_total      += __o._M_total;
+      _M_item_total += __o._M_item_total;
+      _M_count      += __o._M_count;
+      _M_cost       += __o._M_cost;
+      _M_resize     += __o._M_resize;
+    }
+
+    // Call if a container is destructed or cleaned.
+    void
+    __destruct(std::size_t __num, std::size_t __inum)
+    {
+      _M_max = std::max(_M_max, __num);
+      _M_item_max = std::max(_M_item_max, __inum);
+      if (_M_min == 0)
+	{
+	  _M_min = __num; 
+	  _M_item_min = __inum;
+	}
+      else
+	{
+	  _M_min = std::min(_M_min, __num);
+	  _M_item_min = std::min(_M_item_min, __inum);
+	}
+      _M_total += __num;
+      _M_item_total += __inum;
+      _M_count += 1;
+    }
+
+    // Estimate the cost of resize/rehash. 
+    float
+    __resize_cost(std::size_t __from, std::size_t)
+    { return __from; }
+
+    // Call if container is resized.
+    void
+    __resize(std::size_t __from, std::size_t __to)
+    {
+      _M_cost += this->__resize_cost(__from, __to);
+      _M_resize += 1;
+      _M_max = std::max(_M_max, __to);
+    }
+
+  private:
+    std::size_t _M_init;
+    std::size_t _M_max;  // range of # buckets
+    std::size_t _M_min;
+    std::size_t _M_total;
+    std::size_t _M_item_min;  // range of # items
+    std::size_t _M_item_max;
+    std::size_t _M_item_total;
+    std::size_t _M_count;
+    std::size_t _M_resize;
+    std::size_t _M_cost;
+  };
+
+
+  /** @brief A container size instrumentation line in the stack table.  */
+  class __container_size_stack_info
+  : public __container_size_info
+  {
+  public:
+    __container_size_stack_info(const __container_size_info& __o)
+    : __container_size_info(__o) { }
+  };
+
+  
+  /** @brief Container size instrumentation trace producer.  */
+  class __trace_container_size
+  : public __trace_base<__container_size_info, __container_size_stack_info> 
+  {
+  public:
+    ~__trace_container_size() { }
+
+    __trace_container_size()
+    : __trace_base<__container_size_info, __container_size_stack_info>() { };
+
+    // Insert a new node at construct with object, callstack and initial size. 
+    void
+    __insert(const __object_t __obj, __stack_t __stack, std::size_t __num)
+    { __add_object(__obj, __container_size_info(__stack, __num)); }
+
+    // XXX Undefined?
+    void
+    __construct(const void* __obj, std::size_t __inum);
+  
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj, std::size_t __num, std::size_t __inum)
+    {
+      if (!__is_on())
+	return;
+
+      __object_t __obj_handle = static_cast<__object_t>(__obj);
+
+      __container_size_info* __object_info = __get_object_info(__obj_handle);
+      if (!__object_info)
+	return;
+
+      __object_info->__destruct(__num, __inum);
+      __retire_object(__obj_handle);
+    }
+
+    // Call at resize to set resize/cost information.
+    void
+    __resize(const void* __obj, int __from, int __to)
+    {
+      if (!__is_on())
+	return;
+
+      __container_size_info* __object_info = __get_object_info(__obj);
+      if (!__object_info)
+	return;
+
+      __object_info->__resize(__from, __to);
+    }
+  };
+
+} // namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_hash_func.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_hash_func.h
new file mode 100644
index 0000000..79e4c4a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_hash_func.h
@@ -0,0 +1,174 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_hash_func.h
+ *  @brief Data structures to represent profiling traces.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H
+#define _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H 1
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+
+namespace __gnu_profile
+{
+  /** @brief A hash performance instrumentation line in the object table.  */
+  class __hashfunc_info
+  : public __object_info_base
+  {
+  public:
+    __hashfunc_info()
+    : _M_longest_chain(0), _M_accesses(0), _M_hops(0) { }
+
+    __hashfunc_info(const __hashfunc_info& __o)
+    : __object_info_base(__o), _M_longest_chain(__o._M_longest_chain),
+      _M_accesses(__o._M_accesses), _M_hops(__o._M_hops) { }
+
+    __hashfunc_info(__stack_t __stack)
+    : __object_info_base(__stack), _M_longest_chain(0),
+      _M_accesses(0), _M_hops(0) { }
+
+    virtual ~__hashfunc_info() { }
+
+    void
+    __merge(const __hashfunc_info& __o)
+    {
+      _M_longest_chain  = std::max(_M_longest_chain, __o._M_longest_chain);
+      _M_accesses      += __o._M_accesses;
+      _M_hops          += __o._M_hops;
+    }
+
+    void
+    __destruct(std::size_t __chain, std::size_t __accesses,
+	       std::size_t __hops)
+    { 
+      _M_longest_chain  = std::max(_M_longest_chain, __chain);
+      _M_accesses      += __accesses;
+      _M_hops          += __hops;
+    }
+
+    void
+    __write(FILE* __f) const
+    { std::fprintf(__f, "%Zu %Zu %Zu\n", _M_hops,
+		   _M_accesses, _M_longest_chain); }
+
+    float
+    __magnitude() const
+    { return static_cast<float>(_M_hops); }
+
+    std::string
+    __advice() const
+    { return "change hash function"; }
+
+  private:
+    std::size_t _M_longest_chain;
+    std::size_t _M_accesses;
+    std::size_t _M_hops;
+  };
+
+
+  /** @brief A hash performance instrumentation line in the stack table.  */
+  class __hashfunc_stack_info 
+  : public __hashfunc_info
+  {
+  public:
+    __hashfunc_stack_info(const __hashfunc_info& __o)
+    : __hashfunc_info(__o) { }
+  };
+
+
+  /** @brief Hash performance instrumentation producer.  */
+  class __trace_hash_func
+  : public __trace_base<__hashfunc_info, __hashfunc_stack_info> 
+  {
+  public:
+    __trace_hash_func()
+    : __trace_base<__hashfunc_info, __hashfunc_stack_info>()
+    { __id = "hash-distr"; }
+
+    ~__trace_hash_func() {}
+    
+    // Insert a new node at construct with object, callstack and initial size.
+    void
+    __insert(__object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __hashfunc_info(__stack)); }
+
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj, std::size_t __chain,
+	       std::size_t __accesses, std::size_t __hops)
+    {
+      if (!__is_on())
+	return;
+
+      // First find the item from the live objects and update the informations.
+      __hashfunc_info* __objs = __get_object_info(__obj);
+      if (!__objs)
+	return;
+
+      __objs->__destruct(__chain, __accesses, __hops);
+      __retire_object(__obj);
+    }
+  };
+
+
+  inline void
+  __trace_hash_func_init()
+  { _GLIBCXX_PROFILE_DATA(_S_hash_func) = new __trace_hash_func(); }
+
+  inline void
+  __trace_hash_func_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_hash_func))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_hash_func)->__collect_warnings(__warnings);
+	_GLIBCXX_PROFILE_DATA(_S_hash_func)->__write(__f);
+      }
+  }
+
+  inline void
+  __trace_hash_func_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_hash_func)->__insert(__obj, __get_stack());
+  }
+
+  inline void
+  __trace_hash_func_destruct(const void* __obj, std::size_t __chain,
+			     std::size_t __accesses, std::size_t __hops)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_hash_func)->__destruct(__obj, __chain,
+						    __accesses, __hops);
+  }
+
+} // namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h
new file mode 100644
index 0000000..2b9a5c8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h
@@ -0,0 +1,98 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_hashtable_size.h
+ *  @brief Collection of hashtable size traces.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H
+#define _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H 1
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+#include "profile/impl/profiler_state.h"
+#include "profile/impl/profiler_container_size.h"
+
+namespace __gnu_profile
+{
+  /** @brief Hashtable size instrumentation trace producer.  */
+  class __trace_hashtable_size
+  : public __trace_container_size
+  {
+  public:
+    __trace_hashtable_size()
+    : __trace_container_size()
+    { __id = "hashtable-size"; }
+  };
+
+  inline void
+  __trace_hashtable_size_init()
+  { _GLIBCXX_PROFILE_DATA(_S_hashtable_size) = new __trace_hashtable_size(); }
+
+  inline void
+  __trace_hashtable_size_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_hashtable_size))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_hashtable_size)->
+	  __collect_warnings(__warnings);
+	_GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__write(__f);
+      }
+  }
+
+  inline void
+  __trace_hashtable_size_construct(const void* __obj, std::size_t __num)
+  {
+    if (!__profcxx_init())
+      return;
+  
+    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__insert(__obj, __get_stack(),
+						       __num);
+  }
+
+  inline void
+  __trace_hashtable_size_destruct(const void* __obj, std::size_t __num, 
+				  std::size_t __inum)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__destruct(__obj, __num, __inum);
+  }
+
+  inline void
+  __trace_hashtable_size_resize(const void* __obj, std::size_t __from, 
+				std::size_t __to)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__resize(__obj, __from, __to);
+  }
+
+} // namespace __gnu_profile
+
+#endif /* _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_list_to_slist.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_list_to_slist.h
new file mode 100644
index 0000000..5b489b2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_list_to_slist.h
@@ -0,0 +1,208 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_list_to_slist.h
+ *  @brief Diagnostics for list to slist.
+ */
+
+// Written by Changhee Jung.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H
+#define _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H 1
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+
+namespace __gnu_profile
+{
+  class __list2slist_info
+  : public __object_info_base
+  {
+  public:
+    __list2slist_info()
+    : _M_rewind(false), _M_operations(0) { }
+  
+    __list2slist_info(__stack_t __stack)
+    : __object_info_base(__stack), _M_rewind(false), _M_operations(0) { }
+
+    virtual ~__list2slist_info() { }
+
+    __list2slist_info(const __list2slist_info& __o)
+    : __object_info_base(__o), _M_rewind(__o._M_rewind),
+      _M_operations(__o._M_operations) { }
+  
+    // XXX: the magnitude should be multiplied with a constant factor F,
+    // where F is 1 when the malloc size class of list nodes is different
+    // from the malloc size class of slist nodes.  When they fall into the same
+    // class, the only slist benefit is from having to set fewer links, so
+    // the factor F should be much smaller, closer to 0 than to 1.
+    // This could be implemented by passing the size classes in the config 
+    // file.  For now, we always assume F to be 1.
+
+    float
+    __magnitude() const
+    {
+      if (!_M_rewind)
+	return _M_operations;
+      else
+	return 0;
+    }
+    
+    void
+    __merge(const __list2slist_info&) { }
+
+    void
+    __write(FILE* __f) const
+    { std::fprintf(__f, "%s\n", _M_rewind ? "invalid" : "valid"); }
+
+    std::string
+    __advice() const
+    { return "change std::list to std::forward_list"; }
+
+    void
+    __opr_rewind()
+    {
+      _M_rewind = true;
+      _M_valid = false;
+    }
+
+    void
+    __record_operation()
+    { ++_M_operations; }
+
+    bool
+    __has_rewind()
+    { return _M_rewind; }
+
+  private:
+    bool _M_rewind;
+    std::size_t _M_operations;
+  };
+
+  class __list2slist_stack_info
+  : public __list2slist_info
+  {
+  public:
+    __list2slist_stack_info(const __list2slist_info& __o) 
+    : __list2slist_info(__o) { }
+  };
+
+  class __trace_list_to_slist
+  : public __trace_base<__list2slist_info, __list2slist_stack_info> 
+  {
+  public:
+    ~__trace_list_to_slist() { }
+
+    __trace_list_to_slist()
+    : __trace_base<__list2slist_info, __list2slist_stack_info>()
+    { __id = "list-to-slist"; }
+
+    void
+    __opr_rewind(const void* __obj)
+    {
+      __list2slist_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__opr_rewind();
+    }
+
+    void
+    __record_operation(const void* __obj)
+    {
+      __list2slist_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__record_operation();
+    }
+
+    void
+    __insert(const __object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __list2slist_info(__stack)); }
+  
+    void
+    __destruct(const void* __obj)
+    {
+      if (!__is_on())
+	return;
+
+      __list2slist_info* __res = __get_object_info(__obj);
+      if (!__res)
+	return;
+
+      __retire_object(__obj);
+    }
+  };
+
+
+  inline void
+  __trace_list_to_slist_init()
+  { _GLIBCXX_PROFILE_DATA(_S_list_to_slist) = new __trace_list_to_slist(); }
+
+  inline void
+  __trace_list_to_slist_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_list_to_slist))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_list_to_slist)->
+	  __collect_warnings(__warnings);
+	_GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__write(__f);
+      }
+  }
+
+  inline void
+  __trace_list_to_slist_rewind(const void* __obj) 
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__opr_rewind(__obj);
+  }
+
+  inline void
+  __trace_list_to_slist_operation(const void* __obj) 
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__record_operation(__obj);
+  }
+
+  inline void
+  __trace_list_to_slist_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__insert(__obj, __get_stack());
+  }
+
+  inline void
+  __trace_list_to_slist_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__destruct(__obj);
+  }
+
+} // namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_list_to_vector.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_list_to_vector.h
new file mode 100644
index 0000000..c98df5e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_list_to_vector.h
@@ -0,0 +1,324 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_list_to_vector.h
+ *  @brief diagnostics for list to vector.
+ */
+
+// Written by Changhee Jung.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H
+#define _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H 1
+
+#include <sstream>
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+
+namespace __gnu_profile
+{
+  /** @brief A list-to-vector instrumentation line in the object table.  */
+  class __list2vector_info
+  : public __object_info_base
+  {
+  public:
+    __list2vector_info()
+    : _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0),
+      _M_vector_cost(0), _M_valid(true), _M_max_size(0) { }
+
+    __list2vector_info(__stack_t __stack)
+    : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0),
+      _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true),
+      _M_max_size(0) { }
+
+    virtual ~__list2vector_info() { }
+
+    __list2vector_info(const __list2vector_info& __o)
+    : __object_info_base(__o), _M_shift_count(__o._M_shift_count),
+      _M_iterate(__o._M_iterate), _M_resize(__o._M_resize),
+      _M_list_cost(__o._M_list_cost), _M_vector_cost(__o._M_vector_cost),
+      _M_valid(__o._M_valid), _M_max_size(__o._M_max_size) { }
+
+    void
+    __merge(const __list2vector_info& __o)
+    {
+      _M_shift_count  += __o._M_shift_count;
+      _M_iterate      += __o._M_iterate;
+      _M_vector_cost  += __o._M_vector_cost;
+      _M_list_cost    += __o._M_list_cost;
+      _M_valid        &= __o._M_valid;
+      _M_resize       += __o._M_resize;
+      _M_max_size     = std::max( _M_max_size, __o._M_max_size);
+    }
+
+    void
+    __write(FILE* __f) const
+    {
+      std::fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count,
+		   _M_resize, _M_iterate, _M_vector_cost, _M_list_cost);
+    }
+
+    float
+    __magnitude() const
+    { return _M_list_cost - _M_vector_cost; }
+  
+    std::string
+    __advice() const
+    {
+      std::stringstream __sstream;
+      __sstream 
+	<< "change std::list to std::vector and its initial size from 0 to "
+	<< _M_max_size;
+      return __sstream.str();
+    }
+
+    std::size_t
+    __shift_count()
+    { return _M_shift_count; }
+  
+    std::size_t
+    __iterate()
+    { return _M_iterate; }
+  
+    float
+    __list_cost()
+    { return _M_list_cost; }
+  
+    std::size_t
+    __resize()
+    { return _M_resize; }
+  
+    void
+    __set_list_cost(float __lc)
+    { _M_list_cost = __lc; }
+    
+    void
+    __set_vector_cost(float __vc)
+    { _M_vector_cost = __vc; }
+    
+    bool
+    __is_valid()
+    { return _M_valid; }
+    
+    void
+    __set_invalid()
+    { _M_valid = false; }
+
+    void
+    __opr_insert(std::size_t __shift, std::size_t __size)
+    {
+      _M_shift_count += __shift;
+      _M_max_size = std::max(_M_max_size, __size);
+    }
+
+    void
+    __opr_iterate(std::size_t __num)
+    { _M_iterate += __num;}
+
+    void
+    __resize(std::size_t __from, std::size_t)
+    { _M_resize += __from; }
+
+  private:
+    std::size_t _M_shift_count;
+    std::size_t _M_iterate;
+    std::size_t _M_resize;
+    float _M_list_cost;
+    float _M_vector_cost;
+    bool  _M_valid;
+    std::size_t _M_max_size;
+  };
+
+  class __list2vector_stack_info 
+  : public __list2vector_info
+  {
+  public:
+    __list2vector_stack_info(const __list2vector_info& __o) 
+    : __list2vector_info(__o) {}
+  };
+
+  class __trace_list_to_vector
+  : public __trace_base<__list2vector_info, __list2vector_stack_info> 
+  {
+  public:
+    __trace_list_to_vector()
+    : __trace_base<__list2vector_info, __list2vector_stack_info>()
+    { __id = "list-to-vector"; }
+
+    ~__trace_list_to_vector() { }
+
+    // Insert a new node at construct with object, callstack and initial size.
+    void
+    __insert(__object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __list2vector_info(__stack)); }
+
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj)
+    {
+      if (!__is_on())
+	return;
+
+      __list2vector_info* __res = __get_object_info(__obj);
+      if (!__res)
+	return;
+
+      float __vc = __vector_cost(__res->__shift_count(), __res->__iterate());
+      float __lc = __list_cost(__res->__shift_count(), __res->__iterate());
+      __res->__set_vector_cost(__vc);
+      __res->__set_list_cost(__lc);
+      __retire_object(__obj);
+    }
+
+    // Find the node in the live map.
+    __list2vector_info* __find(const void* __obj);
+
+    // Collect cost of operations.
+    void
+    __opr_insert(const void* __obj, std::size_t __shift, std::size_t __size)
+    {
+      __list2vector_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__opr_insert(__shift, __size);
+    }
+
+    void
+    __opr_iterate(const void* __obj, std::size_t __num)
+    {
+      __list2vector_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__opr_iterate(__num);
+    }
+
+    void
+    __invalid_operator(const void* __obj)
+    {
+      __list2vector_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__set_invalid();
+    }
+
+    void
+    __resize(const void* __obj, std::size_t __from, std::size_t __to)
+    {
+      __list2vector_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__resize(__from, __to);
+    }
+
+    float
+    __vector_cost(std::size_t __shift, std::size_t __iterate)
+    {
+      // The resulting vector will use a 'reserve' method.
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value); 
+    }
+
+    float
+    __list_cost(std::size_t __shift, std::size_t __iterate)
+    {
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value); 
+    }
+  };
+
+
+  inline void
+  __trace_list_to_vector_init()
+  { _GLIBCXX_PROFILE_DATA(_S_list_to_vector) = new __trace_list_to_vector(); }
+
+  inline void
+  __trace_list_to_vector_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_list_to_vector))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_list_to_vector)->
+	  __collect_warnings(__warnings);
+	_GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__write(__f);
+      }
+  }
+
+  inline void
+  __trace_list_to_vector_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__insert(__obj, __get_stack());
+  }
+
+  inline void
+  __trace_list_to_vector_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__destruct(__obj);
+  }
+
+  inline void
+  __trace_list_to_vector_insert(const void* __obj, 
+				std::size_t __shift, std::size_t __size)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_insert(__obj, __shift, 
+							   __size);
+  }
+
+  inline void
+  __trace_list_to_vector_iterate(const void* __obj, std::size_t __num = 1)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_iterate(__obj, __num);
+  }
+
+  inline void
+  __trace_list_to_vector_invalid_operator(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__invalid_operator(__obj);
+  }
+
+  inline void
+  __trace_list_to_vector_resize(const void* __obj, 
+				std::size_t __from, std::size_t __to)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__resize(__obj, __from, __to);
+  }
+
+} // namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H__ */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h
new file mode 100644
index 0000000..4ef9da1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h
@@ -0,0 +1,290 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_map_to_unordered_map.h
+ *  @brief Diagnostics for map to unordered_map.
+ */
+
+// Written by Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H
+#define _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H 1
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+
+namespace __gnu_profile
+{
+  inline int
+  __log2(std::size_t __size)
+  {
+    for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0;
+	 -- __bit_count) 
+      if ((2 << __bit_count) & __size)
+	return __bit_count;
+    return 0;
+  }
+
+  inline float
+  __map_insert_cost(std::size_t __size)
+  { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value 
+	    * static_cast<float>(__log2(__size))); }
+
+  inline float
+  __map_erase_cost(std::size_t __size)
+  { return (_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor).__value
+	    * static_cast<float>(__log2(__size))); }
+
+  inline float
+  __map_find_cost(std::size_t __size)
+  { return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value
+	    * static_cast<float>(__log2(__size))); }
+
+  /** @brief A map-to-unordered_map instrumentation line in the 
+      object table.  */
+  class __map2umap_info
+  : public __object_info_base
+  {
+  public:
+    __map2umap_info()
+    : _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0),
+      _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
+    
+    __map2umap_info(__stack_t __stack)
+    : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), 
+      _M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
+
+    virtual ~__map2umap_info() { }
+
+    __map2umap_info(const __map2umap_info& __o)
+    : __object_info_base(__o), _M_insert(__o._M_insert),
+      _M_erase(__o._M_erase), _M_find(__o._M_find),
+      _M_iterate(__o._M_iterate), _M_umap_cost(__o._M_umap_cost),
+      _M_map_cost(__o._M_map_cost), _M_valid(__o._M_valid) { }
+
+    void
+    __merge(const __map2umap_info& __o)
+    {
+      _M_insert    += __o._M_insert;
+      _M_erase     += __o._M_erase;
+      _M_find      += __o._M_find;
+      _M_umap_cost += __o._M_umap_cost;
+      _M_map_cost  += __o._M_map_cost;
+      _M_valid     &= __o._M_valid;
+    }
+
+    void
+    __write(FILE* __f) const
+    {
+      std::fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f %s\n",
+		   _M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost,
+		   _M_umap_cost, _M_valid ? "valid" : "invalid");
+    }
+
+    float
+    __magnitude() const
+    { return _M_map_cost - _M_umap_cost; }
+
+    std::string
+    __advice() const
+    { return "change std::map to std::unordered_map"; }
+
+    void
+    __record_insert(std::size_t __size, std::size_t __count)
+    {
+      _M_insert += __count;
+      _M_map_cost += __count * __map_insert_cost(__size);
+      _M_umap_cost
+	+= (__count
+	    * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
+    }
+
+    void
+    __record_erase(std::size_t __size, std::size_t __count)
+    {
+      _M_erase += __count;
+      _M_map_cost += __count * __map_erase_cost(__size);
+      _M_umap_cost
+	+= (__count
+	    * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
+    }
+
+    void
+    __record_find(std::size_t __size)
+    {
+      _M_find += 1;
+      _M_map_cost += __map_find_cost(__size);
+      _M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value;
+    }
+
+    void
+    __record_iterate(std::size_t __count)
+    {
+      _M_iterate += __count;
+      _M_map_cost
+	+= (__count
+	    * _GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor).__value);
+      _M_umap_cost
+	+= (__count
+	    * _GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor).__value);
+    }
+
+    void
+    __record_invalidate()
+    { _M_valid = false; }
+
+  private:
+    std::size_t _M_insert;
+    std::size_t _M_erase;
+    std::size_t _M_find;
+    std::size_t _M_iterate;
+    float _M_umap_cost;
+    float _M_map_cost;
+    bool  _M_valid;
+  };
+
+
+  /** @brief A map-to-unordered_map instrumentation line in the 
+      stack table.  */
+  class __map2umap_stack_info 
+  : public __map2umap_info
+  {
+  public:
+    __map2umap_stack_info(const __map2umap_info& __o)
+    : __map2umap_info(__o) { }
+  };
+
+  /** @brief Map-to-unordered_map instrumentation producer.  */
+  class __trace_map2umap
+  : public __trace_base<__map2umap_info, __map2umap_stack_info> 
+  {
+  public:
+    __trace_map2umap()
+    : __trace_base<__map2umap_info, __map2umap_stack_info>()
+    { __id = "map-to-unordered-map"; }
+  };
+
+  inline void
+  __trace_map_to_unordered_map_init()
+  { _GLIBCXX_PROFILE_DATA(_S_map2umap) = new __trace_map2umap(); }
+
+  inline void
+  __trace_map_to_unordered_map_report(FILE* __f,
+				      __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) 
+      {
+	_GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings);
+	_GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f);
+      }
+  }
+
+  inline void
+  __trace_map_to_unordered_map_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_map2umap)->
+      __add_object(__obj, __map2umap_info(__get_stack()));
+  }
+
+  inline void
+  __trace_map_to_unordered_map_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_map2umap)->__retire_object(__obj);
+  }
+
+  inline void
+  __trace_map_to_unordered_map_insert(const void* __obj, 
+				      std::size_t __size, std::size_t __count)
+  {
+    if (!__profcxx_init())
+      return;
+
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+
+    if (__info)
+      __info->__record_insert(__size, __count);
+  }
+
+  inline void
+  __trace_map_to_unordered_map_erase(const void* __obj, 
+				     std::size_t __size, std::size_t __count)
+  {
+    if (!__profcxx_init()) 
+      return;
+
+    __map2umap_info* __info 
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+
+    if (__info)
+      __info->__record_erase(__size, __count);
+  }
+
+  inline void
+  __trace_map_to_unordered_map_find(const void* __obj, std::size_t __size)
+  {
+    if (!__profcxx_init())
+      return;
+
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+
+    if (__info)
+      __info->__record_find(__size);
+  }
+
+  inline void
+  __trace_map_to_unordered_map_iterate(const void* __obj, std::size_t __count)
+  {
+    if (!__profcxx_init())
+      return;
+
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+    
+    if (__info)
+      __info->__record_iterate(__count);
+  }
+
+  inline void
+  __trace_map_to_unordered_map_invalidate(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+
+    if (__info)
+      __info->__record_invalidate();
+  }
+
+} // namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_node.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_node.h
new file mode 100644
index 0000000..d286c4e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_node.h
@@ -0,0 +1,166 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_node.h
+ *  @brief Data structures to represent a single profiling event.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_NODE_H
+#define _GLIBCXX_PROFILE_PROFILER_NODE_H 1
+
+#include <cstdio> // FILE, fprintf
+
+#include <vector>
+#if defined _GLIBCXX_HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+
+namespace __gnu_profile
+{
+  typedef const void* __object_t;
+  typedef void* __instruction_address_t;
+  typedef std::_GLIBCXX_STD_C::vector<__instruction_address_t> __stack_npt;
+  typedef __stack_npt* __stack_t;
+
+  std::size_t __stack_max_depth();
+
+  inline __stack_t
+  __get_stack()
+  {
+#if defined _GLIBCXX_HAVE_EXECINFO_H
+    std::size_t __max_depth = __stack_max_depth();
+    if (__max_depth == 0)
+      return 0;
+    __stack_npt __buffer(__max_depth);
+    int __depth = backtrace(&__buffer[0], __max_depth);
+    __stack_t __stack = new __stack_npt(__depth);
+    __builtin_memcpy(&(*__stack)[0], &__buffer[0],
+		     __depth * sizeof(__object_t));
+    return __stack;
+#else
+    return 0;
+#endif
+  }
+
+  inline std::size_t
+  __size(__stack_t __stack)
+  {
+    if (!__stack)
+      return 0;
+    else
+      return __stack->size();
+  }
+
+  // XXX
+  inline void
+  __write(FILE* __f, __stack_t __stack)
+  {
+    if (!__stack)
+      return;
+  
+    __stack_npt::const_iterator __it;
+    for (__it = __stack->begin(); __it != __stack->end(); ++__it)
+      std::fprintf(__f, "%p ", *__it);
+  }
+
+  /** @brief Hash function for summary trace using call stack as index.  */
+  class __stack_hash 
+  {
+  public:
+    std::size_t
+    operator()(__stack_t __s) const
+    {
+      if (!__s) 
+	return 0;
+
+      std::size_t __index = 0;
+      __stack_npt::const_iterator __it;
+      for (__it = __s->begin(); __it != __s->end(); ++__it)
+	__index += reinterpret_cast<std::size_t>(*__it);
+      return __index;
+    }
+
+    bool operator() (__stack_t __stack1, __stack_t __stack2) const
+    {
+      if (!__stack1 && !__stack2)
+	return true;
+      if (!__stack1 || !__stack2)
+	return false;
+      if (__stack1->size() != __stack2->size())
+	return false;
+
+      std::size_t __byte_size
+	= __stack1->size() * sizeof(__stack_npt::value_type);
+      return __builtin_memcmp(&(*__stack1)[0], &(*__stack2)[0],
+			      __byte_size) == 0;
+    }
+  };
+
+
+  /** @brief Base class for a line in the object table.  */
+  class __object_info_base
+  {
+  public:
+    __object_info_base() { }
+
+    __object_info_base(__stack_t __stack)
+    : _M_stack(__stack), _M_valid(true) { }
+
+    __object_info_base(const __object_info_base& __o)
+    : _M_stack(__o._M_stack), _M_valid(__o._M_valid) { }
+
+    virtual ~__object_info_base() { }
+
+    bool
+    __is_valid() const 
+    { return _M_valid; }
+    
+    __stack_t
+    __stack() const
+    { return _M_stack; }
+    
+    virtual void __write(FILE* __f) const = 0;
+
+  protected:
+    __stack_t _M_stack;
+    bool _M_valid;
+  };
+
+
+  /** @brief Base class for a line in the stack table.  */
+  template<typename __object_info>
+    class __stack_info_base
+    {
+    public:
+      __stack_info_base() { }
+      __stack_info_base(const __object_info& __info) = 0;
+      virtual ~__stack_info_base() {}
+      void __merge(const __object_info& __info) = 0;
+      virtual float __magnitude() const = 0;
+      virtual const char* __get_id() const = 0;
+    };
+
+} // namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_NODE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_state.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_state.h
new file mode 100644
index 0000000..6b7447b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_state.h
@@ -0,0 +1,69 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_state.h
+ *  @brief Global profiler state.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_STATE_H
+#define _GLIBCXX_PROFILE_PROFILER_STATE_H 1
+
+namespace __gnu_profile
+{
+  enum __state_type { __ON, __OFF, __INVALID };
+
+  _GLIBCXX_PROFILE_DEFINE_DATA(__state_type, __state, __INVALID);
+
+  inline bool
+  __turn(__state_type __s)
+  { 
+    __state_type inv(__INVALID);
+    return __atomic_compare_exchange_n(&_GLIBCXX_PROFILE_DATA(__state),
+				       &inv, __s, false, __ATOMIC_ACQ_REL, 
+				       __ATOMIC_RELAXED);
+  }
+
+  inline bool
+  __turn_on()
+  { return __turn(__ON); }
+
+  inline bool
+  __turn_off()
+  { return __turn(__OFF); }
+
+  inline bool
+  __is_on()
+  { return _GLIBCXX_PROFILE_DATA(__state) == __ON; }
+
+  inline bool
+  __is_off()
+  { return _GLIBCXX_PROFILE_DATA(__state) == __OFF; }
+
+  inline bool
+  __is_invalid()
+  { return _GLIBCXX_PROFILE_DATA(__state) == __INVALID; }
+
+} // end namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_STATE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_trace.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_trace.h
new file mode 100644
index 0000000..31c33f8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_trace.h
@@ -0,0 +1,659 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_trace.h
+ *  @brief Data structures to represent profiling traces.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_TRACE_H
+#define _GLIBCXX_PROFILE_PROFILER_TRACE_H 1
+
+#include <cstdio>  // fopen, fclose, fprintf, FILE
+#include <cerrno>
+#include <cstdlib> // atof, atoi, strtol, getenv, atexit, abort
+
+#if __cplusplus >= 201103L
+#define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_C::unordered_map
+#include <unordered_map>
+#else
+#include <tr1/unordered_map>
+#define _GLIBCXX_IMPL_UNORDERED_MAP std::tr1::unordered_map
+#endif
+
+#include <ext/concurrence.h>
+#include <fstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "profile/impl/profiler_algos.h"
+#include "profile/impl/profiler_state.h"
+#include "profile/impl/profiler_node.h"
+
+namespace __gnu_profile
+{
+  /** @brief Internal environment.  Values can be set one of two ways:
+      1. In config file "var = value".  The default config file path is 
+         libstdcxx-profile.conf.
+      2. By setting process environment variables.  For instance, in a Bash
+         shell you can set the unit cost of iterating through a map like this:
+         export __map_iterate_cost_factor=5.0.
+	 If a value is set both in the input file and through an environment
+	 variable, the environment value takes precedence.  */
+  typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t;
+
+  _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env);
+
+  /** @brief Master lock.  */
+  _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock);
+
+  /** @brief Representation of a warning.  */
+  struct __warning_data
+  {
+    float __magnitude;
+    __stack_t __context;
+    const char* __warning_id;
+    std::string __warning_message;
+
+    __warning_data()
+    : __magnitude(0.0), __context(0), __warning_id(0) { }
+
+    __warning_data(float __m, __stack_t __c, const char* __id, 
+		   const std::string& __msg)
+    : __magnitude(__m), __context(__c), __warning_id(__id), 
+      __warning_message(__msg) { }
+
+    bool
+    operator<(const __warning_data& __other) const
+    { return __magnitude < __other.__magnitude; }
+  };
+
+  typedef std::_GLIBCXX_STD_C::vector<__warning_data> __warning_vector_t;
+
+  // Defined in profiler_<diagnostic name>.h.
+  class __trace_hash_func;
+  class __trace_hashtable_size;
+  class __trace_map2umap;
+  class __trace_vector_size;
+  class __trace_vector_to_list;
+  class __trace_list_to_slist; 
+  class __trace_list_to_vector; 
+  void __trace_vector_size_init();
+  void __trace_hashtable_size_init();
+  void __trace_hash_func_init();
+  void __trace_vector_to_list_init();
+  void __trace_list_to_slist_init();  
+  void __trace_list_to_vector_init();  
+  void __trace_map_to_unordered_map_init();
+  void __trace_vector_size_report(FILE*, __warning_vector_t&);
+  void __trace_hashtable_size_report(FILE*, __warning_vector_t&);
+  void __trace_hash_func_report(FILE*, __warning_vector_t&);
+  void __trace_vector_to_list_report(FILE*, __warning_vector_t&);
+  void __trace_list_to_slist_report(FILE*, __warning_vector_t&); 
+  void __trace_list_to_vector_report(FILE*, __warning_vector_t&);
+  void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&);
+
+  struct __cost_factor
+  {
+    const char* __env_var;
+    float __value;
+  };
+
+  typedef std::_GLIBCXX_STD_C::vector<__cost_factor*> __cost_factor_vector;
+
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); 
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0);
+
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, 
+			       {"__vector_shift_cost_factor", 1.0});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor,
+			       {"__vector_iterate_cost_factor", 1.0});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor,
+			       {"__vector_resize_cost_factor", 1.0}); 
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor,
+			       {"__list_shift_cost_factor", 0.0});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor,
+			       {"__list_iterate_cost_factor", 10.0}); 
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor,
+			       {"__list_resize_cost_factor", 0.0}); 
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor,
+			       {"__map_insert_cost_factor", 1.5});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor,
+			       {"__map_erase_cost_factor", 1.5});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor,
+			       {"__map_find_cost_factor", 1});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor,
+			       {"__map_iterate_cost_factor", 2.3});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor,
+			       {"__umap_insert_cost_factor", 12.0});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor,
+			       {"__umap_erase_cost_factor", 12.0});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor,
+			       {"__umap_find_cost_factor", 10.0});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor,
+			       {"__umap_iterate_cost_factor", 1.7});
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0);
+
+  _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name,
+			       _GLIBCXX_PROFILE_TRACE_PATH_ROOT);
+  _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_warn_count,
+			       _GLIBCXX_PROFILE_MAX_WARN_COUNT);
+  _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_stack_depth,
+			       _GLIBCXX_PROFILE_MAX_STACK_DEPTH);
+  _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_mem,
+			       _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC);
+
+  inline std::size_t
+  __stack_max_depth()
+  { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); }
+
+  inline std::size_t
+  __max_mem()
+  { return _GLIBCXX_PROFILE_DATA(_S_max_mem); }
+
+  /** @brief Base class for all trace producers.  */
+  template<typename __object_info, typename __stack_info>
+    class __trace_base
+    {
+    public:
+      // Do not pick the initial size too large, as we don't know which
+      // diagnostics are more active.
+      __trace_base()
+      : __object_table(10000), __stack_table(10000),
+	__stack_table_byte_size(0), __id(0) { }
+
+      virtual ~__trace_base() { }
+
+      void __add_object(__object_t object, __object_info __info);
+      __object_info* __get_object_info(__object_t __object);
+      void __retire_object(__object_t __object);
+      void __write(FILE* __f);
+      void __collect_warnings(__warning_vector_t& __warnings);
+
+    private:
+      __gnu_cxx::__mutex __object_table_lock;
+      __gnu_cxx::__mutex __stack_table_lock;
+      typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t, 
+					  __object_info> __object_table_t;
+      typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info,
+					  __stack_hash, 
+					  __stack_hash> __stack_table_t;
+      __object_table_t __object_table;
+      __stack_table_t __stack_table;
+      std::size_t __stack_table_byte_size;
+
+    protected:
+      const char* __id;
+    };
+
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __collect_warnings(__warning_vector_t& __warnings)
+    {
+      for (typename __stack_table_t::iterator __it
+	     = __stack_table.begin(); __it != __stack_table.end(); ++__it)
+	__warnings.push_back(__warning_data((*__it).second.__magnitude(),
+					    (*__it).first, __id,
+					    (*__it).second.__advice()));
+    }
+
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __add_object(__object_t __object, __object_info __info)
+    {
+      if (__max_mem() == 0 
+	  || __object_table.size() * sizeof(__object_info) <= __max_mem())
+	{
+	  this->__object_table_lock.lock();
+	  __object_table.insert(typename __object_table_t::
+				value_type(__object, __info));
+	  this->__object_table_lock.unlock();
+	}
+    }
+
+  template<typename __object_info, typename __stack_info>
+    __object_info*
+    __trace_base<__object_info, __stack_info>::
+    __get_object_info(__object_t __object)
+    {
+      // XXX: Revisit this to see if we can decrease mutex spans.
+      // Without this mutex, the object table could be rehashed during an
+      // insertion on another thread, which could result in a segfault.
+      this->__object_table_lock.lock();
+      typename __object_table_t::iterator __object_it
+	=  __object_table.find(__object);
+
+      if (__object_it == __object_table.end())
+	{
+	  this->__object_table_lock.unlock();
+	  return 0;
+	}
+      else
+	{
+	  this->__object_table_lock.unlock();
+	  return &__object_it->second;
+	}
+    }
+
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __retire_object(__object_t __object)
+    {
+      this->__object_table_lock.lock();
+      this->__stack_table_lock.lock();
+      typename __object_table_t::iterator __object_it
+	= __object_table.find(__object);
+  
+      if (__object_it != __object_table.end())
+	{
+	  const __object_info& __info = __object_it->second;
+	  const __stack_t& __stack = __info.__stack();
+	  typename __stack_table_t::iterator __stack_it
+	    = __stack_table.find(__stack);
+    
+	  if (__stack_it == __stack_table.end())
+	    {
+	      // First occurrence of this call context.
+	      if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) 
+		{
+		  __stack_table_byte_size 
+		    += (sizeof(__instruction_address_t) * __size(__stack)
+			+ sizeof(__stack) + sizeof(__stack_info));
+		  __stack_table.insert(make_pair(__stack,
+						 __stack_info(__info)));
+		}
+	    }
+	  else
+	    {
+	      // Merge object info into info summary for this call context.
+	      __stack_it->second.__merge(__info);
+	      delete __stack;
+	    }
+	  __object_table.erase(__object);
+	}
+
+      this->__object_table_lock.unlock();
+      this->__stack_table_lock.unlock();
+    }
+
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __write(FILE* __f)
+    {
+      for (typename __stack_table_t::iterator __it
+	     = __stack_table.begin(); __it != __stack_table.end(); ++__it)
+	if (__it->second.__is_valid())
+	  {
+	    std::fprintf(__f, __id);
+	    std::fprintf(__f, "|");
+	    __gnu_profile::__write(__f, __it->first);
+	    std::fprintf(__f, "|");
+	    __it->second.__write(__f);
+	  }
+    }
+
+  inline std::size_t
+  __env_to_size_t(const char* __env_var, std::size_t __default_value)
+  {
+    char* __env_value = std::getenv(__env_var);
+    if (__env_value)
+      {
+	errno = 0;
+	long __converted_value = std::strtol(__env_value, 0, 10);
+	if (errno || __converted_value < 0)
+	  {
+	    std::fprintf(stderr,
+			 "Bad value for environment variable '%s'.\n",
+			 __env_var);
+	    std::abort();
+	  }
+	else
+	  return static_cast<std::size_t>(__converted_value);
+      }
+    else
+      return __default_value;
+  }
+
+  inline void
+  __set_max_stack_trace_depth()
+  {
+    _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)
+      = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR,
+			_GLIBCXX_PROFILE_DATA(_S_max_stack_depth));
+  }
+
+  inline void
+  __set_max_mem()
+  {
+    _GLIBCXX_PROFILE_DATA(_S_max_mem) 
+      = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR,
+			_GLIBCXX_PROFILE_DATA(_S_max_mem));
+  }
+
+  inline int
+  __log_magnitude(float __f)
+  {
+    const float __log_base = 10.0;
+    int __result = 0;
+    int __sign = 1;
+
+    if (__f < 0) 
+      {
+	__f = -__f;
+	__sign = -1;
+      }
+
+    while (__f > __log_base) 
+      {
+	++__result;
+	__f /= 10.0;
+      }
+    return __sign * __result;
+  }
+
+  inline FILE* 
+  __open_output_file(const char* __extension)
+  {
+    // The path is made of _S_trace_file_name + "." + extension.
+    std::size_t __root_len 
+      = __builtin_strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));
+    std::size_t __ext_len = __builtin_strlen(__extension);
+    char* __file_name = new char[__root_len + 1 + __ext_len + 1];
+    __builtin_memcpy(__file_name,
+		     _GLIBCXX_PROFILE_DATA(_S_trace_file_name),
+		     __root_len);
+    *(__file_name + __root_len) = '.';
+    __builtin_memcpy(__file_name + __root_len + 1,
+		     __extension, __ext_len + 1);
+
+    FILE* __out_file = std::fopen(__file_name, "w");
+    if (!__out_file)
+      {
+	std::fprintf(stderr, "Could not open trace file '%s'.\n",
+		     __file_name);
+	std::abort();
+      }
+
+    delete[] __file_name;
+    return __out_file;
+  }
+
+  struct __warn
+  {
+    FILE* __file;
+
+    __warn(FILE* __f)
+    { __file = __f; }
+
+    void
+    operator()(const __warning_data& __info)
+    {
+      std::fprintf(__file,  __info.__warning_id);
+      std::fprintf(__file, ": improvement = %d",
+		   __log_magnitude(__info.__magnitude));
+      std::fprintf(__file, ": call stack = ");
+      __gnu_profile::__write(__file, __info.__context);
+      std::fprintf(__file, ": advice = %s\n",
+		   __info.__warning_message.c_str());
+    }
+  };
+
+  /** @brief Final report method, registered with @b atexit.
+   *
+   * This can also be called directly by user code, including signal handlers.
+   * It is protected against deadlocks by the reentrance guard in profiler.h.
+   * However, when called from a signal handler that triggers while within
+   * __gnu_profile (under the guarded zone), no output will be produced.
+   */
+  inline void
+  __report(void)
+  {
+    _GLIBCXX_PROFILE_DATA(__global_lock).lock();
+
+    __warning_vector_t __warnings, __top_warnings;
+
+    FILE* __raw_file = __open_output_file("raw");
+    __trace_vector_size_report(__raw_file, __warnings);
+    __trace_hashtable_size_report(__raw_file, __warnings);
+    __trace_hash_func_report(__raw_file, __warnings);
+    __trace_vector_to_list_report(__raw_file, __warnings);
+    __trace_list_to_slist_report(__raw_file, __warnings);
+    __trace_list_to_vector_report(__raw_file, __warnings);
+    __trace_map_to_unordered_map_report(__raw_file, __warnings);
+    std::fclose(__raw_file);
+
+    // Sort data by magnitude, keeping just top N.
+    std::size_t __cutoff = std::min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count),
+				    __warnings.size());
+    __top_n(__warnings, __top_warnings, __cutoff);
+
+    FILE* __warn_file = __open_output_file("txt");
+    __for_each(__top_warnings.begin(), __top_warnings.end(),
+	       __warn(__warn_file));
+    std::fclose(__warn_file);
+
+    _GLIBCXX_PROFILE_DATA(__global_lock).unlock();
+  }
+
+  inline void
+  __set_trace_path()
+  {
+    char* __env_trace_file_name = std::getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR);
+
+    if (__env_trace_file_name)
+      _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name;
+
+    // Make sure early that we can create the trace file.
+    std::fclose(__open_output_file("txt"));
+  }
+
+  inline void
+  __set_max_warn_count()
+  {
+    char* __env_max_warn_count_str
+      = std::getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR);
+
+    if (__env_max_warn_count_str)
+      _GLIBCXX_PROFILE_DATA(_S_max_warn_count)
+	= static_cast<std::size_t>(std::atoi(__env_max_warn_count_str));
+  }
+
+  inline void
+  __read_cost_factors()
+  {
+    std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));
+    __conf_file_name += ".conf";
+
+    std::ifstream __conf_file(__conf_file_name.c_str());
+
+    if (__conf_file.is_open())
+      {
+	std::string __line;
+
+	while (std::getline(__conf_file, __line))
+	  {
+	    std::string::size_type __i = __line.find_first_not_of(" \t\n\v");
+
+	    if (__line.length() <= 0 || __line[__i] == '#')
+	      // Skip empty lines or comments.
+	      continue;
+	  }
+
+	// Trim.
+	__line.erase(__remove(__line.begin(), __line.end(), ' '),
+		     __line.end());
+	std::string::size_type __pos = __line.find("=");
+	std::string __factor_name = __line.substr(0, __pos);
+	std::string::size_type __end = __line.find_first_of(";\n");
+	std::string __factor_value = __line.substr(__pos + 1, __end - __pos);
+
+	_GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value;
+      }
+  }
+
+  struct __cost_factor_writer
+  {
+    FILE* __file;
+
+    __cost_factor_writer(FILE* __f)
+    : __file(__f) { }
+
+    void
+    operator() (const __cost_factor* __factor)
+    { std::fprintf(__file, "%s = %f\n", __factor->__env_var,
+		   __factor->__value); }
+  };
+
+  inline void
+  __write_cost_factors()
+  {
+    FILE* __file = __open_output_file("conf.out");
+    __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(),
+	       _GLIBCXX_PROFILE_DATA(__cost_factors)->end(),
+	       __cost_factor_writer(__file));
+    std::fclose(__file);
+  }
+
+  struct __cost_factor_setter
+  {
+    void
+    operator()(__cost_factor* __factor)
+    {
+      // Look it up in the process environment first.
+      const char* __env_value = std::getenv(__factor->__env_var);
+
+      if (!__env_value)
+        {
+          // Look it up in the config file.
+          __env_t::iterator __it 
+	    = _GLIBCXX_PROFILE_DATA(__env).find(__factor->__env_var);
+          if (__it != _GLIBCXX_PROFILE_DATA(__env).end())
+            __env_value = (*__it).second.c_str();
+        }
+
+      if (__env_value)
+        __factor->__value = std::atof(__env_value);
+    }
+  };
+
+  inline void
+  __set_cost_factors()
+  {
+    _GLIBCXX_PROFILE_DATA(__cost_factors) = new __cost_factor_vector;
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__map_find_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor));
+    __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(),
+	       _GLIBCXX_PROFILE_DATA(__cost_factors)->end(),
+	       __cost_factor_setter());
+  }
+
+  inline void
+  __profcxx_init_unconditional()
+  {
+    _GLIBCXX_PROFILE_DATA(__global_lock).lock();
+
+    if (__is_invalid())
+      {
+	__set_max_warn_count();
+
+	if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0)
+	  __turn_off();
+	else
+	  {
+	    __set_max_stack_trace_depth();
+	    __set_max_mem();
+	    __set_trace_path();
+	    __read_cost_factors(); 
+	    __set_cost_factors();
+	    __write_cost_factors();
+
+	    __trace_vector_size_init();
+	    __trace_hashtable_size_init();
+	    __trace_hash_func_init();
+	    __trace_vector_to_list_init();
+	    __trace_list_to_slist_init(); 
+	    __trace_list_to_vector_init();
+	    __trace_map_to_unordered_map_init();
+
+	    std::atexit(__report);
+
+	    __turn_on();
+	  }
+      }
+
+    _GLIBCXX_PROFILE_DATA(__global_lock).unlock();
+  }
+
+  /** @brief This function must be called by each instrumentation point.
+   *
+   * The common path is inlined fully.
+   */
+  inline bool
+  __profcxx_init()
+  {
+    if (__is_invalid())
+      __profcxx_init_unconditional();
+
+    return __is_on();
+  }
+
+} // namespace __gnu_profile
+
+#endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_vector_size.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_vector_size.h
new file mode 100644
index 0000000..48376cd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_vector_size.h
@@ -0,0 +1,97 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_vector_size.h
+ *  @brief Collection of vector size traces.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H
+#define _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H 1
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+#include "profile/impl/profiler_state.h"
+#include "profile/impl/profiler_container_size.h"
+
+namespace __gnu_profile
+{
+  /** @brief Hashtable size instrumentation trace producer.  */
+  class __trace_vector_size
+  : public __trace_container_size
+  {
+  public:
+    __trace_vector_size()
+    : __trace_container_size()
+    { __id = "vector-size"; }
+  };
+
+  inline void
+  __trace_vector_size_init()
+  { _GLIBCXX_PROFILE_DATA(_S_vector_size) = new __trace_vector_size(); }
+
+  inline void
+  __trace_vector_size_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_vector_size))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_vector_size)->__collect_warnings(__warnings);
+	_GLIBCXX_PROFILE_DATA(_S_vector_size)->__write(__f);
+      }
+  }
+
+  inline void
+  __trace_vector_size_construct(const void* __obj, std::size_t __num)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__insert(__obj, __get_stack(),
+						    __num);
+  }
+
+  inline void
+  __trace_vector_size_destruct(const void* __obj, std::size_t __num,
+			       std::size_t __inum)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__destruct(__obj, __num, __inum);
+  }
+
+  inline void
+  __trace_vector_size_resize(const void* __obj, std::size_t __from,
+			     std::size_t __to)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__resize(__obj, __from, __to);
+  }
+
+} // namespace __gnu_profile
+
+#endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h
new file mode 100644
index 0000000..cbacda5
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h
@@ -0,0 +1,347 @@
+// -*- C++ -*-
+//
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/impl/profiler_vector_to_list.h
+ *  @brief diagnostics for vector to list.
+ */
+
+// Written by Lixia Liu and Silvius Rus.
+
+#ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H
+#define _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H 1
+
+#include "profile/impl/profiler.h"
+#include "profile/impl/profiler_node.h"
+#include "profile/impl/profiler_trace.h"
+
+namespace __gnu_profile
+{
+  /** @brief A vector-to-list instrumentation line in the object table.  */
+  class __vector2list_info
+  : public __object_info_base
+  {
+  public:
+    __vector2list_info()
+    : _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0),
+      _M_vector_cost(0), _M_valid(true) { }
+
+    __vector2list_info(__stack_t __stack)
+    : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0),
+      _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true) { }
+
+    virtual ~__vector2list_info() { }
+
+    __vector2list_info(const __vector2list_info& __o)
+    : __object_info_base(__o), _M_shift_count(__o._M_shift_count),
+      _M_iterate(__o._M_iterate), _M_resize(__o._M_resize),
+      _M_list_cost(__o._M_list_cost), _M_vector_cost(__o._M_vector_cost),
+      _M_valid(__o._M_valid) { }
+
+    void
+    __merge(const __vector2list_info& __o)
+    {
+      _M_shift_count  += __o._M_shift_count;
+      _M_iterate      += __o._M_iterate;
+      _M_vector_cost  += __o._M_vector_cost;
+      _M_list_cost    += __o._M_list_cost;
+      _M_valid        &= __o._M_valid;
+      _M_resize       += __o._M_resize;
+    }
+
+    void
+    __write(FILE* __f) const
+    {
+      std::fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count,
+		   _M_resize, _M_iterate, _M_vector_cost, _M_list_cost);
+    }
+
+    float
+    __magnitude() const
+    { return _M_vector_cost - _M_list_cost; }
+
+    std::string
+    __advice() const 
+    { return "change std::vector to std::list"; }
+
+    std::size_t
+    __shift_count()
+    { return _M_shift_count; }
+
+    std::size_t
+    __iterate()
+    { return _M_iterate; }
+
+    float
+    __list_cost()
+    { return _M_list_cost; }
+
+    std::size_t
+    __resize()
+    { return _M_resize; }
+
+    void
+    __set_list_cost(float __lc)
+    { _M_list_cost = __lc; }
+    
+    void
+    __set_vector_cost(float __vc)
+    { _M_vector_cost = __vc; }
+    
+    bool
+    __is_valid()
+    { return _M_valid; }
+    
+    void
+    __set_invalid()
+    { _M_valid = false; }
+
+    void
+    __opr_insert(std::size_t __pos, std::size_t __num)
+    { _M_shift_count += __num - __pos; }
+
+    void
+    __opr_iterate(std::size_t __num)
+    { _M_iterate += __num; }
+
+    void
+    __resize(std::size_t __from, std::size_t)
+    { _M_resize += __from; }
+
+    void
+    __opr_find(std::size_t __size)
+    {
+      // Use average case complexity.
+      _M_iterate += 3.0 / 4.0 * __size;
+    }
+
+  private:
+    std::size_t _M_shift_count;
+    std::size_t _M_iterate;
+    std::size_t _M_resize;
+    float _M_list_cost;
+    float _M_vector_cost;
+    bool  _M_valid;
+  };
+
+
+  /** @brief A vector-to-list instrumentation line in the stack table.  */
+  class __vector2list_stack_info
+  : public __vector2list_info
+  {
+  public:
+    __vector2list_stack_info(const __vector2list_info& __o) 
+    : __vector2list_info(__o) { }
+  };
+
+
+  /** @brief Vector-to-list instrumentation producer.  */
+  class __trace_vector_to_list
+  : public __trace_base<__vector2list_info, __vector2list_stack_info> 
+  {
+  public:
+    __trace_vector_to_list()
+    : __trace_base<__vector2list_info, __vector2list_stack_info>()
+    { __id = "vector-to-list"; }
+
+    ~__trace_vector_to_list() { }
+
+    // Insert a new node at construct with object, callstack and initial size. 
+    void
+    __insert(__object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __vector2list_info(__stack)); }
+
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj)
+    {
+      if (!__is_on())
+	return;
+
+      __vector2list_info* __res = __get_object_info(__obj);
+      if (!__res)
+	return;
+
+      float __vc = __vector_cost(__res->__shift_count(), __res->__iterate(),
+				 __res->__resize());
+      float __lc = __list_cost(__res->__shift_count(), __res->__iterate(),
+			       __res->__resize());
+      __res->__set_vector_cost(__vc);
+      __res->__set_list_cost(__lc);
+
+      __retire_object(__obj);
+    }
+
+    // Find the node in the live map.
+    // XXX Undefined?!?
+    __vector2list_info* __find(const void* __obj);
+
+    // Collect cost of operations.
+    void
+    __opr_insert(const void* __obj, std::size_t __pos, std::size_t __num)
+    {
+      __vector2list_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__opr_insert(__pos, __num);
+    }
+
+    void
+    __opr_iterate(const void* __obj, std::size_t __num)
+    {
+      __vector2list_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__opr_iterate(__num);
+    }
+
+    void
+    __invalid_operator(const void* __obj)
+    {
+      __vector2list_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__set_invalid();
+    }
+
+    void
+    __resize(const void* __obj, std::size_t __from, std::size_t __to)
+    {
+      __vector2list_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__resize(__from, __to);
+    }
+
+    float
+    __vector_cost(std::size_t __shift, std::size_t __iterate,
+		  std::size_t __resize)
+    {
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value
+	      + __resize
+	      * _GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor).__value);
+    }
+
+    float
+    __list_cost(std::size_t __shift, std::size_t __iterate,
+		std::size_t __resize)
+    {
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value
+	      + __resize
+	      * _GLIBCXX_PROFILE_DATA(__list_resize_cost_factor).__value);
+    }
+
+    void
+    __opr_find(const void* __obj, std::size_t __size)
+    {
+      __vector2list_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__opr_find(__size);
+    }
+  };
+
+
+  inline void
+  __trace_vector_to_list_init()
+  { _GLIBCXX_PROFILE_DATA(_S_vector_to_list) = new __trace_vector_to_list(); }
+
+  inline void
+  __trace_vector_to_list_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_vector_to_list))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_vector_to_list)->
+	  __collect_warnings(__warnings);
+	_GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__write(__f);
+      }
+  }
+
+  inline void
+  __trace_vector_to_list_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__insert(__obj, __get_stack());
+  }
+
+  inline void
+  __trace_vector_to_list_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__destruct(__obj);
+  }
+
+  inline void
+  __trace_vector_to_list_insert(const void* __obj, std::size_t __pos,
+				std::size_t __num)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_insert(__obj, __pos,
+							   __num);
+  }
+
+  inline void
+  __trace_vector_to_list_iterate(const void* __obj, std::size_t __num = 1)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_iterate(__obj, __num);
+  }
+
+  inline void
+  __trace_vector_to_list_invalid_operator(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__invalid_operator(__obj);
+  }
+
+  inline void
+  __trace_vector_to_list_resize(const void* __obj, std::size_t __from,
+				std::size_t __to)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__resize(__obj, __from, __to);
+  }
+
+  inline void
+  __trace_vector_to_list_find(const void* __obj, std::size_t __size)
+  {
+    if (!__profcxx_init())
+      return;
+
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_find(__obj, __size);
+  }
+
+} // namespace __gnu_profile
+#endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H */
diff --git a/gcc-4.9/libstdc++-v3/include/profile/iterator_tracker.h b/gcc-4.9/libstdc++-v3/include/profile/iterator_tracker.h
new file mode 100644
index 0000000..df92c84
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/iterator_tracker.h
@@ -0,0 +1,290 @@
+// Profiling iterator implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/iterator_tracker.h
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_ITERATOR_TRACKER
+#define _GLIBCXX_PROFILE_ITERATOR_TRACKER 1
+
+#include <ext/type_traits.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+
+  template<typename _Iterator, typename _Sequence>
+    class __iterator_tracker 
+    {
+      typedef __iterator_tracker _Self;
+
+      // The underlying iterator
+      _Iterator _M_current;
+
+      // The underlying data structure
+      const _Sequence* _M_ds;
+      typedef std::iterator_traits<_Iterator> _Traits;
+
+    public:
+      typedef _Iterator		              _Base_iterator;
+      typedef typename _Traits::iterator_category iterator_category; 
+      typedef typename _Traits::value_type        value_type;
+      typedef typename _Traits::difference_type   difference_type;
+      typedef typename _Traits::reference         reference;
+      typedef typename _Traits::pointer           pointer;
+
+      __iterator_tracker() _GLIBCXX_NOEXCEPT
+      : _M_current(), _M_ds(0) { }
+
+      __iterator_tracker(const _Iterator& __i, const _Sequence* __seq)
+      _GLIBCXX_NOEXCEPT
+      : _M_current(__i), _M_ds(__seq) { }
+
+      __iterator_tracker(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT
+      : _M_current(__x._M_current), _M_ds(__x._M_ds) { }
+
+      template<typename _MutableIterator>
+        __iterator_tracker(const __iterator_tracker<_MutableIterator,
+			   typename __gnu_cxx::__enable_if
+			   <(std::__are_same<_MutableIterator, typename
+			     _Sequence::iterator::_Base_iterator>::__value),
+			   _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT
+	:  _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { }
+
+      _Iterator
+      base() const _GLIBCXX_NOEXCEPT { return _M_current; }
+  
+      /**
+       * @brief Conversion to underlying non-debug iterator to allow
+       * better interaction with non-profile containers.
+       */
+      operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }
+
+      pointer
+      operator->() const _GLIBCXX_NOEXCEPT { return &*_M_current; }
+
+      __iterator_tracker&
+      operator++() _GLIBCXX_NOEXCEPT
+      {
+	_M_ds->_M_profile_iterate();
+	++_M_current;
+	return *this;
+      }
+
+      __iterator_tracker
+      operator++(int) _GLIBCXX_NOEXCEPT
+      {
+	_M_ds->_M_profile_iterate();
+	__iterator_tracker __tmp(*this);
+	++_M_current;
+	return __tmp;
+      }
+
+      __iterator_tracker&
+      operator--() _GLIBCXX_NOEXCEPT
+      {
+	_M_ds->_M_profile_iterate(1);
+	--_M_current;
+	return *this;
+      }
+
+      __iterator_tracker
+      operator--(int) _GLIBCXX_NOEXCEPT
+      {
+	_M_ds->_M_profile_iterate(1);
+	__iterator_tracker __tmp(*this);
+	--_M_current;
+	return __tmp;
+      }
+
+      __iterator_tracker&
+      operator=(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT
+      {
+	_M_current = __x._M_current;
+	return *this;
+      }
+
+      reference
+      operator*() const _GLIBCXX_NOEXCEPT
+      { return *_M_current; }
+
+      // ------ Random access iterator requirements ------
+      reference
+      operator[](const difference_type& __n) const  _GLIBCXX_NOEXCEPT
+      { return _M_current[__n]; }
+
+      __iterator_tracker&
+      operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT
+      {
+	_M_current += __n;
+	return *this;
+      }
+
+      __iterator_tracker
+      operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT
+      {
+	__iterator_tracker __tmp(*this);
+	__tmp += __n;
+	return __tmp;
+      }
+
+      __iterator_tracker&
+      operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT
+      {
+	_M_current += -__n;
+	return *this;
+      }
+
+      __iterator_tracker
+      operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT
+      {
+	__iterator_tracker __tmp(*this);
+	__tmp -= __n;
+	return __tmp;
+      }
+
+      void
+      _M_find()
+      { _M_ds->_M_profile_find(); }
+
+      const _Sequence*
+      _M_get_sequence() const
+      { return static_cast<const _Sequence*>(_M_ds); }
+  };
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
+	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
+	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
+	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() != __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
+               const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() != __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
+	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
+	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
+	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
+	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
+	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
+	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline bool
+    operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
+	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() >= __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline bool
+    operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
+	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() >= __rhs.base(); }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // According to the resolution of DR179 not only the various comparison
+  // operators but also operator- must accept mixed iterator/const_iterator
+  // parameters.
+  template<typename _IteratorL, typename _IteratorR, typename _Sequence>
+    inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type
+    operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
+	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type
+    operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
+	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Sequence>
+    inline __iterator_tracker<_Iterator, _Sequence>
+    operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type
+	      __n,
+	      const __iterator_tracker<_Iterator, _Sequence>& __i)
+    _GLIBCXX_NOEXCEPT
+    { return __i + __n; }
+	
+}  // namespace __profile
+}  // namespace std
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/list b/gcc-4.9/libstdc++-v3/include/profile/list
new file mode 100644
index 0000000..87d99a0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/list
@@ -0,0 +1,694 @@
+// Profiling list implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/list
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_LIST
+#define _GLIBCXX_PROFILE_LIST 1
+
+#include <list>
+#include <profile/base.h> 
+#include <profile/iterator_tracker.h> 
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /** @brief List wrapper with performance instrumentation.  */
+template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
+    class list
+    : public _GLIBCXX_STD_C::list<_Tp, _Allocator>
+    {
+      typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
+
+    public:
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __iterator_tracker<typename _Base::iterator, list>        
+				                    iterator;
+      typedef __iterator_tracker<typename _Base::const_iterator, list>  
+                                                    const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+
+      typedef _Tp				    value_type;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      // 23.2.2.1 construct/copy/destroy:
+
+      list() _GLIBCXX_NOEXCEPT
+      : _Base()
+      {
+        __profcxx_list_construct(this); 	// list2slist
+        __profcxx_list_construct2(this); 	// list2vector
+      }
+
+      explicit
+      list(const _Allocator& __a) _GLIBCXX_NOEXCEPT
+      : _Base(__a) 
+      {
+        __profcxx_list_construct(this); 	// list2slist
+        __profcxx_list_construct2(this); 	// list2vector
+      }
+
+#if __cplusplus >= 201103L
+      explicit
+      list(size_type __n)
+      : _Base(__n) 
+      {
+        __profcxx_list_construct(this); 
+        __profcxx_list_construct2(this); 
+      }
+
+      list(size_type __n, const _Tp& __value,
+	   const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) 
+      {
+        __profcxx_list_construct(this); 
+        __profcxx_list_construct2(this); 
+      }
+#else
+      explicit
+      list(size_type __n, const _Tp& __value = _Tp(),
+	   const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a) 
+      {
+        __profcxx_list_construct(this); 
+        __profcxx_list_construct2(this); 
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+      list(_InputIterator __first, _InputIterator __last,
+	   const _Allocator& __a = _Allocator())
+      : _Base(__first, __last, __a)
+      {
+        __profcxx_list_construct(this); 
+        __profcxx_list_construct2(this); 
+      }
+
+      list(const list& __x)
+      : _Base(__x) 
+      {
+        __profcxx_list_construct(this); 
+        __profcxx_list_construct2(this); 
+      }
+
+      list(const _Base& __x)
+      : _Base(__x) 
+      {
+        __profcxx_list_construct(this); 
+        __profcxx_list_construct2(this); 
+      }
+
+#if __cplusplus >= 201103L
+      list(list&& __x) noexcept
+      : _Base(std::move(__x))
+      {
+        __profcxx_list_construct(this); 
+        __profcxx_list_construct2(this); 
+      }
+
+      list(initializer_list<value_type> __l,
+           const allocator_type& __a = allocator_type())
+        : _Base(__l, __a) { }
+#endif
+
+      ~list() _GLIBCXX_NOEXCEPT
+      { 
+        __profcxx_list_destruct(this); 
+        __profcxx_list_destruct2(this); 
+      }
+
+      list&
+      operator=(const list& __x)
+      {
+	static_cast<_Base&>(*this) = __x;
+	return *this;
+      }
+
+#if __cplusplus >= 201103L
+      list&
+      operator=(list&& __x)
+      {
+	// NB: DR 1204.
+	// NB: DR 675.
+	this->clear();
+	this->swap(__x);
+	return *this;
+      }
+
+      list&
+      operator=(initializer_list<value_type> __l)
+      {
+	static_cast<_Base&>(*this) = __l;
+	return *this;
+      }
+
+      void
+      assign(initializer_list<value_type> __l)
+      {	_Base::assign(__l); }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<class _InputIterator>
+#endif
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _Base::assign(__first, __last); }
+
+      void
+      assign(size_type __n, const _Tp& __t)
+      {	_Base::assign(__n, __t); }
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_list_rewind(this);
+        return iterator(_Base::end(), this);
+      }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_list_rewind(this);
+        return const_iterator(_Base::end(), this);
+      }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_list_rewind(this);
+        return reverse_iterator(end());
+      }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { 
+        __profcxx_list_rewind(this);
+        return const_reverse_iterator(end());
+      }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // 23.2.2.2 capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+#if __cplusplus >= 201103L
+      void
+      resize(size_type __sz)
+      { _Base::resize(__sz); }
+
+      void
+      resize(size_type __sz, const _Tp& __c)
+      { _Base::resize(__sz, __c); }
+#else
+      void
+      resize(size_type __sz, _Tp __c = _Tp())
+      { _Base::resize(__sz, __c); }
+#endif
+
+      // element access:
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      { return _Base::front(); }
+
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      { return _Base::front(); }
+
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_list_rewind(this);
+	return _Base::back();
+      }
+
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_list_rewind(this);
+	return _Base::back();
+      }
+
+      // 23.2.2.3 modifiers:
+      void
+      push_front(const value_type& __x)
+      {
+        __profcxx_list_invalid_operator(this);
+        __profcxx_list_operation(this);
+        _Base::push_front(__x);
+      }
+
+#if __cplusplus >= 201103L
+      using _Base::emplace_front;
+#endif
+
+      void
+      pop_front() _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_list_operation(this);
+	_Base::pop_front();
+      }
+
+      using _Base::push_back;
+
+#if __cplusplus >= 201103L
+      using _Base::emplace_back;
+#endif
+
+      void
+      pop_back() _GLIBCXX_NOEXCEPT
+      {
+	iterator __victim = end();
+	--__victim;
+	_Base::pop_back();
+        __profcxx_list_rewind(this);
+      }
+
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args)
+	{
+	  return iterator(_Base::emplace(__position.base(),
+                                         std::forward<_Args>(__args)...),
+			  this);
+	}
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const _Tp& __x)
+#else
+      insert(iterator __position, const _Tp& __x)
+#endif
+      {
+        _M_profile_insert(this, __position, size());
+        return iterator(_Base::insert(__position.base(), __x), this);
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, _Tp&& __x)
+      {
+        _M_profile_insert(this, __position, size());
+        return iterator(_Base::emplace(__position.base(), std::move(__x)),
+                        this); 
+      }
+
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      {
+        _M_profile_insert(this, __position, size());
+        return iterator(_Base::insert(__position.base(), __l), this);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, size_type __n, const _Tp& __x)
+      {
+        _M_profile_insert(this, __position, size());
+	return iterator(_Base::insert(__position.base(), __n, __x), this);
+      }
+#else
+      void
+      insert(iterator __position, size_type __n, const _Tp& __x)
+      {
+        _M_profile_insert(this, __position, size());
+	_Base::insert(__position.base(), __n, __x);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	iterator
+        insert(const_iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+	{
+	  _M_profile_insert(this, __position, size());
+	  return iterator(_Base::insert(__position.base(), __first, __last),
+			  this);
+	}
+#else
+      template<class _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+	       _InputIterator __last)
+	{
+	  _M_profile_insert(this, __position, size());
+	  _Base::insert(__position.base(), __first, __last);
+	}
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position) noexcept
+#else
+      erase(iterator __position)
+#endif
+      {	return iterator(_Base::erase(__position.base()), this); }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position, const_iterator __last) noexcept
+#else
+      erase(iterator __position, iterator __last)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	return iterator(_Base::erase(__position.base(), __last.base()), this);
+      }
+
+      void
+      swap(list& __x)
+      {	_Base::swap(__x); }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {	_Base::clear(); }
+
+      // 23.2.2.4 list operations:
+      void
+#if __cplusplus >= 201103L
+      splice(const_iterator __position, list&& __x) noexcept
+#else
+      splice(iterator __position, list& __x)
+#endif
+      { this->splice(__position, _GLIBCXX_MOVE(__x), __x.begin(), __x.end()); }
+
+#if __cplusplus >= 201103L
+      void
+      splice(const_iterator __position, list& __x) noexcept
+      { this->splice(__position, std::move(__x)); }
+
+      void
+      splice(const_iterator __position, list& __x, const_iterator __i)
+      { this->splice(__position, std::move(__x), __i); }
+#endif
+
+      void
+#if __cplusplus >= 201103L
+      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
+#else
+      splice(iterator __position, list& __x, iterator __i)
+#endif
+      {
+	// We used to perform the splice_alloc check:  not anymore, redundant
+	// after implementing the relevant bits of N1599.
+
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
+		      __i.base());
+      }
+
+      void
+#if __cplusplus >= 201103L
+      splice(const_iterator __position, list&& __x, const_iterator __first,
+	     const_iterator __last) noexcept
+#else
+      splice(iterator __position, list& __x, iterator __first,
+	     iterator __last)
+#endif
+      {
+	// We used to perform the splice_alloc check:  not anymore, redundant
+	// after implementing the relevant bits of N1599.
+
+	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
+		      __first.base(), __last.base());
+      }
+
+#if __cplusplus >= 201103L
+      void
+      splice(const_iterator __position, list& __x,
+	     const_iterator __first, const_iterator __last) noexcept
+      { this->splice(__position, std::move(__x), __first, __last); }
+#endif
+
+      void
+      remove(const _Tp& __value)
+      {
+	for (iterator __x = begin(); __x != end(); )
+	  {
+	    if (*__x == __value)
+	      __x = erase(__x);
+	    else
+	      ++__x;
+	  }
+      }
+
+      template<class _Predicate>
+        void
+        remove_if(_Predicate __pred)
+        {
+	  for (iterator __x = begin(); __x != end(); )
+	    {
+              __profcxx_list_operation(this);
+	      if (__pred(*__x))
+		__x = erase(__x);
+	      else
+		++__x;
+	    }
+	}
+
+      void
+      unique()
+      {
+	iterator __first = begin();
+	iterator __last = end();
+	if (__first == __last)
+	  return;
+	iterator __next = __first;
+	while (++__next != __last)
+	  {
+            __profcxx_list_operation(this);
+	    if (*__first == *__next)
+	      erase(__next);
+	    else
+	      __first = __next;
+	    __next = __first;
+	  }
+      }
+
+      template<class _BinaryPredicate>
+        void
+        unique(_BinaryPredicate __binary_pred)
+        {
+	  iterator __first = begin();
+	  iterator __last = end();
+	  if (__first == __last)
+	    return;
+	  iterator __next = __first;
+	  while (++__next != __last)
+	    {
+              __profcxx_list_operation(this);
+	      if (__binary_pred(*__first, *__next))
+		erase(__next);
+	      else
+		__first = __next;
+	      __next = __first;
+	    }
+	}
+
+      void
+#if __cplusplus >= 201103L
+      merge(list&& __x)
+#else
+      merge(list& __x)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 300. list::merge() specification incomplete
+	if (this != &__x)
+	  { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); }
+      }
+
+#if __cplusplus >= 201103L
+      void
+      merge(list& __x)
+      { this->merge(std::move(__x)); }
+#endif
+
+      template<class _Compare>
+        void
+#if __cplusplus >= 201103L
+        merge(list&& __x, _Compare __comp)
+#else
+        merge(list& __x, _Compare __comp)
+#endif
+        {
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 300. list::merge() specification incomplete
+	  if (this != &__x)
+	    { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); }
+	}
+
+#if __cplusplus >= 201103L
+      template<typename _Compare>
+        void
+        merge(list& __x, _Compare __comp)
+        { this->merge(std::move(__x), __comp); }
+#endif
+
+      void
+      sort() { _Base::sort(); }
+
+      template<typename _StrictWeakOrdering>
+        void
+        sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); }
+
+      using _Base::reverse;
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+      void _M_profile_find() const
+      { }
+
+      void _M_profile_iterate(int __rewind = 0) const 
+      {
+        __profcxx_list_operation(this);
+        __profcxx_list_iterate(this); 
+        if (__rewind)
+          __profcxx_list_rewind(this);
+      }
+
+    private:
+      size_type
+      _M_profile_insert(void* obj, const_iterator __pos, size_type __size)
+      {
+        size_type __shift = 0;
+        typename _Base::const_iterator __it = __pos.base();
+        for (; __it != _Base::end(); ++__it)
+          __shift++;
+        __profcxx_list_rewind(this);
+        __profcxx_list_operation(this);
+        __profcxx_list_insert(this, __shift, __size);
+      }
+    };
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const list<_Tp, _Alloc>& __lhs,
+	      const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const list<_Tp, _Alloc>& __lhs,
+	       const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const list<_Tp, _Alloc>& __lhs,
+	      const list<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __profile
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/map b/gcc-4.9/libstdc++-v3/include/profile/map
new file mode 100644
index 0000000..bcc6271
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/map
@@ -0,0 +1,35 @@
+// Profiling map/multimap implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/map
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_MAP
+#define _GLIBCXX_PROFILE_MAP 1
+
+#include <map>
+#include <profile/map.h>
+#include <profile/multimap.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/map.h b/gcc-4.9/libstdc++-v3/include/profile/map.h
new file mode 100644
index 0000000..6a3160b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/map.h
@@ -0,0 +1,594 @@
+// Profiling map implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/map.h
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_MAP_H
+#define _GLIBCXX_PROFILE_MAP_H 1
+
+#include <utility>
+#include <profile/base.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /// Class std::map wrapper with performance instrumentation.
+  template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
+    class map
+    : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>
+    {
+      typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
+    public:
+      // types:
+      typedef _Key                                  key_type;
+      typedef _Tp                                   mapped_type;
+      typedef std::pair<const _Key, _Tp>            value_type;
+      typedef _Compare                              key_compare;
+      typedef _Allocator                            allocator_type;
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef typename _Base::iterator       iterator;
+      typedef typename _Base::const_iterator       const_iterator;
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+      // 23.3.1.1 construct/copy/destroy:
+
+      map()
+      : _Base()
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      explicit
+      map(const _Compare& __comp,
+	  const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        map(_InputIterator __first, _InputIterator __last,
+	    const _Compare& __comp = _Compare(),
+	    const _Allocator& __a = _Allocator())
+	: _Base(__first, __last, __comp, __a)
+        { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(const map& __x)
+      : _Base(__x)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(const _Base& __x)
+      : _Base(__x)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+#if __cplusplus >= 201103L
+      map(map&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _Base(std::move(__x))
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(initializer_list<value_type> __l,
+	  const _Compare& __c = _Compare(),
+	  const allocator_type& __a = allocator_type())
+      : _Base(__l, __c, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      explicit
+      map(const allocator_type& __a)
+	: _Base(__a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(const map& __x, const allocator_type& __a)
+      : _Base(__x, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(map&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+#endif
+
+      ~map() _GLIBCXX_NOEXCEPT
+      { __profcxx_map_to_unordered_map_destruct(this); }
+
+#if __cplusplus < 201103L
+      map&
+      operator=(const map& __x)
+      {
+	_M_base() = __x;
+	return *this;
+      }
+#else
+      map&
+      operator=(const map&) = default;
+
+      map&
+      operator=(map&&) = default;
+
+      map&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+#endif
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 133. map missing get_allocator()
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator 
+      begin() _GLIBCXX_NOEXCEPT
+      { return _Base::begin(); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return _Base::begin(); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return _Base::end(); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return _Base::end(); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { 
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return reverse_iterator(end()); 
+      }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return const_reverse_iterator(end());
+      }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return reverse_iterator(begin());
+      }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return const_reverse_iterator(begin());
+      }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end()); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      {
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return const_reverse_iterator(end());
+      }
+
+      const_reverse_iterator
+      crend() const noexcept
+      {
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return const_reverse_iterator(begin());
+      }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // 23.3.1.2 element access:
+      mapped_type&
+      operator[](const key_type& __k)
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+        return _Base::operator[](__k);
+      }
+
+#if __cplusplus >= 201103L
+      mapped_type&
+      operator[](key_type&& __k)
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+        return _Base::operator[](std::move(__k));
+      }
+#endif
+
+      mapped_type&
+      at(const key_type& __k)
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+        return _Base::at(__k);
+      }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+        return _Base::at(__k);
+      }
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  __profcxx_map_to_unordered_map_insert(this, size(), 1);
+	  auto __res = _Base::emplace(std::forward<_Args>(__args)...);
+	  return std::pair<iterator, bool>(iterator(__res.first),
+					   __res.second);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  size_type size_before = size();
+	  auto __res = _Base::emplace_hint(__pos,
+					   std::forward<_Args>(__args)...);
+	  __profcxx_map_to_unordered_map_insert(this, size_before,
+						size() - size_before);
+	  return __res;
+	}
+#endif
+
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      {
+        __profcxx_map_to_unordered_map_insert(this, size(), 1);
+	typedef typename _Base::iterator _Base_iterator;
+	std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
+	return std::pair<iterator, bool>(iterator(__res.first),
+					 __res.second);
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        std::pair<iterator, bool>
+        insert(_Pair&& __x)
+        {
+	  __profcxx_map_to_unordered_map_insert(this, size(), 1);
+	  typedef typename _Base::iterator _Base_iterator;
+	  std::pair<_Base_iterator, bool> __res
+	    = _Base::insert(std::forward<_Pair>(__x));
+	  return std::pair<iterator, bool>(iterator(__res.first),
+					   __res.second);
+	}
+#endif
+
+#if __cplusplus >= 201103L
+      void
+      insert(std::initializer_list<value_type> __list)
+      { 
+        size_type size_before = size();
+        _Base::insert(__list); 
+        __profcxx_map_to_unordered_map_insert(this, size_before, 
+					      size() - size_before);
+      }
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const value_type& __x)
+#else
+      insert(iterator __position, const value_type& __x)
+#endif
+      {
+        size_type size_before = size();
+	iterator __i = iterator(_Base::insert(__position, __x));
+        __profcxx_map_to_unordered_map_insert(this, size_before,
+					      size() - size_before);
+	return __i;
+      }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        {
+	  size_type size_before = size();
+	  iterator __i
+	    = iterator(_Base::insert(__position, std::forward<_Pair>(__x)));
+	  __profcxx_map_to_unordered_map_insert(this, size_before, 
+						size() - size_before);
+	  return __i;
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        {
+          size_type size_before = size();
+	  _Base::insert(__first, __last);
+          __profcxx_map_to_unordered_map_insert(this, size_before, 
+                                                size() - size_before);
+	}
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      {
+	iterator __i = _Base::erase(__position);
+        __profcxx_map_to_unordered_map_erase(this, size(), 1);
+        return __i;
+      }
+
+      iterator
+      erase(iterator __position)
+      { return erase(const_iterator(__position)); }
+#else
+      void
+      erase(iterator __position)
+      {
+	_Base::erase(__position);
+        __profcxx_map_to_unordered_map_erase(this, size(), 1);
+      }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	iterator __victim = find(__x);
+	if (__victim == end())
+	  return 0;
+	else
+	{
+	  _Base::erase(__victim);
+	  return 1;
+	}
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return iterator(_Base::erase(__first, __last)); }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      { _Base::erase(__first, __last); }
+#endif
+
+      void
+      swap(map& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _Base::swap(__x); }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { this->erase(begin(), end()); }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // 23.3.1.3 map operations:
+      iterator
+      find(const key_type& __x)
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+        return iterator(_Base::find(__x));
+      }
+
+      const_iterator
+      find(const key_type& __x) const
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+        return const_iterator(_Base::find(__x));
+      }
+
+      size_type
+      count(const key_type& __x) const
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+        return _Base::count(__x);
+      }
+
+      iterator
+      lower_bound(const key_type& __x)
+      { 
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return iterator(_Base::lower_bound(__x)); 
+      }
+
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { 
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return const_iterator(_Base::lower_bound(__x)); 
+      }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { 
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return iterator(_Base::upper_bound(__x)); 
+      }
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { 
+        __profcxx_map_to_unordered_map_invalidate(this);
+        return const_iterator(_Base::upper_bound(__x)); 
+      }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	typedef typename _Base::iterator _Base_iterator;
+	std::pair<_Base_iterator, _Base_iterator> __res =
+	_Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first),
+			      iterator(__res.second));
+      }
+
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+        __profcxx_map_to_unordered_map_find(this, size());
+	typedef typename _Base::const_iterator _Base_const_iterator;
+	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+	_Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first),
+			      const_iterator(__res.second));
+      }
+
+      _Base& 
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    };
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { 
+      __profcxx_map_to_unordered_map_invalidate(&__lhs);
+      __profcxx_map_to_unordered_map_invalidate(&__rhs);
+      return __lhs._M_base() == __rhs._M_base(); 
+    }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { 
+      __profcxx_map_to_unordered_map_invalidate(&__lhs);
+      __profcxx_map_to_unordered_map_invalidate(&__rhs);
+      return __lhs._M_base() != __rhs._M_base(); 
+    }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    {
+      __profcxx_map_to_unordered_map_invalidate(&__lhs);
+      __profcxx_map_to_unordered_map_invalidate(&__rhs);
+      return __lhs._M_base() < __rhs._M_base(); 
+    }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    {
+      __profcxx_map_to_unordered_map_invalidate(&__lhs);
+      __profcxx_map_to_unordered_map_invalidate(&__rhs);
+      return __lhs._M_base() <= __rhs._M_base();
+    }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    {
+      __profcxx_map_to_unordered_map_invalidate(&__lhs);
+      __profcxx_map_to_unordered_map_invalidate(&__rhs);
+      return __lhs._M_base() >= __rhs._M_base();
+    }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    {
+      __profcxx_map_to_unordered_map_invalidate(&__lhs);
+      __profcxx_map_to_unordered_map_invalidate(&__rhs);
+      return __lhs._M_base() > __rhs._M_base();
+    }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline void
+    swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	 map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __profile
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/multimap.h b/gcc-4.9/libstdc++-v3/include/profile/multimap.h
new file mode 100644
index 0000000..5ba5355
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/multimap.h
@@ -0,0 +1,432 @@
+// Profiling multimap implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/multimap.h
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_MULTIMAP_H
+#define _GLIBCXX_PROFILE_MULTIMAP_H 1
+
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /// Class std::multimap wrapper with performance instrumentation.
+  template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
+    class multimap
+    : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>
+    {
+      typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
+    public:
+      // types:
+      typedef _Key				     key_type;
+      typedef _Tp				     mapped_type;
+      typedef std::pair<const _Key, _Tp>             value_type;
+      typedef _Compare                               key_compare;
+      typedef _Allocator                             allocator_type;
+      typedef typename _Base::reference              reference;
+      typedef typename _Base::const_reference        const_reference;
+
+      typedef typename _Base::iterator               iterator;
+      typedef typename _Base::const_iterator         const_iterator;
+      typedef typename _Base::reverse_iterator       reverse_iterator;
+      typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+
+      typedef typename _Base::size_type              size_type;
+      typedef typename _Base::difference_type        difference_type;
+      typedef typename _Base::pointer                pointer;
+      typedef typename _Base::const_pointer          const_pointer;
+
+      // 23.3.1.1 construct/copy/destroy:
+
+      multimap()
+      : _Base() { }
+
+      explicit multimap(const _Compare& __comp,
+			const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a) { }
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+      multimap(_InputIterator __first, _InputIterator __last,
+	       const _Compare& __comp = _Compare(),
+	       const _Allocator& __a = _Allocator())
+      : _Base(__first, __last, __comp, __a) { }
+
+#if __cplusplus < 201103L
+      multimap(const multimap& __x)
+      : _Base(__x) { }
+#else
+      multimap(const multimap&) = default;
+      multimap(multimap&&) = default;
+
+      multimap(initializer_list<value_type> __l,
+	       const _Compare& __c = _Compare(),
+	       const allocator_type& __a = allocator_type())
+      : _Base(__l, __c, __a) { }
+
+      explicit
+      multimap(const allocator_type& __a)
+	: _Base(__a) { }
+
+      multimap(const multimap& __x, const allocator_type& __a)
+      : _Base(__x, __a) { }
+
+      multimap(multimap&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a) { }
+
+      multimap(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a) { }
+
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a) { }
+#endif
+
+      multimap(const _Base& __x)
+      : _Base(__x) { }
+
+      ~multimap() _GLIBCXX_NOEXCEPT { }
+
+#if __cplusplus < 201103L
+      multimap&
+      operator=(const multimap& __x)
+      {
+	_M_base() = __x;
+	return *this;
+      }
+#else
+      multimap&
+      operator=(const multimap&) = default;
+
+      multimap&
+      operator=(multimap&&) = default;
+
+      multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin()); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin()); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end()); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end()); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end()); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{
+	  return iterator(_Base::emplace(std::forward<_Args>(__args)...));
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  return iterator(_Base::emplace_hint(__pos,
+					      std::forward<_Args>(__args)...));
+	}
+#endif
+      
+      iterator
+      insert(const value_type& __x)
+      { return iterator(_Base::insert(__x)); }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(_Pair&& __x)
+        { return iterator(_Base::insert(std::forward<_Pair>(__x))); }
+#endif
+
+#if __cplusplus >= 201103L
+      void
+      insert(std::initializer_list<value_type> __list)
+      { _Base::insert(__list); }
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const value_type& __x)
+#else
+      insert(iterator __position, const value_type& __x)
+#endif
+      { return iterator(_Base::insert(__position, __x)); }
+
+#if __cplusplus >= 201103L
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        { return iterator(_Base::insert(__position,
+					std::forward<_Pair>(__x))); }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _Base::insert(__first, __last); }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      { return iterator(_Base::erase(__position)); }
+
+      iterator
+      erase(iterator __position)
+      { return iterator(_Base::erase(__position)); }
+#else
+      void
+      erase(iterator __position)
+      { _Base::erase(__position); }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	std::pair<iterator, iterator> __victims = this->equal_range(__x);
+	size_type __count = 0;
+	while (__victims.first != __victims.second)
+	{
+	  iterator __victim = __victims.first++;
+	  _Base::erase(__victim);
+	  ++__count;
+	}
+	return __count;
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return iterator(_Base::erase(__first, __last)); }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      { _Base::erase(__first, __last); }
+#endif
+
+      void
+      swap(multimap& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _Base::swap(__x); }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { this->erase(begin(), end()); }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // 23.3.1.3 multimap operations:
+      iterator
+      find(const key_type& __x)
+      { return iterator(_Base::find(__x)); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return const_iterator(_Base::find(__x)); }
+
+      using _Base::count;
+
+      iterator
+      lower_bound(const key_type& __x)
+      { return iterator(_Base::lower_bound(__x)); }
+
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return const_iterator(_Base::lower_bound(__x)); }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return iterator(_Base::upper_bound(__x)); }
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return const_iterator(_Base::upper_bound(__x)); }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	typedef typename _Base::iterator _Base_iterator;
+	std::pair<_Base_iterator, _Base_iterator> __res =
+	_Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first),
+			      iterator(__res.second));
+      }
+
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+	typedef typename _Base::const_iterator _Base_const_iterator;
+	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+	_Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first),
+			      const_iterator(__res.second));
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+    };
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	       const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	      const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Key, typename _Tp,
+	   typename _Compare, typename _Allocator>
+    inline void
+    swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
+	 multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    { __lhs.swap(__rhs); }
+
+} // namespace __profile
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/multiset.h b/gcc-4.9/libstdc++-v3/include/profile/multiset.h
new file mode 100644
index 0000000..8ef6e6b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/multiset.h
@@ -0,0 +1,417 @@
+// Profiling multiset implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/multiset.h
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_MULTISET_H
+#define _GLIBCXX_PROFILE_MULTISET_H 1
+
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /// Class std::multiset wrapper with performance instrumentation.
+  template<typename _Key, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<_Key> >
+    class multiset
+    : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>
+    {
+      typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
+    public:
+      // types:
+      typedef _Key				     key_type;
+      typedef _Key				     value_type;
+      typedef _Compare				     key_compare;
+      typedef _Compare				     value_compare;
+      typedef _Allocator			     allocator_type;
+      typedef typename _Base::reference	             reference;
+      typedef typename _Base::const_reference        const_reference;
+
+      typedef typename _Base::iterator               iterator;
+      typedef typename _Base::const_iterator         const_iterator;
+      typedef typename _Base::reverse_iterator       reverse_iterator;
+      typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+
+      typedef typename _Base::size_type              size_type;
+      typedef typename _Base::difference_type        difference_type;
+      typedef typename _Base::pointer                pointer;
+      typedef typename _Base::const_pointer          const_pointer;
+
+      // 23.3.3.1 construct/copy/destroy:
+
+      multiset()
+      : _Base() { }
+
+      explicit multiset(const _Compare& __comp,
+			const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a) { }
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        multiset(_InputIterator __first, _InputIterator __last,
+		 const _Compare& __comp = _Compare(),
+		 const _Allocator& __a = _Allocator())
+	: _Base(__first, __last, __comp, __a) { }
+
+#if __cplusplus < 201103L
+      multiset(const multiset& __x)
+      : _Base(__x) { }
+#else
+      multiset(const multiset&) = default;
+      multiset(multiset&&) = default;
+
+      multiset(initializer_list<value_type> __l,
+	       const _Compare& __comp = _Compare(),
+	       const allocator_type& __a = allocator_type())
+      : _Base(__l, __comp, __a) { }
+
+      explicit
+      multiset(const allocator_type& __a)
+	: _Base(__a) { }
+
+      multiset(const multiset& __x, const allocator_type& __a)
+      : _Base(__x, __a) { }
+
+      multiset(multiset&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a) { }
+
+      multiset(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a) { }
+
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a) { }
+#endif
+
+      multiset(const _Base& __x)
+      : _Base(__x) { }
+
+      ~multiset() _GLIBCXX_NOEXCEPT { }
+
+#if __cplusplus < 201103L
+      multiset&
+      operator=(const multiset& __x)
+      {
+	_M_base() = __x;
+	return *this;
+      }
+#else
+      multiset&
+      operator=(const multiset&) = default;
+
+      multiset&
+      operator=(multiset&&) = default;
+
+      multiset&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin()); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin()); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end()); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end()); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end()); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{ return iterator(_Base::emplace(std::forward<_Args>(__args)...)); }
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  return iterator(_Base::emplace_hint(__pos,
+					      std::forward<_Args>(__args)...));
+	}
+#endif
+
+      iterator
+      insert(const value_type& __x)
+      { return iterator(_Base::insert(__x)); }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(value_type&& __x)
+      { return iterator(_Base::insert(std::move(__x))); }
+#endif
+
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      { return iterator(_Base::insert(__position, __x)); }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return iterator(_Base::insert(__position, std::move(__x))); }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _Base::insert(__first, __last); }
+
+#if __cplusplus >= 201103L
+      void
+      insert(initializer_list<value_type> __l)
+      { _Base::insert(__l); }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      { return iterator(_Base::erase(__position)); }
+#else
+      void
+      erase(iterator __position)
+      { _Base::erase(__position); }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	std::pair<iterator, iterator> __victims = this->equal_range(__x);
+	size_type __count = 0;
+	while (__victims.first != __victims.second)
+	{
+	  iterator __victim = __victims.first++;
+	  _Base::erase(__victim);
+	  ++__count;
+	}
+	return __count;
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return iterator(_Base::erase(__first, __last)); }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      { _Base::erase(__first, __last); }
+#endif
+
+      void
+      swap(multiset& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _Base::swap(__x); }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { this->erase(begin(), end()); }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // multiset operations:
+      iterator
+      find(const key_type& __x)
+      { return iterator(_Base::find(__x)); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      find(const key_type& __x) const
+      { return const_iterator(_Base::find(__x)); }
+
+      using _Base::count;
+
+      iterator
+      lower_bound(const key_type& __x)
+      { return iterator(_Base::lower_bound(__x)); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return const_iterator(_Base::lower_bound(__x)); }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return iterator(_Base::upper_bound(__x)); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return const_iterator(_Base::upper_bound(__x)); }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	typedef typename _Base::iterator _Base_iterator;
+	std::pair<_Base_iterator, _Base_iterator> __res =
+        _Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first),
+			      iterator(__res.second));
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+	typedef typename _Base::const_iterator _Base_iterator;
+	std::pair<_Base_iterator, _Base_iterator> __res =
+        _Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first),
+			      const_iterator(__res.second));
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    };
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	      const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	       const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const multiset<_Key, _Compare, _Allocator>& __lhs,
+	      const multiset<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    void
+    swap(multiset<_Key, _Compare, _Allocator>& __x,
+	 multiset<_Key, _Compare, _Allocator>& __y)
+    { return __x.swap(__y); }
+
+} // namespace __profile
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/set b/gcc-4.9/libstdc++-v3/include/profile/set
new file mode 100644
index 0000000..675eaf2
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/set
@@ -0,0 +1,35 @@
+// Profiling set/multiset implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/set
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_SET
+#define _GLIBCXX_PROFILE_SET 1
+
+#include <set>
+#include <profile/set.h>
+#include <profile/multiset.h>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/set.h b/gcc-4.9/libstdc++-v3/include/profile/set.h
new file mode 100644
index 0000000..05fbeb9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/set.h
@@ -0,0 +1,431 @@
+// Profiling set implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/set.h
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_SET_H
+#define _GLIBCXX_PROFILE_SET_H 1
+
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default) 
+{
+namespace __profile
+{
+  /// Class std::set wrapper with performance instrumentation.
+  template<typename _Key, typename _Compare = std::less<_Key>,
+	   typename _Allocator = std::allocator<_Key> >
+    class set
+    : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>
+    {
+      typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
+    public:
+      // types:
+      typedef _Key				    key_type;
+      typedef _Key				    value_type;
+      typedef _Compare				    key_compare;
+      typedef _Compare				    value_compare;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef typename _Base::iterator               iterator;
+      typedef typename _Base::const_iterator         const_iterator;
+      typedef typename _Base::reverse_iterator       reverse_iterator;
+      typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+
+      // 23.3.3.1 construct/copy/destroy:
+
+      set()
+      : _Base() { }
+
+      explicit set(const _Compare& __comp,
+		   const _Allocator& __a = _Allocator())
+      : _Base(__comp, __a) { }
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        set(_InputIterator __first, _InputIterator __last,
+	    const _Compare& __comp = _Compare(),
+	    const _Allocator& __a = _Allocator())
+	: _Base(__first, __last, __comp, __a) { }
+
+#if __cplusplus < 201103L
+      set(const set& __x)
+      : _Base(__x) { }
+#else
+      set(const set&) = default;
+      set(set&&) = default;
+
+      set(initializer_list<value_type> __l,
+	  const _Compare& __comp = _Compare(),
+	  const allocator_type& __a = allocator_type())
+      : _Base(__l, __comp, __a) { }
+
+      explicit
+      set(const allocator_type& __a)
+	: _Base(__a) { }
+
+      set(const set& __x, const allocator_type& __a)
+      : _Base(__x, __a) { }
+
+      set(set&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a) { }
+
+      set(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a) { }
+
+      template<typename _InputIterator>
+        set(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a) { }
+#endif
+
+      set(const _Base& __x)
+      : _Base(__x) { }
+
+      ~set() _GLIBCXX_NOEXCEPT { }
+
+#if __cplusplus < 201103L
+      set&
+      operator=(const set& __x)
+      {
+	_M_base() = __x;
+	return *this;
+      }
+#else
+      set&
+      operator=(const set&) = default;
+
+      set&
+      operator=(set&&) = default;
+
+      set&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+#endif
+
+      using _Base::get_allocator;
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin()); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin()); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end()); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end()); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end()); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // capacity:
+      using _Base::empty;
+      using _Base::size;
+      using _Base::max_size;
+
+      // modifiers:
+#if __cplusplus >= 201103L
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  auto __res = _Base::emplace(std::forward<_Args>(__args)...);
+	  return std::pair<iterator, bool>(iterator(__res.first),
+					   __res.second);
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __pos, _Args&&... __args)
+	{
+	  return iterator(_Base::emplace_hint(__pos,
+					      std::forward<_Args>(__args)...));
+	}
+#endif
+
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      {
+	typedef typename _Base::iterator _Base_iterator;
+	std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
+	return std::pair<iterator, bool>(iterator(__res.first),
+					 __res.second);
+      }
+
+#if __cplusplus >= 201103L
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      {
+	typedef typename _Base::iterator _Base_iterator;
+	std::pair<_Base_iterator, bool> __res
+	  = _Base::insert(std::move(__x));
+	return std::pair<iterator, bool>(iterator(__res.first),
+					 __res.second);
+      }
+#endif
+
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      { return iterator(_Base::insert(__position, __x)); }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return iterator(_Base::insert(__position, std::move(__x))); }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _Base::insert(__first, __last); }
+
+#if __cplusplus >= 201103L
+      void
+      insert(initializer_list<value_type> __l)
+      { _Base::insert(__l); }
+#endif
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __position)
+      { return iterator(_Base::erase(__position)); }
+#else
+      void
+      erase(iterator __position)
+      { _Base::erase(__position); }
+#endif
+
+      size_type
+      erase(const key_type& __x)
+      {
+	iterator __victim = find(__x);
+	if (__victim == end())
+          return 0;
+	else
+        {
+	  _Base::erase(__victim);
+	  return 1;
+        }
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return iterator(_Base::erase(__first, __last)); }
+#else
+      void
+      erase(iterator __first, iterator __last)
+      { _Base::erase(__first, __last); }
+#endif
+
+      void
+      swap(set& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      { _Base::swap(__x); }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      { this->erase(begin(), end()); }
+
+      // observers:
+      using _Base::key_comp;
+      using _Base::value_comp;
+
+      // set operations:
+      iterator
+      find(const key_type& __x)
+      { return iterator(_Base::find(__x)); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      find(const key_type& __x) const
+      { return const_iterator(_Base::find(__x)); }
+
+      using _Base::count;
+
+      iterator
+      lower_bound(const key_type& __x)
+      { return iterator(_Base::lower_bound(__x)); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return const_iterator(_Base::lower_bound(__x)); }
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return iterator(_Base::upper_bound(__x)); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return const_iterator(_Base::upper_bound(__x)); }
+
+      std::pair<iterator,iterator>
+      equal_range(const key_type& __x)
+      {
+	typedef typename _Base::iterator _Base_iterator;
+	std::pair<_Base_iterator, _Base_iterator> __res =
+        _Base::equal_range(__x);
+	return std::make_pair(iterator(__res.first),
+			      iterator(__res.second));
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 214. set::find() missing const overload
+      std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& __x) const
+      {
+	typedef typename _Base::const_iterator _Base_iterator;
+	std::pair<_Base_iterator, _Base_iterator> __res =
+        _Base::equal_range(__x);
+	return std::make_pair(const_iterator(__res.first),
+			      const_iterator(__res.second));
+      }
+
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+    };
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator==(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator!=(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<(const set<_Key, _Compare, _Allocator>& __lhs,
+	      const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator<=(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>=(const set<_Key, _Compare, _Allocator>& __lhs,
+	       const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    inline bool
+    operator>(const set<_Key, _Compare, _Allocator>& __lhs,
+	      const set<_Key, _Compare, _Allocator>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Key, typename _Compare, typename _Allocator>
+    void
+    swap(set<_Key, _Compare, _Allocator>& __x,
+	 set<_Key, _Compare, _Allocator>& __y)
+    { return __x.swap(__y); }
+
+} // namespace __profile
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/unordered_base.h b/gcc-4.9/libstdc++-v3/include/profile/unordered_base.h
new file mode 100644
index 0000000..6c52f0a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/unordered_base.h
@@ -0,0 +1,262 @@
+// Profiling unordered containers implementation details -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/unordered_base.h
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_UNORDERED
+#define _GLIBCXX_PROFILE_UNORDERED 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  template<typename _UnorderedCont,
+	   typename _Value, bool _Cache_hash_code>
+    struct _Bucket_index_helper;
+
+  template<typename _UnorderedCont, typename _Value>
+    struct _Bucket_index_helper<_UnorderedCont, _Value, true>
+    {
+      static std::size_t
+      bucket(const _UnorderedCont& __uc,
+	     const __detail::_Hash_node<_Value, true>* __node)
+      { return __node->_M_hash_code % __uc.bucket_count(); }
+    };
+
+  template<typename _UnorderedCont, typename _Value>
+    struct _Bucket_index_helper<_UnorderedCont, _Value, false>
+    {
+      static std::size_t
+      bucket(const _UnorderedCont& __uc,
+	     const __detail::_Hash_node<_Value, false>* __node)
+      { return __uc.bucket(__node->_M_v()); }
+    };
+
+  template<typename _UnorderedCont, typename _Key, typename _Mapped>
+    struct _Bucket_index_helper<_UnorderedCont,
+				std::pair<const _Key, _Mapped>, false>
+    {
+      typedef std::pair<const _Key, _Mapped> _Value;
+
+      static std::size_t
+      bucket(const _UnorderedCont& __uc,
+	     const __detail::_Hash_node<_Value, false>* __node)
+      { return __uc.bucket(__node->_M_v().first); }
+    };
+
+  template<typename _UnorderedCont, typename _Value, bool _Cache_hash_code>
+    std::size_t
+    __get_bucket_index(const _UnorderedCont& __uc,
+		       const __detail::_Hash_node<_Value, _Cache_hash_code>* __node)
+    {
+      using __bucket_index_helper
+	= _Bucket_index_helper<_UnorderedCont, _Value, _Cache_hash_code>;
+      return __bucket_index_helper::bucket(__uc, __node);
+    }
+
+  template<typename _UnorderedCont,
+	   typename _Value, bool _Cache_hash_code>
+    struct _Equal_helper;
+
+  template<typename _UnorderedCont, typename _Value>
+    struct _Equal_helper<_UnorderedCont, _Value, true>
+    {
+      static std::size_t
+      are_equal(const _UnorderedCont& __uc,
+		const __detail::_Hash_node<_Value, true>* __lhs,
+		const __detail::_Hash_node<_Value, true>* __rhs)
+      {
+	return __lhs->_M_hash_code == __rhs->_M_hash_code
+	  && __uc.key_eq()(__lhs->_M_v(), __rhs->_M_v());
+      }
+    };
+
+  template<typename _UnorderedCont,
+	   typename _Value>
+    struct _Equal_helper<_UnorderedCont, _Value, false>
+    {
+      static std::size_t
+      are_equal(const _UnorderedCont& __uc,
+		const __detail::_Hash_node<_Value, false>* __lhs,
+		const __detail::_Hash_node<_Value, false>* __rhs)
+      { return __uc.key_eq()(__lhs->_M_v(), __rhs->_M_v()); }
+    };
+
+  template<typename _UnorderedCont,
+	   typename _Key, typename _Mapped>
+    struct _Equal_helper<_UnorderedCont, std::pair<const _Key, _Mapped>, true>
+    {
+      typedef std::pair<const _Key, _Mapped> _Value;
+
+      static std::size_t
+      are_equal(const _UnorderedCont& __uc,
+		const __detail::_Hash_node<_Value, true>* __lhs,
+		const __detail::_Hash_node<_Value, true>* __rhs)
+      {
+	return __lhs->_M_hash_code == __rhs->_M_hash_code
+	  && __uc.key_eq()(__lhs->_M_v().first, __rhs->_M_v().first);
+      }
+    };
+
+  template<typename _UnorderedCont,
+	   typename _Key, typename _Mapped>
+    struct _Equal_helper<_UnorderedCont, std::pair<const _Key, _Mapped>, false>
+    {
+      typedef std::pair<const _Key, _Mapped> _Value;
+
+      static std::size_t
+      are_equal(const _UnorderedCont& __uc,
+		const __detail::_Hash_node<_Value, false>* __lhs,
+		const __detail::_Hash_node<_Value, false>* __rhs)
+      { return __uc.key_eq()(__lhs->_M_v().first, __rhs->_M_v().first); }
+    };
+
+  template<typename _UnorderedCont, typename _Value, bool _Cache_hash_code>
+    bool
+    __are_equal(const _UnorderedCont& __uc,
+		const __detail::_Hash_node<_Value, _Cache_hash_code>* __lhs,
+		const __detail::_Hash_node<_Value, _Cache_hash_code>* __rhs)
+  {
+    using __equal_helper
+      = _Equal_helper<_UnorderedCont, _Value, _Cache_hash_code>;
+    return __equal_helper::are_equal(__uc, __lhs, __rhs);
+  }
+
+  template<typename _UnorderedCont, bool _Unique_keys>
+    class _Unordered_profile
+    {
+      _UnorderedCont&
+      _M_conjure()
+      { return *(static_cast<_UnorderedCont*>(this)); }
+
+      using __unique_keys = std::integral_constant<bool, _Unique_keys>;
+
+    protected:
+      _Unordered_profile()
+      {
+	auto& __uc = _M_conjure();
+        __profcxx_hashtable_construct(&__uc, __uc.bucket_count());
+	__profcxx_hashtable_construct2(&__uc);
+      }
+      _Unordered_profile(const _Unordered_profile&)
+	: _Unordered_profile() { }
+      _Unordered_profile(_Unordered_profile&&)
+	: _Unordered_profile() { }
+
+      ~_Unordered_profile() noexcept
+      {
+	auto& __uc = _M_conjure();
+        __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size());
+        _M_profile_destruct();
+      }
+
+      _Unordered_profile&
+      operator=(const _Unordered_profile&) = default;
+
+      _Unordered_profile&
+      operator=(_Unordered_profile&&) = default;
+
+      void
+      _M_profile_destruct()
+      {
+	if (!__profcxx_inefficient_hash_is_on())
+	  return;
+
+	_M_profile_destruct(__unique_keys());
+      }
+
+    private:
+      void
+      _M_profile_destruct(std::true_type);
+
+      void
+      _M_profile_destruct(std::false_type);
+    };
+
+  template<typename _UnorderedCont, bool _Unique_keys>
+    void
+    _Unordered_profile<_UnorderedCont, _Unique_keys>::
+    _M_profile_destruct(std::true_type)
+    {
+      auto& __uc = _M_conjure();
+      std::size_t __hops = 0, __lc = 0, __chain = 0;
+      auto __it = __uc.begin();
+      while (__it != __uc.end())
+	{
+	  auto __bkt = __get_bucket_index(__uc, __it._M_cur);
+	  auto __lit = __uc.begin(__bkt);
+	  auto __lend = __uc.end(__bkt);
+	  for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
+	    ++__chain;
+	  if (__chain)
+	    {
+	      ++__chain;
+	      __lc = __lc > __chain ? __lc : __chain;
+	      __hops += __chain * (__chain - 1) / 2;
+	      __chain = 0;
+	    }
+	}
+      __profcxx_hashtable_destruct2(&__uc, __lc, __uc.size(), __hops);
+    }
+
+  template<typename _UnorderedCont, bool _Unique_keys>
+    void
+    _Unordered_profile<_UnorderedCont, _Unique_keys>::
+    _M_profile_destruct(std::false_type)
+    {
+      auto& __uc = _M_conjure();
+      std::size_t __hops = 0, __lc = 0, __chain = 0, __unique_size = 0;
+      auto __it = __uc.begin();
+      while (__it != __uc.end())
+	{
+	  auto __bkt = __get_bucket_index(__uc, __it._M_cur);
+	  auto __lit = __uc.begin(__bkt);
+	  auto __lend = __uc.end(__bkt);
+	  auto __pit = __it;
+	  ++__unique_size;
+	  for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
+	    {
+	      if (!__are_equal(__uc, __pit._M_cur, __it._M_cur))
+		{
+		  ++__chain;
+		  ++__unique_size;
+		  __pit = __it;
+		}
+	    }
+	  if (__chain)
+	    {
+	      ++__chain;
+	      __lc = __lc > __chain ? __lc : __chain;
+	      __hops += __chain * (__chain - 1) / 2;
+	      __chain = 0;
+	    }
+	}
+      __profcxx_hashtable_destruct2(&__uc, __lc, __unique_size, __hops);
+    }
+
+} // namespace __profile
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/unordered_map b/gcc-4.9/libstdc++-v3/include/profile/unordered_map
new file mode 100644
index 0000000..9944382
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/unordered_map
@@ -0,0 +1,534 @@
+// Profiling unordered_map/unordered_multimap implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/unordered_map
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_UNORDERED_MAP
+#define _GLIBCXX_PROFILE_UNORDERED_MAP 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+# include <unordered_map>
+
+#include <profile/base.h>
+#include <profile/unordered_base.h>
+
+#define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /// Class std::unordered_map wrapper with performance instrumentation.
+  template<typename _Key, typename _Tp,
+	   typename _Hash = std::hash<_Key>,
+	   typename _Pred = std::equal_to<_Key>,
+	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_map
+    : public _GLIBCXX_STD_BASE,
+      public _Unordered_profile<unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
+				true>
+    {
+      typedef typename _GLIBCXX_STD_BASE _Base;
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::difference_type difference_type;
+      typedef typename _Base::reference       reference;
+      typedef typename _Base::const_reference const_reference;
+      typedef typename _Base::mapped_type      mapped_type;
+
+      typedef typename _Base::iterator iterator;
+      typedef typename _Base::const_iterator const_iterator;
+
+      explicit
+      unordered_map(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+	: _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+        unordered_map(_InputIterator __f, _InputIterator __l,
+		      size_type __n = 0,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+	  : _Base(__f, __l, __n, __hf, __eql, __a)
+        { }
+
+      unordered_map(const unordered_map&) = default;
+
+      unordered_map(const _Base& __x)
+	: _Base(__x)
+      { }
+
+      unordered_map(unordered_map&&) = default;
+
+      explicit
+      unordered_map(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_map(const unordered_map& __umap,
+		    const allocator_type& __a)
+	: _Base(__umap, __a)
+      { }
+
+      unordered_map(unordered_map&& __umap,
+		    const allocator_type& __a)
+	: _Base(std::move(__umap._M_base()), __a)
+      { }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n = 0,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+	: _Base(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_map&
+      operator=(const unordered_map&) = default;
+
+      unordered_map&
+      operator=(unordered_map&&) = default;
+
+      unordered_map&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+
+      void
+      clear() noexcept
+      {
+        __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+				     _Base::size());
+        this->_M_profile_destruct();
+	_Base::clear();
+      }
+
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  std::pair<iterator, bool> __res
+	    = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __it, _Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  iterator __res
+	    = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      { 
+        size_type __old_size = _Base::bucket_count(); 
+        _Base::insert(__l);
+        _M_profile_resize(__old_size); 
+      }
+
+      std::pair<iterator, bool>
+      insert(const value_type& __obj)
+      {
+        size_type __old_size = _Base::bucket_count();
+        std::pair<iterator, bool> __res = _Base::insert(__obj);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      iterator
+      insert(const_iterator __iter, const value_type& __v)
+      { 
+        size_type __old_size = _Base::bucket_count(); 
+        iterator __res = _Base::insert(__iter, __v);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        std::pair<iterator, bool>
+        insert(_Pair&& __obj)
+        {
+	  size_type __old_size = _Base::bucket_count();
+	  std::pair<iterator, bool> __res
+	    = _Base::insert(std::forward<_Pair>(__obj));
+	  _M_profile_resize(__old_size); 
+	  return __res;
+	}
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __iter, _Pair&& __v)
+        { 
+	  size_type __old_size = _Base::bucket_count(); 
+	  iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
+	  _M_profile_resize(__old_size); 
+	  return __res;
+	}
+
+      template<typename _InputIter>
+        void
+        insert(_InputIter __first, _InputIter __last)
+        {
+	  size_type __old_size = _Base::bucket_count(); 
+	  _Base::insert(__first, __last);
+	  _M_profile_resize(__old_size); 
+	}
+
+      // operator[]
+      mapped_type&
+      operator[](const _Key& __k)
+      {
+        size_type __old_size = _Base::bucket_count();
+        mapped_type& __res = _M_base()[__k];
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      mapped_type&
+      operator[](_Key&& __k)
+      {
+        size_type __old_size = _Base::bucket_count();
+        mapped_type& __res = _M_base()[std::move(__k)];
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      void
+      swap(unordered_map& __x)
+      noexcept( noexcept(__x._M_base().swap(__x)) )
+      { _Base::swap(__x._M_base()); }
+
+      void rehash(size_type __n)
+      {
+	size_type __old_size = _Base::bucket_count();
+	_Base::rehash(__n);
+	_M_profile_resize(__old_size); 
+      }
+
+    private:
+      void
+      _M_profile_resize(size_type __old_size)
+      {
+	size_type __new_size = _Base::bucket_count();
+	if (__old_size != __new_size)
+	  __profcxx_hashtable_resize(this, __old_size, __new_size);
+      }
+  };
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+#undef _GLIBCXX_BASE
+#undef _GLIBCXX_STD_BASE
+#define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
+
+  /// Class std::unordered_multimap wrapper with performance instrumentation.
+  template<typename _Key, typename _Tp,
+	   typename _Hash = std::hash<_Key>,
+	   typename _Pred = std::equal_to<_Key>,
+	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_multimap
+    : public _GLIBCXX_STD_BASE,
+      public _Unordered_profile<unordered_multimap<_Key, _Tp,
+						   _Hash, _Pred, _Alloc>,
+				false>
+    {      
+      typedef typename _GLIBCXX_STD_BASE _Base;
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::difference_type difference_type;
+      typedef typename _Base::reference       reference;
+      typedef typename _Base::const_reference const_reference;
+
+      typedef typename _Base::iterator iterator;
+      typedef typename _Base::const_iterator const_iterator;
+
+      explicit
+      unordered_multimap(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+	: _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+        unordered_multimap(_InputIterator __f, _InputIterator __l,
+			   size_type __n = 0,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+	  : _Base(__f, __l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_multimap(const unordered_multimap&) = default;
+
+      unordered_multimap(const _Base& __x)
+	: _Base(__x)
+      { }
+
+      unordered_multimap(unordered_multimap&&) = default;
+
+      explicit
+      unordered_multimap(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_multimap(const unordered_multimap& __ummap,
+			 const allocator_type& __a)
+	: _Base(__ummap._M_base(), __a)
+      { }
+
+      unordered_multimap(unordered_multimap&& __ummap,
+			 const allocator_type& __a)
+	: _Base(std::move(__ummap._M_base()), __a)
+      { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n = 0,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_multimap&
+      operator=(const unordered_multimap&) = default;
+
+      unordered_multimap&
+      operator=(unordered_multimap&&) = default;
+
+      unordered_multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+
+      void
+      clear() noexcept
+      {
+	__profcxx_hashtable_destruct(this, _Base::bucket_count(), 
+				     _Base::size());
+	this->_M_profile_destruct();
+	_Base::clear();
+      }
+
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  iterator __res
+	    = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __it, _Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  iterator __res
+	    = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      { 
+        size_type __old_size = _Base::bucket_count();
+        _Base::insert(__l);
+        _M_profile_resize(__old_size);
+      }
+
+      iterator
+      insert(const value_type& __obj)
+      {
+        size_type __old_size = _Base::bucket_count();
+        iterator __res = _Base::insert(__obj);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      iterator
+      insert(const_iterator __iter, const value_type& __v)
+      { 
+        size_type __old_size = _Base::bucket_count(); 
+        iterator __res = _Base::insert(__iter, __v);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(_Pair&& __obj)
+        {
+	  size_type __old_size = _Base::bucket_count();
+	  iterator __res = _Base::insert(std::forward<_Pair>(__obj));
+	  _M_profile_resize(__old_size); 
+	  return __res;
+	}
+
+      template<typename _Pair, typename = typename
+	       std::enable_if<std::is_constructible<value_type,
+						    _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __iter, _Pair&& __v)
+        {
+	  size_type __old_size = _Base::bucket_count(); 
+	  iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
+	  _M_profile_resize(__old_size); 
+	  return __res;
+	}
+
+      template<typename _InputIter>
+        void
+        insert(_InputIter __first, _InputIter __last)
+        {
+	  size_type __old_size = _Base::bucket_count(); 
+	  _Base::insert(__first, __last);
+	  _M_profile_resize(__old_size); 
+	}
+
+      void
+      swap(unordered_multimap& __x)
+      noexcept( noexcept(__x._M_base().swap(__x)) )
+      { _Base::swap(__x._M_base()); }
+
+      void
+      rehash(size_type __n)
+      {
+        size_type __old_size = _Base::bucket_count();
+        _Base::rehash(__n);
+        _M_profile_resize(__old_size); 
+      }
+
+    private:
+      void
+      _M_profile_resize(size_type __old_size)
+      {
+	size_type __new_size = _Base::bucket_count();
+        if (__old_size != __new_size)
+          __profcxx_hashtable_resize(this, __old_size, __new_size);
+      }
+  };
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }
+
+  template<typename _Key, typename _Tp, typename _Hash,
+	   typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+} // namespace __profile
+} // namespace std
+
+#undef _GLIBCXX_BASE
+#undef _GLIBCXX_STD_BASE
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/unordered_set b/gcc-4.9/libstdc++-v3/include/profile/unordered_set
new file mode 100644
index 0000000..a7f8ea8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/unordered_set
@@ -0,0 +1,495 @@
+// Profiling unordered_set/unordered_multiset implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/unordered_set
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_UNORDERED_SET
+#define _GLIBCXX_PROFILE_UNORDERED_SET 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+# include <unordered_set>
+
+#include <profile/base.h>
+#include <profile/unordered_base.h>
+
+#define _GLIBCXX_BASE unordered_set<_Key, _Hash, _Pred, _Alloc>
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  /** @brief Unordered_set wrapper with performance instrumentation.  */
+  template<typename _Key, 
+	   typename _Hash = std::hash<_Key>,
+	   typename _Pred = std::equal_to<_Key>,
+	   typename _Alloc =  std::allocator<_Key> >
+    class unordered_set
+    : public _GLIBCXX_STD_BASE,
+      public _Unordered_profile<unordered_set<_Key, _Hash, _Pred, _Alloc>,
+				true>
+    {
+      typedef _GLIBCXX_STD_BASE _Base;
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::difference_type difference_type;
+      typedef typename _Base::reference       reference;
+      typedef typename _Base::const_reference const_reference;
+
+      typedef typename _Base::iterator iterator;
+      typedef typename _Base::const_iterator const_iterator;
+
+      explicit
+      unordered_set(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+	: _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+        unordered_set(_InputIterator __f, _InputIterator __l,
+		      size_type __n = 0,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+	  : _Base(__f, __l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_set(const unordered_set&) = default;
+
+      unordered_set(const _Base& __x)
+	: _Base(__x)
+      { }
+
+      unordered_set(unordered_set&&) = default;
+
+      explicit
+      unordered_set(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_set(const unordered_set& __uset,
+		    const allocator_type& __a)
+	: _Base(__uset._M_base(), __a)
+      { }
+
+      unordered_set(unordered_set&& __uset,
+		    const allocator_type& __a)
+	: _Base(std::move(__uset._M_base()), __a)
+      { }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n = 0,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_set&
+      operator=(const unordered_set&) = default;
+
+      unordered_set&
+      operator=(unordered_set&&) = default;
+
+      unordered_set&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+
+      void
+      swap(unordered_set& __x)
+      noexcept( noexcept(__x._M_base().swap(__x)) )
+      { _Base::swap(__x); }
+
+      void
+      clear() noexcept
+      {
+        __profcxx_hashtable_destruct(this, _Base::bucket_count(), 
+                                     _Base::size());
+        this->_M_profile_destruct();
+        _Base::clear();
+      }
+
+      template<typename... _Args>
+	std::pair<iterator, bool>
+	emplace(_Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  std::pair<iterator, bool> __res
+	    = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __it, _Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  iterator __res
+	    = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      { 
+        size_type __old_size = _Base::bucket_count();
+        _Base::insert(__l); 
+        _M_profile_resize(__old_size); 
+      }
+
+      std::pair<iterator, bool>
+      insert(const value_type& __obj)
+      {
+        size_type __old_size = _Base::bucket_count();
+        std::pair<iterator, bool> __res = _Base::insert(__obj);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      iterator
+      insert(const_iterator __iter, const value_type& __v)
+      { 
+        size_type __old_size = _Base::bucket_count(); 
+        iterator __res = _Base::insert(__iter, __v);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      std::pair<iterator, bool>
+      insert(value_type&& __obj)
+      {
+        size_type __old_size = _Base::bucket_count();
+        std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      iterator
+      insert(const_iterator __iter, value_type&& __v)
+      { 
+        size_type __old_size = _Base::bucket_count();
+        iterator __res = _Base::insert(__iter, std::move(__v));
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      template<typename _InputIter>
+        void
+        insert(_InputIter __first, _InputIter __last)
+        {
+	  size_type __old_size = _Base::bucket_count(); 
+	  _Base::insert(__first, __last);
+	  _M_profile_resize(__old_size); 
+	}
+
+      void
+      rehash(size_type __n)
+      {
+        size_type __old_size = _Base::bucket_count();
+        _Base::rehash(__n);
+        _M_profile_resize(__old_size); 
+      }
+
+    private:
+      void
+      _M_profile_resize(size_type __old_size)
+      {
+	size_type __new_size = _Base::bucket_count();
+	if (__old_size != __new_size)
+	  __profcxx_hashtable_resize(this, __old_size, __new_size);
+      }
+  };
+
+  template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
+	 unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
+    { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }
+
+  template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+#undef _GLIBCXX_BASE
+#undef _GLIBCXX_STD_BASE
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
+#define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc>
+
+  /** @brief Unordered_multiset wrapper with performance instrumentation.  */
+  template<typename _Value,
+	   typename _Hash = std::hash<_Value>,
+	   typename _Pred = std::equal_to<_Value>,
+	   typename _Alloc =  std::allocator<_Value> >
+    class unordered_multiset
+    : public _GLIBCXX_STD_BASE,
+      public _Unordered_profile<unordered_multiset<_Value,
+						   _Hash, _Pred, _Alloc>,
+				false>
+    {
+      typedef _GLIBCXX_STD_BASE _Base;
+
+      _Base&
+      _M_base() noexcept       { return *this; }
+
+      const _Base&
+      _M_base() const noexcept { return *this; }
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::difference_type difference_type;
+      typedef typename _Base::reference       reference;
+      typedef typename _Base::const_reference const_reference;
+
+      typedef typename _Base::iterator iterator;
+      typedef typename _Base::const_iterator const_iterator;
+
+      explicit
+      unordered_multiset(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+	: _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+        unordered_multiset(_InputIterator __f, _InputIterator __l,
+			   size_type __n = 0,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+	  : _Base(__f, __l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_multiset(const unordered_multiset&) = default;
+
+      unordered_multiset(const _Base& __x)
+	: _Base(__x)
+      { }
+
+      unordered_multiset(unordered_multiset&&) = default;
+
+      explicit
+      unordered_multiset(const allocator_type& __a)
+	: _Base(__a)
+      { }
+
+      unordered_multiset(const unordered_multiset& __umset,
+			 const allocator_type& __a)
+	: _Base(__umset._M_base(), __a)
+      { }
+
+      unordered_multiset(unordered_multiset&& __umset,
+			 const allocator_type& __a)
+	: _Base(std::move(__umset._M_base()), __a)
+      { }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n = 0,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+	: _Base(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_multiset&
+      operator=(const unordered_multiset&) = default;
+
+      unordered_multiset&
+      operator=(unordered_multiset&&) = default;
+
+      unordered_multiset&
+      operator=(initializer_list<value_type> __l)
+      {
+	_M_base() = __l;
+	return *this;
+      }
+
+      void
+      swap(unordered_multiset& __x)
+      noexcept( noexcept(__x._M_base().swap(__x)) )
+      { _Base::swap(__x); }
+
+      void
+      clear() noexcept
+      {
+        __profcxx_hashtable_destruct(this, _Base::bucket_count(), 
+                                     _Base::size());
+        this->_M_profile_destruct();
+        _Base::clear();
+      }
+
+      template<typename... _Args>
+	iterator
+	emplace(_Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  iterator __res = _Base::emplace(std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      template<typename... _Args>
+	iterator
+	emplace_hint(const_iterator __it, _Args&&... __args)
+	{
+	  size_type __old_size = _Base::bucket_count();
+	  iterator __res
+	    = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
+	  _M_profile_resize(__old_size);
+	  return __res;
+	}
+
+      void
+      insert(std::initializer_list<value_type> __l)
+      { 
+        size_type __old_size = _Base::bucket_count();
+        _Base::insert(__l); 
+        _M_profile_resize(__old_size); 
+      }
+
+      iterator
+      insert(const value_type& __obj)
+      {
+        size_type __old_size = _Base::bucket_count();
+        iterator __res = _Base::insert(__obj);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      iterator
+      insert(const_iterator __iter, const value_type& __v)
+      {
+        size_type __old_size = _Base::bucket_count(); 
+        iterator __res = _Base::insert(__iter, __v);
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      iterator
+      insert(value_type&& __obj)
+      {
+	size_type __old_size = _Base::bucket_count();
+        iterator __res = _Base::insert(std::move(__obj));
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      iterator
+      insert(const_iterator __iter, value_type&& __v)
+      {
+        size_type __old_size = _Base::bucket_count(); 
+        iterator __res = _Base::insert(__iter, std::move(__v));
+        _M_profile_resize(__old_size); 
+        return __res;
+      }
+
+      template<typename _InputIter>
+        void
+        insert(_InputIter __first, _InputIter __last)
+        {
+	  size_type __old_size = _Base::bucket_count(); 
+	  _Base::insert(__first, __last);
+	  _M_profile_resize(__old_size); 
+	}
+
+      void
+      rehash(size_type __n)
+      {
+        size_type __old_size = _Base::bucket_count();
+        _Base::rehash(__n);
+        _M_profile_resize(__old_size); 
+      }
+
+    private:
+      void
+      _M_profile_resize(size_type __old_size)
+      {
+	size_type __new_size = _Base::bucket_count();
+        if (__old_size != __new_size)
+          __profcxx_hashtable_resize(this, __old_size, __new_size);
+      }
+   };
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline void
+    swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }
+
+  template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+    inline bool
+    operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	       const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+} // namespace __profile
+} // namespace std
+
+#undef _GLIBCXX_BASE
+#undef _GLIBCXX_STD_BASE
+
+#endif // C++11
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/profile/vector b/gcc-4.9/libstdc++-v3/include/profile/vector
new file mode 100644
index 0000000..5c2c621
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/profile/vector
@@ -0,0 +1,598 @@
+// Profiling vector implementation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/vector
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_VECTOR
+#define _GLIBCXX_PROFILE_VECTOR 1
+
+#include <vector>
+#include <utility>
+#include <profile/base.h>
+#include <profile/iterator_tracker.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  template<typename _Tp,
+	   typename _Allocator = std::allocator<_Tp> >
+    class vector
+    : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>
+    {
+      typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
+
+      typedef typename _Base::iterator _Base_iterator;
+      typedef typename _Base::const_iterator _Base_const_iterator;
+
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator>  _Alloc_traits;
+#endif
+
+    public:
+      typedef typename _Base::reference             reference;
+      typedef typename _Base::const_reference       const_reference;
+
+      typedef __iterator_tracker<_Base_iterator, vector>
+                                                    iterator;
+      typedef __iterator_tracker<_Base_const_iterator, vector>
+				                    const_iterator;
+
+      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::difference_type       difference_type;
+
+      typedef _Tp				    value_type;
+      typedef _Allocator			    allocator_type;
+      typedef typename _Base::pointer               pointer;
+      typedef typename _Base::const_pointer         const_pointer;
+      typedef std::reverse_iterator<iterator>       reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      
+      _Base&
+      _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+
+      const _Base&
+      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+      // 23.2.4.1 construct/copy/destroy:
+
+      vector() _GLIBCXX_NOEXCEPT
+      : _Base()
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+      explicit
+      vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT
+      : _Base(__a)
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+#if __cplusplus >= 201103L
+      explicit
+      vector(size_type __n, const _Allocator& __a = _Allocator())
+      : _Base(__n, __a)
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+      vector(size_type __n, const _Tp& __value,
+	     const _Allocator& __a = _Allocator())
+      :  _Base(__n, __value, __a)
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+#else
+      explicit
+      vector(size_type __n, const _Tp& __value = _Tp(),
+	     const _Allocator& __a = _Allocator())
+      : _Base(__n, __value, __a)
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+#else
+      template<typename _InputIterator>
+#endif
+        vector(_InputIterator __first, _InputIterator __last,
+	       const _Allocator& __a = _Allocator())
+	: _Base(__first, __last, __a)
+        {
+	  __profcxx_vector_construct(this, this->capacity());
+	  __profcxx_vector_construct2(this);
+	}
+
+      vector(const vector& __x)
+      : _Base(__x) 
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+      /// Construction from a release-mode vector
+      vector(const _Base& __x)
+      : _Base(__x) 
+      { 
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+#if __cplusplus >= 201103L
+      vector(vector&& __x) noexcept
+      : _Base(std::move(__x))
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+      vector(const _Base& __x, const _Allocator& __a)
+      : _Base(__x, __a)
+      { 
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+      vector(vector&& __x, const _Allocator& __a)
+      : _Base(std::move(__x), __a)
+      {
+        __profcxx_vector_construct(this, this->capacity());
+        __profcxx_vector_construct2(this);
+      }
+
+      vector(initializer_list<value_type> __l,
+	     const allocator_type& __a = allocator_type())
+      : _Base(__l, __a) { }
+#endif
+
+      ~vector() _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_vector_destruct(this, this->capacity(), this->size());
+        __profcxx_vector_destruct2(this);
+      }
+
+      vector&
+      operator=(const vector& __x)
+      {
+        static_cast<_Base&>(*this) = __x;
+        return *this;
+      }
+
+#if __cplusplus >= 201103L
+      vector&
+      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+	__profcxx_vector_destruct(this, this->capacity(), this->size());
+	__profcxx_vector_destruct2(this);
+	static_cast<_Base&>(*this) = std::move(__x);
+	return *this;
+      }
+
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+	static_cast<_Base&>(*this) = __l;
+	return *this;
+      }
+#endif
+
+      using _Base::assign;
+      using _Base::get_allocator;
+
+
+      // iterators:
+      iterator
+      begin() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::begin(), this); }
+
+      const_iterator
+      begin() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::begin(), this); }
+
+      iterator
+      end() _GLIBCXX_NOEXCEPT
+      { return iterator(_Base::end(), this); }
+
+      const_iterator
+      end() const _GLIBCXX_NOEXCEPT
+      { return const_iterator(_Base::end(), this); }
+
+      reverse_iterator
+      rbegin() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() _GLIBCXX_NOEXCEPT
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const _GLIBCXX_NOEXCEPT
+      { return const_reverse_iterator(begin()); }
+
+#if __cplusplus >= 201103L
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_Base::begin(), this); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(_Base::end(), this); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+#endif
+
+      // 23.2.4.2 capacity:
+      using _Base::size;
+      using _Base::max_size;
+
+#if __cplusplus >= 201103L
+      void
+      resize(size_type __sz)
+      {
+        __profcxx_vector_invalid_operator(this);
+        _M_profile_resize(this, this->capacity(), __sz);
+        _Base::resize(__sz);
+      }
+
+      void
+      resize(size_type __sz, const _Tp& __c)
+      {
+        __profcxx_vector_invalid_operator(this);
+        _M_profile_resize(this, this->capacity(), __sz);
+        _Base::resize(__sz, __c);
+      }
+#else
+      void
+      resize(size_type __sz, _Tp __c = _Tp())
+      {
+        __profcxx_vector_invalid_operator(this);
+        _M_profile_resize(this, this->capacity(), __sz);
+        _Base::resize(__sz, __c);
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      using _Base::shrink_to_fit;
+#endif
+
+      using _Base::empty;
+
+      // element access:
+      reference
+      operator[](size_type __n) _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_vector_invalid_operator(this);
+        return _M_base()[__n];
+      }
+      const_reference
+      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_vector_invalid_operator(this);
+        return _M_base()[__n];
+      }
+
+      using _Base::at;
+
+      reference
+      front() _GLIBCXX_NOEXCEPT
+      { 
+        return _Base::front();
+      }
+
+      const_reference
+      front() const _GLIBCXX_NOEXCEPT
+      {
+	return _Base::front();
+      }
+
+      reference
+      back() _GLIBCXX_NOEXCEPT
+      {
+	return _Base::back();
+      }
+
+      const_reference
+      back() const _GLIBCXX_NOEXCEPT
+      {
+	return _Base::back();
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 464. Suggestion for new member functions in standard containers.
+      using _Base::data;
+
+      // 23.2.4.3 modifiers:
+      void
+      push_back(const _Tp& __x)
+      {
+        size_type __old_size = this->capacity();
+	_Base::push_back(__x);
+        _M_profile_resize(this, __old_size, this->capacity());
+      }
+
+#if __cplusplus >= 201103L
+      void
+      push_back(_Tp&& __x)
+      {
+        size_type __old_size = this->capacity();
+        _Base::push_back(std::move(__x));
+        _M_profile_resize(this, __old_size, this->capacity());
+      }
+
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      insert(const_iterator __position, const _Tp& __x)
+#else
+      insert(iterator __position, const _Tp& __x)
+#endif
+      {
+        __profcxx_vector_insert(this, __position.base() - _Base::begin(),
+                                this->size());
+        size_type __old_size = this->capacity();
+	_Base_iterator __res = _Base::insert(__position.base(), __x);
+        _M_profile_resize(this, __old_size, this->capacity());
+	return iterator(__res, this);
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, _Tp&& __x)
+      {
+        __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
+                                this->size());
+        size_type __old_size = this->capacity();
+	_Base_iterator __res = _Base::insert(__position.base(), __x);
+        _M_profile_resize(this, __old_size, this->capacity());
+	return iterator(__res, this);
+      }
+
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args)
+        {
+	  _Base_iterator __res = _Base::emplace(__position.base(),
+						std::forward<_Args>(__args)...);
+	  return iterator(__res, this);
+	}
+
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      { return this->insert(__position, __l.begin(), __l.end()); }
+#endif
+
+#if __cplusplus >= 201103L
+      void
+      swap(vector&& __x)
+      {
+        _Base::swap(__x);
+      }
+#endif
+
+      void
+      swap(vector& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
+      {
+        _Base::swap(__x);
+      }
+
+#if __cplusplus >= 201103L
+      iterator
+      insert(const_iterator __position, size_type __n, const _Tp& __x)
+      {
+        __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
+                                this->size());
+        size_type __old_size = this->capacity();
+        _Base_iterator __res = _Base::insert(__position, __n, __x);
+        _M_profile_resize(this, __old_size, this->capacity());
+	return iterator(__res, this);
+      }
+#else
+      void
+      insert(iterator __position, size_type __n, const _Tp& __x)
+      {
+        __profcxx_vector_insert(this, __position.base() - _Base::begin(),
+                                this->size());
+        size_type __old_size = this->capacity();
+        _Base::insert(__position, __n, __x);
+        _M_profile_resize(this, __old_size, this->capacity());
+      }
+#endif
+
+#if __cplusplus >= 201103L
+      template<typename _InputIterator,
+	       typename = std::_RequireInputIter<_InputIterator>>
+	iterator
+	insert(const_iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        {
+	  __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
+				  this->size());
+	  size_type __old_size = this->capacity();
+	  _Base_iterator __res = _Base::insert(__position, __first, __last);
+	  _M_profile_resize(this, __old_size, this->capacity());
+	  return iterator(__res, this);
+	}
+#else
+      template<typename _InputIterator>
+	void
+	insert(iterator __position,
+	       _InputIterator __first, _InputIterator __last)
+        {
+	  __profcxx_vector_insert(this, __position.base() - _Base::begin(),
+				  this->size());
+	  size_type __old_size = this->capacity();
+	  _Base::insert(__position, __first, __last);
+	  _M_profile_resize(this, __old_size, this->capacity());
+	}
+#endif
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __position)
+#else
+      erase(iterator __position)	
+#endif
+      {
+	_Base_iterator __res = _Base::erase(__position.base());
+	return iterator(__res, this);
+      }
+
+      iterator
+#if __cplusplus >= 201103L
+      erase(const_iterator __first, const_iterator __last)
+#else
+      erase(iterator __first, iterator __last)
+#endif
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 151. can't currently clear() empty container
+	_Base_iterator __res = _Base::erase(__first.base(), __last.base());
+	return iterator(__res, this);
+      }
+
+      void
+      clear() _GLIBCXX_NOEXCEPT
+      {
+        __profcxx_vector_destruct(this, this->capacity(), this->size());
+        __profcxx_vector_destruct2(this);
+        _Base::clear();
+      }
+
+      inline void _M_profile_find() const 
+      { 
+        __profcxx_vector_find(this, size()); 
+      }
+
+      inline void _M_profile_iterate(int __rewind = 0) const 
+      { 
+        __profcxx_vector_iterate(this); 
+      }
+
+    private:
+      void _M_profile_resize(void* obj, size_type __old_size, 
+                             size_type __new_size)
+      {
+        if (__old_size < __new_size) {
+          __profcxx_vector_resize(this, this->size(), __new_size);
+          __profcxx_vector_resize2(this, this->size(), __new_size);
+        }
+      }
+    };
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __lhs,
+           const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() == __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __lhs,
+           const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() != __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __lhs,
+          const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() < __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __lhs,
+           const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() <= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __lhs,
+           const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() >= __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __lhs,
+          const vector<_Tp, _Alloc>& __rhs)
+    { return __lhs._M_base() > __rhs._M_base(); }
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs)
+    { __lhs.swap(__rhs); }
+#endif
+
+} // namespace __profile
+
+#if __cplusplus >= 201103L
+  // DR 1182.
+  /// std::hash specialization for vector<bool>.
+  template<typename _Alloc>
+    struct hash<__profile::vector<bool, _Alloc>>
+    : public __hash_base<size_t, __profile::vector<bool, _Alloc>>
+    {
+      size_t
+      operator()(const __profile::vector<bool, _Alloc>& __b) const noexcept
+      { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()
+	  (__b._M_base()); }
+    };
+#endif
+
+} // namespace std
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/std/algorithm b/gcc-4.9/libstdc++-v3/include/std/algorithm
new file mode 100644
index 0000000..ee1cd94
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/algorithm
@@ -0,0 +1,68 @@
+// <algorithm> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/algorithm
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_ALGORITHM
+#define _GLIBCXX_ALGORITHM 1
+
+#pragma GCC system_header
+
+#include <utility> // UK-300.
+#include <bits/stl_algobase.h>
+#include <bits/stl_algo.h>
+
+#ifdef _GLIBCXX_PARALLEL
+# include <parallel/algorithm>
+#endif
+
+#endif /* _GLIBCXX_ALGORITHM */
diff --git a/gcc-4.9/libstdc++-v3/include/std/array b/gcc-4.9/libstdc++-v3/include/std/array
new file mode 100644
index 0000000..67680d6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/array
@@ -0,0 +1,337 @@
+// <array> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/array
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_ARRAY
+#define _GLIBCXX_ARRAY 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <stdexcept>
+#include <bits/stl_algobase.h>
+#include <bits/range_access.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __array_traits
+    {
+      typedef _Tp _Type[_Nm];
+
+      static constexpr _Tp&
+      _S_ref(const _Type& __t, std::size_t __n) noexcept
+      { return const_cast<_Tp&>(__t[__n]); }
+    };
+
+ template<typename _Tp>
+   struct __array_traits<_Tp, 0>
+   {
+     struct _Type { };
+
+     static constexpr _Tp&
+     _S_ref(const _Type&, std::size_t) noexcept
+     { return *static_cast<_Tp*>(nullptr); }
+   };
+
+  /**
+   *  @brief A standard container for storing a fixed size sequence of elements.
+   *
+   *  @ingroup sequences
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and a
+   *  <a href="tables.html#67">sequence</a>.
+   *
+   *  Sets support random access iterators.
+   *
+   *  @tparam  Tp  Type of element. Required to be a complete type.
+   *  @tparam  N  Number of elements.
+  */
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp 	    			      value_type;
+      typedef value_type*			      pointer;
+      typedef const value_type*                       const_pointer;
+      typedef value_type&                   	      reference;
+      typedef const value_type&             	      const_reference;
+      typedef value_type*          		      iterator;
+      typedef const value_type*			      const_iterator;
+      typedef std::size_t                    	      size_type;
+      typedef std::ptrdiff_t                   	      difference_type;
+      typedef std::reverse_iterator<iterator>	      reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+
+      // Support for zero-sized arrays mandatory.
+      typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;
+      typename _AT_Type::_Type                         _M_elems;
+
+      // No explicit construct/copy/destroy for aggregate type.
+
+      // DR 776.
+      void
+      fill(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void
+      swap(array& __other)
+      noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+      // Iterators.
+      iterator
+      begin() noexcept
+      { return iterator(data()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(data()); }
+
+      iterator
+      end() noexcept
+      { return iterator(data() + _Nm); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      reverse_iterator 
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator 
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator 
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(data()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      const_reverse_iterator 
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      // Capacity.
+      constexpr size_type 
+      size() const noexcept { return _Nm; }
+
+      constexpr size_type 
+      max_size() const noexcept { return _Nm; }
+
+      constexpr bool 
+      empty() const noexcept { return size() == 0; }
+
+      // Element access.
+      reference
+      operator[](size_type __n) noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      constexpr const_reference
+      operator[](size_type __n) const noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      reference
+      at(size_type __n)
+      {
+	if (__n >= _Nm)
+	  std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
+					    ">= _Nm (which is %zu)"),
+					__n, _Nm);
+	return _AT_Type::_S_ref(_M_elems, __n);
+      }
+
+      constexpr const_reference
+      at(size_type __n) const
+      {
+	// Result of conditional expression must be an lvalue so use
+	// boolean ? lvalue : (throw-expr, lvalue)
+	return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+	  : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
+					       ">= _Nm (which is %zu)"),
+					   __n, _Nm),
+	     _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      reference 
+      front() noexcept
+      { return *begin(); }
+
+      constexpr const_reference 
+      front() const noexcept
+      { return _AT_Type::_S_ref(_M_elems, 0); }
+
+      reference 
+      back() noexcept
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      constexpr const_reference 
+      back() const noexcept
+      { 
+	return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) 
+ 	           : _AT_Type::_S_ref(_M_elems, 0);
+      }
+
+      pointer
+      data() noexcept
+      { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
+
+      const_pointer
+      data() const noexcept
+      { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
+    };
+
+  // Array comparisons.
+  template<typename _Tp, std::size_t _Nm>
+    inline bool 
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    { 
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+					  __b.begin(), __b.end()); 
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+  // Specialized algorithms.
+  template<typename _Tp, std::size_t _Nm>
+    inline void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
+	_S_ref(__arr._M_elems, _Int);
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&&
+    get(array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::move(get<_Int>(__arr));
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&
+    get(const array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::
+	_S_ref(__arr._M_elems, _Int);
+    }
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Tuple interface to class template array.
+
+  /// tuple_size
+  template<typename _Tp> 
+    class tuple_size;
+
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<_GLIBCXX_STD_C::array<_Tp, _Nm>>
+    : public integral_constant<std::size_t, _Nm> { };
+
+  /// tuple_element
+  template<std::size_t _Int, typename _Tp>
+    class tuple_element;
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, _GLIBCXX_STD_C::array<_Tp, _Nm>>
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      typedef _Tp type;
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/array>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/array>
+#endif
+
+#endif // C++11
+
+#endif // _GLIBCXX_ARRAY
diff --git a/gcc-4.9/libstdc++-v3/include/std/atomic b/gcc-4.9/libstdc++-v3/include/std/atomic
new file mode 100644
index 0000000..ece75a4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/atomic
@@ -0,0 +1,1126 @@
+// -*- C++ -*- header.
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/atomic
+ *  This is a Standard C++ Library header.
+ */
+
+// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
+
+#ifndef _GLIBCXX_ATOMIC
+#define _GLIBCXX_ATOMIC 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#endif
+
+#include <bits/atomic_base.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup atomics
+   * @{
+   */
+
+  /// atomic_bool
+  // NB: No operators or fetch-operations for this type.
+  struct atomic_bool
+  {
+  private:
+    __atomic_base<bool>	_M_base;
+
+  public:
+    atomic_bool() noexcept = default;
+    ~atomic_bool() noexcept = default;
+    atomic_bool(const atomic_bool&) = delete;
+    atomic_bool& operator=(const atomic_bool&) = delete;
+    atomic_bool& operator=(const atomic_bool&) volatile = delete;
+
+    constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
+
+    bool
+    operator=(bool __i) noexcept
+    { return _M_base.operator=(__i); }
+
+    bool
+    operator=(bool __i) volatile noexcept
+    { return _M_base.operator=(__i); }
+
+    operator bool() const noexcept
+    { return _M_base.load(); }
+
+    operator bool() const volatile noexcept
+    { return _M_base.load(); }
+
+    bool
+    is_lock_free() const noexcept { return _M_base.is_lock_free(); }
+
+    bool
+    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { _M_base.store(__i, __m); }
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
+    { _M_base.store(__i, __m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    exchange(bool __i,
+	     memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+			  memory_order __m2) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+			  memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+			  memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+		     memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+			    memory_order __m2) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+			    memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+			    memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+		    memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+  };
+
+
+  /**
+   *  @brief Generic atomic type, primary class template.
+   *
+   *  @tparam _Tp  Type to be made atomic, must be trivally copyable.
+   */
+  template<typename _Tp>
+    struct atomic
+    {
+    private:
+      _Tp _M_i;
+
+    public:
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
+
+      operator _Tp() const noexcept
+      { return load(); }
+
+      operator _Tp() const volatile noexcept
+      { return load(); }
+
+      _Tp
+      operator=(_Tp __i) noexcept 
+      { store(__i); return __i; }
+
+      _Tp
+      operator=(_Tp __i) volatile noexcept 
+      { store(__i); return __i; }
+
+      bool
+      is_lock_free() const noexcept
+      { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
+
+      bool
+      is_lock_free() const volatile noexcept
+      { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
+
+      void
+      store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
+      { __atomic_store(&_M_i, &__i, _m); }
+
+      void
+      store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept
+      { __atomic_store(&_M_i, &__i, _m); }
+
+      _Tp
+      load(memory_order _m = memory_order_seq_cst) const noexcept
+      { 
+        _Tp tmp;
+	__atomic_load(&_M_i, &tmp, _m); 
+	return tmp;
+      }
+
+      _Tp
+      load(memory_order _m = memory_order_seq_cst) const volatile noexcept
+      { 
+        _Tp tmp;
+	__atomic_load(&_M_i, &tmp, _m); 
+	return tmp;
+      }
+
+      _Tp
+      exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
+      { 
+        _Tp tmp;
+	__atomic_exchange(&_M_i, &__i, &tmp, _m); 
+	return tmp;
+      }
+
+      _Tp
+      exchange(_Tp __i, 
+	       memory_order _m = memory_order_seq_cst) volatile noexcept
+      { 
+        _Tp tmp;
+	__atomic_exchange(&_M_i, &__i, &tmp, _m); 
+	return tmp;
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 
+			    memory_order __f) noexcept
+      {
+	return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); 
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 
+			    memory_order __f) volatile noexcept
+      {
+	return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); 
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+			    memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+		     memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 
+			      memory_order __f) noexcept
+      {
+	return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); 
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 
+			      memory_order __f) volatile noexcept
+      {
+	return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); 
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+			       memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+		     memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+    };
+
+
+  /// Partial specialization for pointer types.
+  template<typename _Tp>
+    struct atomic<_Tp*>
+    {
+      typedef _Tp* 			__pointer_type;
+      typedef __atomic_base<_Tp*>	__base_type;
+      __base_type			_M_b;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
+
+      operator __pointer_type() const noexcept
+      { return __pointer_type(_M_b); }
+
+      operator __pointer_type() const volatile noexcept
+      { return __pointer_type(_M_b); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator++(int) noexcept
+      { return _M_b++; }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      { return _M_b++; }
+
+      __pointer_type
+      operator--(int) noexcept
+      { return _M_b--; }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      { return _M_b--; }
+
+      __pointer_type
+      operator++() noexcept
+      { return ++_M_b; }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return ++_M_b; }
+
+      __pointer_type
+      operator--() noexcept
+      { return --_M_b; }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return --_M_b; }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return _M_b.operator+=(__d); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return _M_b.operator+=(__d); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return _M_b.operator-=(__d); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return _M_b.operator-=(__d); }
+
+      bool
+      is_lock_free() const noexcept
+      { return _M_b.is_lock_free(); }
+
+      bool
+      is_lock_free() const volatile noexcept
+      { return _M_b.is_lock_free(); }
+
+      void
+      store(__pointer_type __p,
+	    memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.store(__p, __m); }
+
+      void
+      store(__pointer_type __p,
+	    memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.store(__p, __m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+	       memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+	       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+			    memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+			    memory_order __m1,
+			    memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+			    memory_order __m = memory_order_seq_cst) noexcept
+      {
+	return compare_exchange_weak(__p1, __p2, __m,
+				     __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+		    memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+	return compare_exchange_weak(__p1, __p2, __m,
+				     __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+			      memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+			      memory_order __m1,
+			      memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+			      memory_order __m = memory_order_seq_cst) noexcept
+      {
+	return _M_b.compare_exchange_strong(__p1, __p2, __m,
+					    __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+		    memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+	return _M_b.compare_exchange_strong(__p1, __p2, __m,
+					    __cmpexch_failure_order(__m));
+      }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.fetch_add(__d, __m); }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.fetch_add(__d, __m); }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.fetch_sub(__d, __m); }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.fetch_sub(__d, __m); }
+    };
+
+
+  /// Explicit specialization for bool.
+  template<>
+    struct atomic<bool> : public atomic_bool
+    {
+      typedef bool 			__integral_type;
+      typedef atomic_bool 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for char.
+  template<>
+    struct atomic<char> : public atomic_char
+    {
+      typedef char 			__integral_type;
+      typedef atomic_char 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for signed char.
+  template<>
+    struct atomic<signed char> : public atomic_schar
+    {
+      typedef signed char 		__integral_type;
+      typedef atomic_schar 		__base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for unsigned char.
+  template<>
+    struct atomic<unsigned char> : public atomic_uchar
+    {
+      typedef unsigned char 		__integral_type;
+      typedef atomic_uchar 		__base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for short.
+  template<>
+    struct atomic<short> : public atomic_short
+    {
+      typedef short 			__integral_type;
+      typedef atomic_short 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for unsigned short.
+  template<>
+    struct atomic<unsigned short> : public atomic_ushort
+    {
+      typedef unsigned short 	      	__integral_type;
+      typedef atomic_ushort 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for int.
+  template<>
+    struct atomic<int> : atomic_int
+    {
+      typedef int 			__integral_type;
+      typedef atomic_int 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for unsigned int.
+  template<>
+    struct atomic<unsigned int> : public atomic_uint
+    {
+      typedef unsigned int		__integral_type;
+      typedef atomic_uint 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for long.
+  template<>
+    struct atomic<long> : public atomic_long
+    {
+      typedef long 			__integral_type;
+      typedef atomic_long 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for unsigned long.
+  template<>
+    struct atomic<unsigned long> : public atomic_ulong
+    {
+      typedef unsigned long 		__integral_type;
+      typedef atomic_ulong 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for long long.
+  template<>
+    struct atomic<long long> : public atomic_llong
+    {
+      typedef long long 		__integral_type;
+      typedef atomic_llong 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for unsigned long long.
+  template<>
+    struct atomic<unsigned long long> : public atomic_ullong
+    {
+      typedef unsigned long long       	__integral_type;
+      typedef atomic_ullong 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for wchar_t.
+  template<>
+    struct atomic<wchar_t> : public atomic_wchar_t
+    {
+      typedef wchar_t 			__integral_type;
+      typedef atomic_wchar_t 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for char16_t.
+  template<>
+    struct atomic<char16_t> : public atomic_char16_t
+    {
+      typedef char16_t 			__integral_type;
+      typedef atomic_char16_t 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+  /// Explicit specialization for char32_t.
+  template<>
+    struct atomic<char32_t> : public atomic_char32_t
+    {
+      typedef char32_t 			__integral_type;
+      typedef atomic_char32_t 		__base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  // Function definitions, atomic_flag operations.
+  inline bool
+  atomic_flag_test_and_set_explicit(atomic_flag* __a,
+				    memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline bool
+  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
+				    memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(volatile atomic_flag* __a,
+			     memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline bool
+  atomic_flag_test_and_set(atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline bool
+  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(volatile atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+
+  // Function templates generally applicable to atomic types.
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline void
+    atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
+
+  template<typename _ITp>
+    inline void
+    atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
+			  memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
+			  memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const volatile atomic<_ITp>* __a,
+			 memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
+			     memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
+			     memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
+					  _ITp* __i1, _ITp __i2,
+					  memory_order __m1,
+					  memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
+					  _ITp* __i1, _ITp __i2,
+					  memory_order __m1,
+					  memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
+					    _ITp* __i1, _ITp __i2,
+					    memory_order __m1,
+					    memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
+					    _ITp* __i1, _ITp __i2,
+					    memory_order __m1,
+					    memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+
+  template<typename _ITp>
+    inline void
+    atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const volatile atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(atomic<_ITp>* __a,
+				 _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+						   memory_order_seq_cst,
+						   memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
+				 _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+						   memory_order_seq_cst,
+						   memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(atomic<_ITp>* __a,
+				   _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+						     memory_order_seq_cst,
+						     memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
+				   _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+						     memory_order_seq_cst,
+						     memory_order_seq_cst);
+    }
+
+  // Function templates for atomic_integral operations only, using
+  // __atomic_base. Template argument should be constricted to
+  // intergral types as specified in the standard, excluding address
+  // types.
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+			     memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+			     memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+			      memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+
+
+  // Partial specializations for pointers.
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
+			      memory_order __m) noexcept
+    { return __a->fetch_add(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
+			      memory_order __m) noexcept
+    { return __a->fetch_add(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_add(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_add(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
+			      ptrdiff_t __d, memory_order __m) noexcept
+    { return __a->fetch_sub(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
+			      memory_order __m) noexcept
+    { return __a->fetch_sub(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_sub(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_sub(__d); }
+  // @} group atomics
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/std/bitset b/gcc-4.9/libstdc++-v3/include/std/bitset
new file mode 100644
index 0000000..d9d4f4d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/bitset
@@ -0,0 +1,1595 @@
+// <bitset> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/bitset
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_BITSET
+#define _GLIBCXX_BITSET 1
+
+#pragma GCC system_header
+
+#include <string>
+#include <bits/functexcept.h>   // For invalid_argument, out_of_range,
+                                // overflow_error
+#include <iosfwd>
+#include <bits/cxxabi_forced.h>
+
+#define _GLIBCXX_BITSET_BITS_PER_WORD  (__CHAR_BIT__ * __SIZEOF_LONG__)
+#define _GLIBCXX_BITSET_WORDS(__n) \
+  ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \
+   ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1))
+
+#define _GLIBCXX_BITSET_BITS_PER_ULL (__CHAR_BIT__ * __SIZEOF_LONG_LONG__)
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+
+  /**
+   *  Base class, general case.  It is a class invariant that _Nw will be
+   *  nonnegative.
+   *
+   *  See documentation for bitset.
+  */
+  template<size_t _Nw>
+    struct _Base_bitset
+    {
+      typedef unsigned long _WordT;
+
+      /// 0 is the least significant word.
+      _WordT 		_M_w[_Nw];
+
+      _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT
+      : _M_w() { }
+
+#if __cplusplus >= 201103L
+      constexpr _Base_bitset(unsigned long long __val) noexcept
+      : _M_w{ _WordT(__val)
+#if __SIZEOF_LONG_LONG__ > __SIZEOF_LONG__
+	       , _WordT(__val >> _GLIBCXX_BITSET_BITS_PER_WORD)
+#endif
+       } { }
+#else
+      _Base_bitset(unsigned long __val)
+      : _M_w()
+      { _M_w[0] = __val; }
+#endif
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
+
+      static _GLIBCXX_CONSTEXPR _WordT
+      _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+
+      _WordT&
+      _M_getword(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return _M_w[_S_whichword(__pos)]; }
+
+      _GLIBCXX_CONSTEXPR _WordT
+      _M_getword(size_t __pos) const _GLIBCXX_NOEXCEPT
+      { return _M_w[_S_whichword(__pos)]; }
+
+#if __cplusplus >= 201103L
+      const _WordT*
+      _M_getdata() const noexcept
+      { return _M_w; }
+#endif
+
+      _WordT&
+      _M_hiword() _GLIBCXX_NOEXCEPT
+      { return _M_w[_Nw - 1]; }
+
+      _GLIBCXX_CONSTEXPR _WordT
+      _M_hiword() const _GLIBCXX_NOEXCEPT
+      { return _M_w[_Nw - 1]; }
+
+      void
+      _M_do_and(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT
+      {
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  _M_w[__i] &= __x._M_w[__i];
+      }
+
+      void
+      _M_do_or(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT
+      {
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  _M_w[__i] |= __x._M_w[__i];
+      }
+
+      void
+      _M_do_xor(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT
+      {
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  _M_w[__i] ^= __x._M_w[__i];
+      }
+
+      void
+      _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT;
+
+      void
+      _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT;
+
+      void
+      _M_do_flip() _GLIBCXX_NOEXCEPT
+      {
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  _M_w[__i] = ~_M_w[__i];
+      }
+
+      void
+      _M_do_set() _GLIBCXX_NOEXCEPT
+      {
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  _M_w[__i] = ~static_cast<_WordT>(0);
+      }
+
+      void
+      _M_do_reset() _GLIBCXX_NOEXCEPT
+      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }
+
+      bool
+      _M_is_equal(const _Base_bitset<_Nw>& __x) const _GLIBCXX_NOEXCEPT
+      {
+	for (size_t __i = 0; __i < _Nw; ++__i)
+	  if (_M_w[__i] != __x._M_w[__i])
+	    return false;
+	return true;
+      }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const _GLIBCXX_NOEXCEPT
+        {
+	  for (size_t __i = 0; __i < _Nw - 1; __i++)
+	    if (_M_w[__i] != ~static_cast<_WordT>(0))
+	      return false;
+	  return _M_hiword() == (~static_cast<_WordT>(0)
+				 >> (_Nw * _GLIBCXX_BITSET_BITS_PER_WORD
+				     - _Nb));
+	}
+
+      bool
+      _M_is_any() const _GLIBCXX_NOEXCEPT
+      {
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  if (_M_w[__i] != static_cast<_WordT>(0))
+	    return true;
+	return false;
+      }
+
+      size_t
+      _M_do_count() const _GLIBCXX_NOEXCEPT
+      {
+	size_t __result = 0;
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  __result += __builtin_popcountl(_M_w[__i]);
+	return __result;
+      }
+
+      unsigned long
+      _M_do_to_ulong() const;
+
+#if __cplusplus >= 201103L
+      unsigned long long
+      _M_do_to_ullong() const;
+#endif
+
+      // find first "on" bit
+      size_t
+      _M_do_find_first(size_t) const _GLIBCXX_NOEXCEPT;
+
+      // find the next "on" bit that follows "prev"
+      size_t
+      _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT;
+    };
+
+  // Definitions of non-inline functions from _Base_bitset.
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT
+    {
+      if (__builtin_expect(__shift != 0, 1))
+	{
+	  const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
+	  const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;
+
+	  if (__offset == 0)
+	    for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
+	      _M_w[__n] = _M_w[__n - __wshift];
+	  else
+	    {
+	      const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD 
+					   - __offset);
+	      for (size_t __n = _Nw - 1; __n > __wshift; --__n)
+		_M_w[__n] = ((_M_w[__n - __wshift] << __offset)
+			     | (_M_w[__n - __wshift - 1] >> __sub_offset));
+	      _M_w[__wshift] = _M_w[0] << __offset;
+	    }
+
+	  std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
+	}
+    }
+
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT
+    {
+      if (__builtin_expect(__shift != 0, 1))
+	{
+	  const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
+	  const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;
+	  const size_t __limit = _Nw - __wshift - 1;
+
+	  if (__offset == 0)
+	    for (size_t __n = 0; __n <= __limit; ++__n)
+	      _M_w[__n] = _M_w[__n + __wshift];
+	  else
+	    {
+	      const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD
+					   - __offset);
+	      for (size_t __n = 0; __n < __limit; ++__n)
+		_M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
+			     | (_M_w[__n + __wshift + 1] << __sub_offset));
+	      _M_w[__limit] = _M_w[_Nw-1] >> __offset;
+	    }
+	  
+	  std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
+	}
+    }
+
+  template<size_t _Nw>
+    unsigned long
+    _Base_bitset<_Nw>::_M_do_to_ulong() const
+    {
+      for (size_t __i = 1; __i < _Nw; ++__i)
+	if (_M_w[__i])
+	  __throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong"));
+      return _M_w[0];
+    }
+
+#if __cplusplus >= 201103L
+  template<size_t _Nw>
+    unsigned long long
+    _Base_bitset<_Nw>::_M_do_to_ullong() const
+    {
+      const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long);
+      for (size_t __i = 1 + __dw; __i < _Nw; ++__i)
+	if (_M_w[__i])
+	  __throw_overflow_error(__N("_Base_bitset::_M_do_to_ullong"));
+
+      if (__dw)
+	return _M_w[0] + (static_cast<unsigned long long>(_M_w[1])
+			  << _GLIBCXX_BITSET_BITS_PER_WORD);
+      return _M_w[0];
+    }
+#endif
+
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::
+    _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT
+    {
+      for (size_t __i = 0; __i < _Nw; __i++)
+	{
+	  _WordT __thisword = _M_w[__i];
+	  if (__thisword != static_cast<_WordT>(0))
+	    return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
+		    + __builtin_ctzl(__thisword));
+	}
+      // not found, so return an indication of failure.
+      return __not_found;
+    }
+
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::
+    _M_do_find_next(size_t __prev, size_t __not_found) const _GLIBCXX_NOEXCEPT
+    {
+      // make bound inclusive
+      ++__prev;
+
+      // check out of bounds
+      if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD)
+	return __not_found;
+
+      // search first word
+      size_t __i = _S_whichword(__prev);
+      _WordT __thisword = _M_w[__i];
+
+      // mask off bits below bound
+      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
+
+      if (__thisword != static_cast<_WordT>(0))
+	return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
+		+ __builtin_ctzl(__thisword));
+
+      // check subsequent words
+      __i++;
+      for (; __i < _Nw; __i++)
+	{
+	  __thisword = _M_w[__i];
+	  if (__thisword != static_cast<_WordT>(0))
+	    return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
+		    + __builtin_ctzl(__thisword));
+	}
+      // not found, so return an indication of failure.
+      return __not_found;
+    } // end _M_do_find_next
+
+  /**
+   *  Base class, specialization for a single word.
+   *
+   *  See documentation for bitset.
+  */
+  template<>
+    struct _Base_bitset<1>
+    {
+      typedef unsigned long _WordT;
+      _WordT _M_w;
+
+      _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT
+      : _M_w(0)
+      { }
+
+#if __cplusplus >= 201103L
+      constexpr _Base_bitset(unsigned long long __val) noexcept
+#else
+      _Base_bitset(unsigned long __val)
+#endif
+      : _M_w(__val)
+      { }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT
+      {  return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
+
+      static _GLIBCXX_CONSTEXPR _WordT
+      _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+
+      _WordT&
+      _M_getword(size_t) _GLIBCXX_NOEXCEPT
+      { return _M_w; }
+
+      _GLIBCXX_CONSTEXPR _WordT
+      _M_getword(size_t) const _GLIBCXX_NOEXCEPT
+      { return _M_w; }
+
+#if __cplusplus >= 201103L
+      const _WordT*
+      _M_getdata() const noexcept
+      { return &_M_w; }
+#endif
+
+      _WordT&
+      _M_hiword() _GLIBCXX_NOEXCEPT
+      { return _M_w; }
+
+      _GLIBCXX_CONSTEXPR _WordT
+      _M_hiword() const _GLIBCXX_NOEXCEPT
+      { return _M_w; }
+
+      void
+      _M_do_and(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT
+      { _M_w &= __x._M_w; }
+
+      void
+      _M_do_or(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT
+      { _M_w |= __x._M_w; }
+
+      void
+      _M_do_xor(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT
+      { _M_w ^= __x._M_w; }
+
+      void
+      _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT
+      { _M_w <<= __shift; }
+
+      void
+      _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT
+      { _M_w >>= __shift; }
+
+      void
+      _M_do_flip() _GLIBCXX_NOEXCEPT
+      { _M_w = ~_M_w; }
+
+      void
+      _M_do_set() _GLIBCXX_NOEXCEPT
+      { _M_w = ~static_cast<_WordT>(0); }
+
+      void
+      _M_do_reset() _GLIBCXX_NOEXCEPT
+      { _M_w = 0; }
+
+      bool
+      _M_is_equal(const _Base_bitset<1>& __x) const _GLIBCXX_NOEXCEPT
+      { return _M_w == __x._M_w; }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const _GLIBCXX_NOEXCEPT
+        { return _M_w == (~static_cast<_WordT>(0)
+			  >> (_GLIBCXX_BITSET_BITS_PER_WORD - _Nb)); }
+
+      bool
+      _M_is_any() const _GLIBCXX_NOEXCEPT
+      { return _M_w != 0; }
+
+      size_t
+      _M_do_count() const _GLIBCXX_NOEXCEPT
+      { return __builtin_popcountl(_M_w); }
+
+      unsigned long
+      _M_do_to_ulong() const _GLIBCXX_NOEXCEPT
+      { return _M_w; }
+
+#if __cplusplus >= 201103L
+      unsigned long long
+      _M_do_to_ullong() const noexcept
+      { return _M_w; }
+#endif
+
+      size_t
+      _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT
+      {
+        if (_M_w != 0)
+          return __builtin_ctzl(_M_w);
+        else
+          return __not_found;
+      }
+
+      // find the next "on" bit that follows "prev"
+      size_t
+      _M_do_find_next(size_t __prev, size_t __not_found) const
+	_GLIBCXX_NOEXCEPT
+      {
+	++__prev;
+	if (__prev >= ((size_t) _GLIBCXX_BITSET_BITS_PER_WORD))
+	  return __not_found;
+
+	_WordT __x = _M_w >> __prev;
+	if (__x != 0)
+	  return __builtin_ctzl(__x) + __prev;
+	else
+	  return __not_found;
+      }
+    };
+
+  /**
+   *  Base class, specialization for no storage (zero-length %bitset).
+   *
+   *  See documentation for bitset.
+  */
+  template<>
+    struct _Base_bitset<0>
+    {
+      typedef unsigned long _WordT;
+
+      _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT
+      { }
+
+#if __cplusplus >= 201103L
+      constexpr _Base_bitset(unsigned long long) noexcept
+#else
+      _Base_bitset(unsigned long)
+#endif
+      { }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
+
+      static _GLIBCXX_CONSTEXPR size_t
+      _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT
+      {  return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
+
+      static _GLIBCXX_CONSTEXPR _WordT
+      _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+
+      // This would normally give access to the data.  The bounds-checking
+      // in the bitset class will prevent the user from getting this far,
+      // but (1) it must still return an lvalue to compile, and (2) the
+      // user might call _Unchecked_set directly, in which case this /needs/
+      // to fail.  Let's not penalize zero-length users unless they actually
+      // make an unchecked call; all the memory ugliness is therefore
+      // localized to this single should-never-get-this-far function.
+      _WordT&
+      _M_getword(size_t) _GLIBCXX_NOEXCEPT
+      {
+	__throw_out_of_range(__N("_Base_bitset::_M_getword")); 
+	return *new _WordT;
+      }
+
+      _GLIBCXX_CONSTEXPR _WordT
+      _M_getword(size_t __pos) const _GLIBCXX_NOEXCEPT
+      { return 0; }
+
+      _GLIBCXX_CONSTEXPR _WordT
+      _M_hiword() const _GLIBCXX_NOEXCEPT
+      { return 0; }
+
+      void
+      _M_do_and(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT
+      { }
+
+      void
+      _M_do_or(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT
+      { }
+
+      void
+      _M_do_xor(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT
+      { }
+
+      void
+      _M_do_left_shift(size_t) _GLIBCXX_NOEXCEPT
+      { }
+
+      void
+      _M_do_right_shift(size_t) _GLIBCXX_NOEXCEPT
+      { }
+
+      void
+      _M_do_flip() _GLIBCXX_NOEXCEPT
+      { }
+
+      void
+      _M_do_set() _GLIBCXX_NOEXCEPT
+      { }
+
+      void
+      _M_do_reset() _GLIBCXX_NOEXCEPT
+      { }
+
+      // Are all empty bitsets equal to each other?  Are they equal to
+      // themselves?  How to compare a thing which has no state?  What is
+      // the sound of one zero-length bitset clapping?
+      bool
+      _M_is_equal(const _Base_bitset<0>&) const _GLIBCXX_NOEXCEPT
+      { return true; }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const _GLIBCXX_NOEXCEPT
+        { return true; }
+
+      bool
+      _M_is_any() const _GLIBCXX_NOEXCEPT
+      { return false; }
+
+      size_t
+      _M_do_count() const _GLIBCXX_NOEXCEPT
+      { return 0; }
+
+      unsigned long
+      _M_do_to_ulong() const _GLIBCXX_NOEXCEPT
+      { return 0; }
+
+#if __cplusplus >= 201103L
+      unsigned long long
+      _M_do_to_ullong() const noexcept
+      { return 0; }
+#endif
+
+      // Normally "not found" is the size, but that could also be
+      // misinterpreted as an index in this corner case.  Oh well.
+      size_t
+      _M_do_find_first(size_t) const _GLIBCXX_NOEXCEPT
+      { return 0; }
+
+      size_t
+      _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT
+      { return 0; }
+    };
+
+
+  // Helper class to zero out the unused high-order bits in the highest word.
+  template<size_t _Extrabits>
+    struct _Sanitize
+    {
+      typedef unsigned long _WordT;
+
+      static void
+      _S_do_sanitize(_WordT& __val) _GLIBCXX_NOEXCEPT
+      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
+    };
+
+  template<>
+    struct _Sanitize<0>
+    {
+      typedef unsigned long _WordT;
+
+      static void
+      _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { } 
+    };
+
+#if __cplusplus >= 201103L
+  template<size_t _Nb, bool = _Nb < _GLIBCXX_BITSET_BITS_PER_ULL>
+    struct _Sanitize_val
+    {
+      static constexpr unsigned long long
+      _S_do_sanitize_val(unsigned long long __val)
+      { return __val; }
+    };
+
+  template<size_t _Nb>
+    struct _Sanitize_val<_Nb, true>
+    {
+      static constexpr unsigned long long
+      _S_do_sanitize_val(unsigned long long __val)
+      { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); }
+    };
+#endif
+
+  /**
+   *  The %bitset class represents a @e fixed-size sequence of bits.
+   *
+   *  @ingroup containers
+   *
+   *  (Note that %bitset does @e not meet the formal requirements of a
+   *  <a href="tables.html#65">container</a>.  Mainly, it lacks iterators.)
+   *
+   *  The template argument, @a Nb, may be any non-negative number,
+   *  specifying the number of bits (e.g., "0", "12", "1024*1024").
+   *
+   *  In the general unoptimized case, storage is allocated in word-sized
+   *  blocks.  Let B be the number of bits in a word, then (Nb+(B-1))/B
+   *  words will be used for storage.  B - Nb%B bits are unused.  (They are
+   *  the high-order bits in the highest word.)  It is a class invariant
+   *  that those unused bits are always zero.
+   *
+   *  If you think of %bitset as <em>a simple array of bits</em>, be
+   *  aware that your mental picture is reversed: a %bitset behaves
+   *  the same way as bits in integers do, with the bit at index 0 in
+   *  the <em>least significant / right-hand</em> position, and the bit at
+   *  index Nb-1 in the <em>most significant / left-hand</em> position.
+   *  Thus, unlike other containers, a %bitset's index <em>counts from
+   *  right to left</em>, to put it very loosely.
+   *
+   *  This behavior is preserved when translating to and from strings.  For
+   *  example, the first line of the following program probably prints
+   *  <em>b(&apos;a&apos;) is 0001100001</em> on a modern ASCII system.
+   *
+   *  @code
+   *     #include <bitset>
+   *     #include <iostream>
+   *     #include <sstream>
+   *
+   *     using namespace std;
+   *
+   *     int main()
+   *     {
+   *         long         a = 'a';
+   *         bitset<10>   b(a);
+   *
+   *         cout << "b('a') is " << b << endl;
+   *
+   *         ostringstream s;
+   *         s << b;
+   *         string  str = s.str();
+   *         cout << "index 3 in the string is " << str[3] << " but\n"
+   *              << "index 3 in the bitset is " << b[3] << endl;
+   *     }
+   *  @endcode
+   *
+   *  Also see:
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch33s02.html
+   *  for a description of extensions.
+   *
+   *  Most of the actual code isn't contained in %bitset<> itself, but in the
+   *  base class _Base_bitset.  The base class works with whole words, not with
+   *  individual bits.  This allows us to specialize _Base_bitset for the
+   *  important special case where the %bitset is only a single word.
+   *
+   *  Extra confusion can result due to the fact that the storage for
+   *  _Base_bitset @e is a regular array, and is indexed as such.  This is
+   *  carefully encapsulated.
+  */
+  template<size_t _Nb>
+    class bitset
+    : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)>
+    {
+    private:
+      typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base;
+      typedef unsigned long _WordT;
+
+      template<class _CharT, class _Traits, class _Alloc>
+      void
+      _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+				size_t __position) const
+      {
+	if (__position > __s.size())
+	  __throw_out_of_range_fmt(__N("bitset::bitset: __position "
+				       "(which is %zu) > __s.size() "
+				       "(which is %zu)"),
+				   __position, __s.size());
+      }
+
+      void _M_check(size_t __position, const char *__s) const
+      {
+	if (__position >= _Nb)
+	  __throw_out_of_range_fmt(__N("%s: __position (which is %zu) "
+				       ">= _Nb (which is %zu)"),
+				   __s, __position, _Nb);
+      }
+
+      void
+      _M_do_sanitize() _GLIBCXX_NOEXCEPT
+      { 
+	typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type;
+	__sanitize_type::_S_do_sanitize(this->_M_hiword());
+      }
+
+#if __cplusplus >= 201103L
+      template<typename> friend struct hash;
+#endif
+
+    public:
+      /**
+       *  This encapsulates the concept of a single bit.  An instance of this
+       *  class is a proxy for an actual bit; this way the individual bit
+       *  operations are done as faster word-size bitwise instructions.
+       *
+       *  Most users will never need to use this class directly; conversions
+       *  to and from bool are automatic and should be transparent.  Overloaded
+       *  operators help to preserve the illusion.
+       *
+       *  (On a typical system, this <em>bit %reference</em> is 64
+       *  times the size of an actual bit.  Ha.)
+       */
+      class reference
+      {
+	friend class bitset;
+
+	_WordT*	_M_wp;
+	size_t 	_M_bpos;
+	
+	// left undefined
+	reference();
+	
+      public:
+	reference(bitset& __b, size_t __pos) _GLIBCXX_NOEXCEPT
+	{
+	  _M_wp = &__b._M_getword(__pos);
+	  _M_bpos = _Base::_S_whichbit(__pos);
+	}
+
+	~reference() _GLIBCXX_NOEXCEPT
+	{ }
+
+	// For b[i] = __x;
+	reference&
+	operator=(bool __x) _GLIBCXX_NOEXCEPT
+	{
+	  if (__x)
+	    *_M_wp |= _Base::_S_maskbit(_M_bpos);
+	  else
+	    *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+	  return *this;
+	}
+
+	// For b[i] = b[__j];
+	reference&
+	operator=(const reference& __j) _GLIBCXX_NOEXCEPT
+	{
+	  if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
+	    *_M_wp |= _Base::_S_maskbit(_M_bpos);
+	  else
+	    *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+	  return *this;
+	}
+
+	// Flips the bit
+	bool
+	operator~() const _GLIBCXX_NOEXCEPT
+	{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
+
+	// For __x = b[i];
+	operator bool() const _GLIBCXX_NOEXCEPT
+	{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
+
+	// For b[i].flip();
+	reference&
+	flip() _GLIBCXX_NOEXCEPT
+	{
+	  *_M_wp ^= _Base::_S_maskbit(_M_bpos);
+	  return *this;
+	}
+      };
+      friend class reference;
+
+      // 23.3.5.1 constructors:
+      /// All bits set to zero.
+      _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
+      { }
+
+      /// Initial bits bitwise-copied from a single word (others set to zero).
+#if __cplusplus >= 201103L
+      constexpr bitset(unsigned long long __val) noexcept
+      : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }
+#else
+      bitset(unsigned long __val)
+      : _Base(__val)
+      { _M_do_sanitize(); }
+#endif
+
+      /**
+       *  Use a subset of a string.
+       *  @param  __s  A string of @a 0 and @a 1 characters.
+       *  @param  __position  Index of the first character in @a __s to use;
+       *                    defaults to zero.
+       *  @throw  std::out_of_range  If @a pos is bigger the size of @a __s.
+       *  @throw  std::invalid_argument  If a character appears in the string
+       *                                 which is neither @a 0 nor @a 1.
+       */
+      template<class _CharT, class _Traits, class _Alloc>
+	explicit
+	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+	       size_t __position = 0)
+	: _Base()
+	{
+	  _M_check_initial_position(__s, __position);
+	  _M_copy_from_string(__s, __position,
+			      std::basic_string<_CharT, _Traits, _Alloc>::npos,
+			      _CharT('0'), _CharT('1'));
+	}
+
+      /**
+       *  Use a subset of a string.
+       *  @param  __s  A string of @a 0 and @a 1 characters.
+       *  @param  __position  Index of the first character in @a __s to use.
+       *  @param  __n    The number of characters to copy.
+       *  @throw std::out_of_range If @a __position is bigger the size
+       *  of @a __s.
+       *  @throw  std::invalid_argument  If a character appears in the string
+       *                                 which is neither @a 0 nor @a 1.
+       */
+      template<class _CharT, class _Traits, class _Alloc>
+	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+	       size_t __position, size_t __n)
+	: _Base()
+	{
+	  _M_check_initial_position(__s, __position);
+	  _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1'));
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 396. what are characters zero and one.
+      template<class _CharT, class _Traits, class _Alloc>
+	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+	       size_t __position, size_t __n,
+	       _CharT __zero, _CharT __one = _CharT('1'))
+	: _Base()
+	{
+	  _M_check_initial_position(__s, __position);
+	  _M_copy_from_string(__s, __position, __n, __zero, __one);
+	}
+
+#if __cplusplus >= 201103L
+      /**
+       *  Construct from a character %array.
+       *  @param  __str  An %array of characters @a zero and @a one.
+       *  @param  __n    The number of characters to use.
+       *  @param  __zero The character corresponding to the value 0.
+       *  @param  __one  The character corresponding to the value 1.
+       *  @throw  std::invalid_argument If a character appears in the string
+       *                                which is neither @a __zero nor @a __one.
+       */
+      template<typename _CharT>
+        explicit
+        bitset(const _CharT* __str,
+	       typename std::basic_string<_CharT>::size_type __n
+	       = std::basic_string<_CharT>::npos,
+	       _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
+        : _Base()
+        {
+	  if (!__str)
+	    __throw_logic_error(__N("bitset::bitset(const _CharT*, ...)"));
+
+	  if (__n == std::basic_string<_CharT>::npos)
+	    __n = std::char_traits<_CharT>::length(__str);
+	  _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
+							     __n, __zero,
+							     __one);
+	}
+#endif
+
+      // 23.3.5.2 bitset operations:
+      //@{
+      /**
+       *  Operations on bitsets.
+       *  @param  __rhs  A same-sized bitset.
+       *
+       *  These should be self-explanatory.
+       */
+      bitset<_Nb>&
+      operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	this->_M_do_and(__rhs);
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	this->_M_do_or(__rhs);
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
+      {
+	this->_M_do_xor(__rhs);
+	return *this;
+      }
+      //@}
+      
+      //@{
+      /**
+       *  Operations on bitsets.
+       *  @param  __position  The number of places to shift.
+       *
+       *  These should be self-explanatory.
+       */
+      bitset<_Nb>&
+      operator<<=(size_t __position) _GLIBCXX_NOEXCEPT
+      {
+	if (__builtin_expect(__position < _Nb, 1))
+	  {
+	    this->_M_do_left_shift(__position);
+	    this->_M_do_sanitize();
+	  }
+	else
+	  this->_M_do_reset();
+	return *this;
+      }
+
+      bitset<_Nb>&
+      operator>>=(size_t __position) _GLIBCXX_NOEXCEPT
+      {
+	if (__builtin_expect(__position < _Nb, 1))
+	  {
+	    this->_M_do_right_shift(__position);
+	    this->_M_do_sanitize();
+	  }
+	else
+	  this->_M_do_reset();
+	return *this;
+      }
+      //@}
+      
+      //@{
+      /**
+       *  These versions of single-bit set, reset, flip, and test are
+       *  extensions from the SGI version.  They do no range checking.
+       *  @ingroup SGIextensions
+       */
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos) _GLIBCXX_NOEXCEPT
+      {
+	this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos, int __val) _GLIBCXX_NOEXCEPT
+      {
+	if (__val)
+	  this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+	else
+	  this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_reset(size_t __pos) _GLIBCXX_NOEXCEPT
+      {
+	this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_flip(size_t __pos) _GLIBCXX_NOEXCEPT
+      {
+	this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      _GLIBCXX_CONSTEXPR bool
+      _Unchecked_test(size_t __pos) const _GLIBCXX_NOEXCEPT
+      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
+		!= static_cast<_WordT>(0)); }
+      //@}
+      
+      // Set, reset, and flip.
+      /**
+       *  @brief Sets every bit to true.
+       */
+      bitset<_Nb>&
+      set() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_do_set();
+	this->_M_do_sanitize();
+	return *this;
+      }
+
+      /**
+       *  @brief Sets a given bit to a particular value.
+       *  @param  __position  The index of the bit.
+       *  @param  __val  Either true or false, defaults to true.
+       *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
+       */
+      bitset<_Nb>&
+      set(size_t __position, bool __val = true)
+      {
+	this->_M_check(__position, __N("bitset::set"));
+	return _Unchecked_set(__position, __val);
+      }
+
+      /**
+       *  @brief Sets every bit to false.
+       */
+      bitset<_Nb>&
+      reset() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_do_reset();
+	return *this;
+      }
+
+      /**
+       *  @brief Sets a given bit to false.
+       *  @param  __position  The index of the bit.
+       *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
+       *
+       *  Same as writing @c set(pos,false).
+       */
+      bitset<_Nb>&
+      reset(size_t __position)
+      {
+	this->_M_check(__position, __N("bitset::reset"));
+	return _Unchecked_reset(__position);
+      }
+      
+      /**
+       *  @brief Toggles every bit to its opposite value.
+       */
+      bitset<_Nb>&
+      flip() _GLIBCXX_NOEXCEPT
+      {
+	this->_M_do_flip();
+	this->_M_do_sanitize();
+	return *this;
+      }
+
+      /**
+       *  @brief Toggles a given bit to its opposite value.
+       *  @param  __position  The index of the bit.
+       *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
+       */
+      bitset<_Nb>&
+      flip(size_t __position)
+      {
+	this->_M_check(__position, __N("bitset::flip"));
+	return _Unchecked_flip(__position);
+      }
+      
+      /// See the no-argument flip().
+      bitset<_Nb>
+      operator~() const _GLIBCXX_NOEXCEPT
+      { return bitset<_Nb>(*this).flip(); }
+
+      //@{
+      /**
+       *  @brief  Array-indexing support.
+       *  @param  __position  Index into the %bitset.
+       *  @return A bool for a <em>const %bitset</em>.  For non-const
+       *           bitsets, an instance of the reference proxy class.
+       *  @note  These operators do no range checking and throw no exceptions,
+       *         as required by DR 11 to the standard.
+       *
+       *  _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already
+       *  resolves DR 11 (items 1 and 2), but does not do the range-checking
+       *  required by that DR's resolution.  -pme
+       *  The DR has since been changed:  range-checking is a precondition
+       *  (users' responsibility), and these functions must not throw.  -pme
+       */
+      reference
+      operator[](size_t __position)
+      { return reference(*this, __position); }
+
+      _GLIBCXX_CONSTEXPR bool
+      operator[](size_t __position) const
+      { return _Unchecked_test(__position); }
+      //@}
+      
+      /**
+       *  @brief Returns a numerical interpretation of the %bitset.
+       *  @return  The integral equivalent of the bits.
+       *  @throw  std::overflow_error  If there are too many bits to be
+       *                               represented in an @c unsigned @c long.
+       */
+      unsigned long
+      to_ulong() const
+      { return this->_M_do_to_ulong(); }
+
+#if __cplusplus >= 201103L
+      unsigned long long
+      to_ullong() const
+      { return this->_M_do_to_ullong(); }
+#endif
+
+      /**
+       *  @brief Returns a character interpretation of the %bitset.
+       *  @return  The string equivalent of the bits.
+       *
+       *  Note the ordering of the bits:  decreasing character positions
+       *  correspond to increasing bit positions (see the main class notes for
+       *  an example).
+       */
+      template<class _CharT, class _Traits, class _Alloc>
+	std::basic_string<_CharT, _Traits, _Alloc>
+	to_string() const
+	{
+	  std::basic_string<_CharT, _Traits, _Alloc> __result;
+	  _M_copy_to_string(__result, _CharT('0'), _CharT('1'));
+	  return __result;
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 396. what are characters zero and one.
+      template<class _CharT, class _Traits, class _Alloc>
+	std::basic_string<_CharT, _Traits, _Alloc>
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{
+	  std::basic_string<_CharT, _Traits, _Alloc> __result;
+	  _M_copy_to_string(__result, __zero, __one);
+	  return __result;
+	}
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 434. bitset::to_string() hard to use.
+      template<class _CharT, class _Traits>
+	std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+	to_string() const
+	{ return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 853. to_string needs updating with zero and one.
+      template<class _CharT, class _Traits>
+	std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{ return to_string<_CharT, _Traits,
+	                   std::allocator<_CharT> >(__zero, __one); }
+
+      template<class _CharT>
+	std::basic_string<_CharT, std::char_traits<_CharT>,
+	                  std::allocator<_CharT> >
+	to_string() const
+	{
+	  return to_string<_CharT, std::char_traits<_CharT>,
+	                   std::allocator<_CharT> >();
+	}
+
+      template<class _CharT>
+	std::basic_string<_CharT, std::char_traits<_CharT>,
+	                  std::allocator<_CharT> >
+	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+	{
+	  return to_string<_CharT, std::char_traits<_CharT>,
+	                   std::allocator<_CharT> >(__zero, __one);
+	}
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string() const
+      {
+	return to_string<char, std::char_traits<char>,
+	                 std::allocator<char> >();
+      }
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string(char __zero, char __one = '1') const
+      {
+	return to_string<char, std::char_traits<char>,
+	                 std::allocator<char> >(__zero, __one);
+      }
+
+      // Helper functions for string operations.
+      template<class _CharT, class _Traits>
+        void
+        _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
+			 _CharT, _CharT);
+
+      template<class _CharT, class _Traits, class _Alloc>
+	void
+	_M_copy_from_string(const std::basic_string<_CharT,
+			    _Traits, _Alloc>& __s, size_t __pos, size_t __n,
+			    _CharT __zero, _CharT __one)
+	{ _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n,
+					    __zero, __one); }
+
+      template<class _CharT, class _Traits, class _Alloc>
+	void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
+			  _CharT, _CharT) const;
+
+      // NB: Backward compat.
+      template<class _CharT, class _Traits, class _Alloc>
+	void
+	_M_copy_from_string(const std::basic_string<_CharT,
+			    _Traits, _Alloc>& __s, size_t __pos, size_t __n)
+	{ _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); }
+
+      template<class _CharT, class _Traits, class _Alloc>
+	void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
+	{ _M_copy_to_string(__s, _CharT('0'), _CharT('1')); }
+
+      /// Returns the number of bits which are set.
+      size_t
+      count() const _GLIBCXX_NOEXCEPT
+      { return this->_M_do_count(); }
+
+      /// Returns the total number of bits.
+      _GLIBCXX_CONSTEXPR size_t
+      size() const _GLIBCXX_NOEXCEPT
+      { return _Nb; }
+
+      //@{
+      /// These comparisons for equality/inequality are, well, @e bitwise.
+      bool
+      operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
+      { return this->_M_is_equal(__rhs); }
+
+      bool
+      operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
+      { return !this->_M_is_equal(__rhs); }
+      //@}
+      
+      /**
+       *  @brief Tests the value of a bit.
+       *  @param  __position  The index of a bit.
+       *  @return  The value at @a pos.
+       *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.
+       */
+      bool
+      test(size_t __position) const
+      {
+	this->_M_check(__position, __N("bitset::test"));
+	return _Unchecked_test(__position);
+      }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 693. std::bitset::all() missing.
+      /**
+       *  @brief Tests whether all the bits are on.
+       *  @return  True if all the bits are set.
+       */
+      bool
+      all() const _GLIBCXX_NOEXCEPT
+      { return this->template _M_are_all<_Nb>(); }
+
+      /**
+       *  @brief Tests whether any of the bits are on.
+       *  @return  True if at least one bit is set.
+       */
+      bool
+      any() const _GLIBCXX_NOEXCEPT
+      { return this->_M_is_any(); }
+
+      /**
+       *  @brief Tests whether any of the bits are on.
+       *  @return  True if none of the bits are set.
+       */
+      bool
+      none() const _GLIBCXX_NOEXCEPT
+      { return !this->_M_is_any(); }
+
+      //@{
+      /// Self-explanatory.
+      bitset<_Nb>
+      operator<<(size_t __position) const _GLIBCXX_NOEXCEPT
+      { return bitset<_Nb>(*this) <<= __position; }
+
+      bitset<_Nb>
+      operator>>(size_t __position) const _GLIBCXX_NOEXCEPT
+      { return bitset<_Nb>(*this) >>= __position; }
+      //@}
+      
+      /**
+       *  @brief  Finds the index of the first "on" bit.
+       *  @return  The index of the first bit set, or size() if not found.
+       *  @ingroup SGIextensions
+       *  @sa  _Find_next
+       */
+      size_t
+      _Find_first() const _GLIBCXX_NOEXCEPT
+      { return this->_M_do_find_first(_Nb); }
+
+      /**
+       *  @brief  Finds the index of the next "on" bit after prev.
+       *  @return  The index of the next bit set, or size() if not found.
+       *  @param  __prev  Where to start searching.
+       *  @ingroup SGIextensions
+       *  @sa  _Find_first
+       */
+      size_t
+      _Find_next(size_t __prev) const _GLIBCXX_NOEXCEPT
+      { return this->_M_do_find_next(__prev, _Nb); }
+    };
+
+  // Definitions of non-inline member functions.
+  template<size_t _Nb>
+    template<class _CharT, class _Traits>
+      void
+      bitset<_Nb>::
+      _M_copy_from_ptr(const _CharT* __s, size_t __len,
+		       size_t __pos, size_t __n, _CharT __zero, _CharT __one)
+      {
+	reset();
+	const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos)));
+	for (size_t __i = __nbits; __i > 0; --__i)
+	  {
+	    const _CharT __c = __s[__pos + __nbits - __i];
+	    if (_Traits::eq(__c, __zero))
+	      ;
+	    else if (_Traits::eq(__c, __one))
+	      _Unchecked_set(__i - 1);
+	    else
+	      __throw_invalid_argument(__N("bitset::_M_copy_from_ptr"));
+	  }
+      }
+
+  template<size_t _Nb>
+    template<class _CharT, class _Traits, class _Alloc>
+      void
+      bitset<_Nb>::
+      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
+			_CharT __zero, _CharT __one) const
+      {
+	__s.assign(_Nb, __zero);
+	for (size_t __i = _Nb; __i > 0; --__i)
+	  if (_Unchecked_test(__i - 1))
+	    _Traits::assign(__s[_Nb - __i], __one);
+      }
+
+  // 23.3.5.3 bitset operations:
+  //@{
+  /**
+   *  @brief  Global bitwise operations on bitsets.
+   *  @param  __x  A bitset.
+   *  @param  __y  A bitset of the same size as @a __x.
+   *  @return  A new bitset.
+   *
+   *  These should be self-explanatory.
+  */
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    {
+      bitset<_Nb> __result(__x);
+      __result &= __y;
+      return __result;
+    }
+
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    {
+      bitset<_Nb> __result(__x);
+      __result |= __y;
+      return __result;
+    }
+
+  template <size_t _Nb>
+    inline bitset<_Nb>
+    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
+    {
+      bitset<_Nb> __result(__x);
+      __result ^= __y;
+      return __result;
+    }
+  //@}
+
+  //@{
+  /**
+   *  @brief Global I/O operators for bitsets.
+   *
+   *  Direct I/O between streams and bitsets is supported.  Output is
+   *  straightforward.  Input will skip whitespace, only accept @a 0 and @a 1
+   *  characters, and will only extract as many digits as the %bitset will
+   *  hold.
+  */
+  template<class _CharT, class _Traits, size_t _Nb>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
+    {
+      typedef typename _Traits::char_type          char_type;
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      std::basic_string<_CharT, _Traits> __tmp;
+      __tmp.reserve(_Nb);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 303. Bitset input operator underspecified
+      const char_type __zero = __is.widen('0');
+      const char_type __one = __is.widen('1');
+
+      typename __ios_base::iostate __state = __ios_base::goodbit;
+      typename __istream_type::sentry __sentry(__is);
+      if (__sentry)
+	{
+	  __try
+	    {
+	      for (size_t __i = _Nb; __i > 0; --__i)
+		{
+		  static typename _Traits::int_type __eof = _Traits::eof();
+		  
+		  typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
+		  if (_Traits::eq_int_type(__c1, __eof))
+		    {
+		      __state |= __ios_base::eofbit;
+		      break;
+		    }
+		  else
+		    {
+		      const char_type __c2 = _Traits::to_char_type(__c1);
+		      if (_Traits::eq(__c2, __zero))
+			__tmp.push_back(__zero);
+		      else if (_Traits::eq(__c2, __one))
+			__tmp.push_back(__one);
+		      else if (_Traits::
+			       eq_int_type(__is.rdbuf()->sputbackc(__c2),
+					   __eof))
+			{
+			  __state |= __ios_base::failbit;
+			  break;
+			}
+		    }
+		}
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __is._M_setstate(__ios_base::badbit);		
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __is._M_setstate(__ios_base::badbit); }
+	}
+
+      if (__tmp.empty() && _Nb)
+	__state |= __ios_base::failbit;
+      else
+	__x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
+				__zero, __one);
+      if (__state)
+	__is.setstate(__state);
+      return __is;
+    }
+
+  template <class _CharT, class _Traits, size_t _Nb>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const bitset<_Nb>& __x)
+    {
+      std::basic_string<_CharT, _Traits> __tmp;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 396. what are characters zero and one.
+      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
+      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
+      return __os << __tmp;
+    }
+  //@}
+
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
+
+#undef _GLIBCXX_BITSET_WORDS
+#undef _GLIBCXX_BITSET_BITS_PER_WORD
+#undef _GLIBCXX_BITSET_BITS_PER_ULL
+
+#if __cplusplus >= 201103L
+
+#include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // DR 1182.
+  /// std::hash specialization for bitset.
+  template<size_t _Nb>
+    struct hash<_GLIBCXX_STD_C::bitset<_Nb>>
+    : public __hash_base<size_t, _GLIBCXX_STD_C::bitset<_Nb>>
+    {
+      size_t
+      operator()(const _GLIBCXX_STD_C::bitset<_Nb>& __b) const noexcept
+      {
+	const size_t __clength = (_Nb + __CHAR_BIT__ - 1) / __CHAR_BIT__;
+	return std::_Hash_impl::hash(__b._M_getdata(), __clength);
+      }
+    };
+
+  template<>
+    struct hash<_GLIBCXX_STD_C::bitset<0>>
+    : public __hash_base<size_t, _GLIBCXX_STD_C::bitset<0>>
+    {
+      size_t
+      operator()(const _GLIBCXX_STD_C::bitset<0>&) const noexcept
+      { return 0; }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // C++11
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/bitset>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/bitset>
+#endif
+
+#endif /* _GLIBCXX_BITSET */
diff --git a/gcc-4.9/libstdc++-v3/include/std/chrono b/gcc-4.9/libstdc++-v3/include/std/chrono
new file mode 100644
index 0000000..b114e02
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/chrono
@@ -0,0 +1,914 @@
+// <chrono> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/chrono
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_CHRONO
+#define _GLIBCXX_CHRONO 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <ratio>
+#include <type_traits>
+#include <limits>
+#include <ctime>
+#include <bits/parse_numbers.h> // for literals support.
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  /**
+   * @defgroup chrono Time
+   * @ingroup utilities
+   *
+   * Classes and functions for time.
+   * @{
+   */
+
+  /** @namespace std::chrono
+   *  @brief ISO C++ 2011 entities sub-namespace for time and date.
+   */
+  namespace chrono
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    template<typename _Rep, typename _Period = ratio<1>>
+      struct duration;
+
+    template<typename _Clock, typename _Dur = typename _Clock::duration>
+      struct time_point;
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  }
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
+  
+  template<typename _CT, typename _Period1, typename _Period2>
+    struct __duration_common_type_wrapper
+    {
+    private:
+      typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
+      typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
+      typedef typename _CT::type __cr;
+      typedef ratio<__gcd_num::value,
+        (_Period1::den / __gcd_den::value) * _Period2::den> __r;
+    public:
+      typedef __success_type<chrono::duration<__cr, __r>> type;
+    };
+
+  template<typename _Period1, typename _Period2>
+    struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
+    { typedef __failure_type type; };
+
+  template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
+    struct common_type<chrono::duration<_Rep1, _Period1>,
+             chrono::duration<_Rep2, _Period2>>
+    : public __duration_common_type_wrapper<typename __member_type_wrapper<
+             common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
+    { };
+
+  // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
+  
+  template<typename _CT, typename _Clock>
+    struct __timepoint_common_type_wrapper
+    {
+      typedef __success_type<chrono::time_point<_Clock, typename _CT::type>>
+        type;
+    };
+
+  template<typename _Clock>
+    struct __timepoint_common_type_wrapper<__failure_type, _Clock>
+    { typedef __failure_type type; };
+
+  template<typename _Clock, typename _Duration1, typename _Duration2>
+    struct common_type<chrono::time_point<_Clock, _Duration1>,
+             chrono::time_point<_Clock, _Duration2>>
+    : public __timepoint_common_type_wrapper<typename __member_type_wrapper<
+             common_type<_Duration1, _Duration2>>::type, _Clock>::type
+    { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+  namespace chrono
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    // Primary template for duration_cast impl.
+    template<typename _ToDur, typename _CF, typename _CR,
+	     bool _NumIsOne = false, bool _DenIsOne = false>
+      struct __duration_cast_impl
+      {
+	template<typename _Rep, typename _Period>
+	  static constexpr _ToDur
+	  __cast(const duration<_Rep, _Period>& __d)
+	  {
+	    typedef typename _ToDur::rep			__to_rep;
+	    return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
+	      * static_cast<_CR>(_CF::num)
+	      / static_cast<_CR>(_CF::den)));
+	  }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
+      {
+	template<typename _Rep, typename _Period>
+	  static constexpr _ToDur
+	  __cast(const duration<_Rep, _Period>& __d)
+	  {
+	    typedef typename _ToDur::rep			__to_rep;
+	    return _ToDur(static_cast<__to_rep>(__d.count()));
+	  }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
+      {
+	template<typename _Rep, typename _Period>
+	  static constexpr _ToDur
+	  __cast(const duration<_Rep, _Period>& __d)
+	  {
+	    typedef typename _ToDur::rep			__to_rep;
+	    return _ToDur(static_cast<__to_rep>(
+	      static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
+	  }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
+      {
+	template<typename _Rep, typename _Period>
+	  static constexpr _ToDur
+	  __cast(const duration<_Rep, _Period>& __d)
+	  {
+	    typedef typename _ToDur::rep			__to_rep;
+	    return _ToDur(static_cast<__to_rep>(
+	      static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
+	  }
+      };
+
+    template<typename _Tp>
+      struct __is_duration
+      : std::false_type
+      { };
+
+    template<typename _Rep, typename _Period>
+      struct __is_duration<duration<_Rep, _Period>>
+      : std::true_type
+      { };
+
+    /// duration_cast
+    template<typename _ToDur, typename _Rep, typename _Period>
+      constexpr typename enable_if<__is_duration<_ToDur>::value,
+				   _ToDur>::type
+      duration_cast(const duration<_Rep, _Period>& __d)
+      {
+	typedef typename _ToDur::period				__to_period;
+	typedef typename _ToDur::rep				__to_rep;
+	typedef ratio_divide<_Period, __to_period> 		__cf;
+	typedef typename common_type<__to_rep, _Rep, intmax_t>::type
+	  							__cr;
+	typedef  __duration_cast_impl<_ToDur, __cf, __cr,
+				      __cf::num == 1, __cf::den == 1> __dc;
+	return __dc::__cast(__d);
+      }
+
+    /// treat_as_floating_point
+    template<typename _Rep>
+      struct treat_as_floating_point
+      : is_floating_point<_Rep>
+      { };
+
+    /// duration_values
+    template<typename _Rep>
+      struct duration_values
+      {
+	static constexpr _Rep
+	zero()
+	{ return _Rep(0); }
+
+	static constexpr _Rep
+	max()
+	{ return numeric_limits<_Rep>::max(); }
+
+	static constexpr _Rep
+	min()
+	{ return numeric_limits<_Rep>::lowest(); }
+      };
+
+    template<typename _Tp>
+      struct __is_ratio
+      : std::false_type
+      { };
+
+    template<intmax_t _Num, intmax_t _Den>
+      struct __is_ratio<ratio<_Num, _Den>>
+      : std::true_type
+      { };
+
+    /// duration
+    template<typename _Rep, typename _Period>
+      struct duration
+      {
+	typedef _Rep						rep;
+	typedef _Period 					period;
+
+	static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
+	static_assert(__is_ratio<_Period>::value,
+		      "period must be a specialization of ratio");
+	static_assert(_Period::num > 0, "period must be positive");
+
+	// 20.11.5.1 construction / copy / destroy
+	constexpr duration() = default;
+
+	// NB: Make constexpr implicit. This cannot be explicitly
+	// constexpr, as any UDT that is not a literal type with a
+	// constexpr copy constructor will be ill-formed.
+	duration(const duration&) = default;
+
+	template<typename _Rep2, typename = typename
+	       enable_if<is_convertible<_Rep2, rep>::value
+			 && (treat_as_floating_point<rep>::value
+			     || !treat_as_floating_point<_Rep2>::value)>::type>
+	  constexpr explicit duration(const _Rep2& __rep)
+	  : __r(static_cast<rep>(__rep)) { }
+
+	template<typename _Rep2, typename _Period2, typename = typename
+	       enable_if<treat_as_floating_point<rep>::value
+			 || (ratio_divide<_Period2, period>::den == 1
+			     && !treat_as_floating_point<_Rep2>::value)>::type>
+	  constexpr duration(const duration<_Rep2, _Period2>& __d)
+	  : __r(duration_cast<duration>(__d).count()) { }
+
+	~duration() = default;
+	duration& operator=(const duration&) = default;
+
+	// 20.11.5.2 observer
+	constexpr rep
+	count() const
+	{ return __r; }
+
+	// 20.11.5.3 arithmetic
+	constexpr duration
+	operator+() const
+	{ return *this; }
+
+	constexpr duration
+	operator-() const
+	{ return duration(-__r); }
+
+	duration&
+	operator++()
+	{
+	  ++__r;
+	  return *this;
+	}
+
+	duration
+	operator++(int)
+	{ return duration(__r++); }
+
+	duration&
+	operator--()
+	{
+	  --__r;
+	  return *this;
+	}
+
+	duration
+	operator--(int)
+	{ return duration(__r--); }
+
+	duration&
+	operator+=(const duration& __d)
+	{
+	  __r += __d.count();
+	  return *this;
+	}
+
+	duration&
+	operator-=(const duration& __d)
+	{
+	  __r -= __d.count();
+	  return *this;
+	}
+
+	duration&
+	operator*=(const rep& __rhs)
+	{
+	  __r *= __rhs;
+	  return *this;
+	}
+
+	duration&
+	operator/=(const rep& __rhs)
+	{
+	  __r /= __rhs;
+	  return *this;
+	}
+
+	// DR 934.
+	template<typename _Rep2 = rep>
+	  typename enable_if<!treat_as_floating_point<_Rep2>::value,
+			     duration&>::type
+	  operator%=(const rep& __rhs)
+	  {
+	    __r %= __rhs;
+	    return *this;
+	  }
+
+	template<typename _Rep2 = rep>
+	  typename enable_if<!treat_as_floating_point<_Rep2>::value,
+			     duration&>::type
+	  operator%=(const duration& __d)
+	  {
+	    __r %= __d.count();
+	    return *this;
+	  }
+
+	// 20.11.5.4 special values
+	static constexpr duration
+	zero()
+	{ return duration(duration_values<rep>::zero()); }
+
+	static constexpr duration
+	min()
+	{ return duration(duration_values<rep>::min()); }
+
+	static constexpr duration
+	max()
+	{ return duration(duration_values<rep>::max()); }
+
+      private:
+	rep __r;
+      };
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+				     duration<_Rep2, _Period2>>::type
+      operator+(const duration<_Rep1, _Period1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      {
+	typedef duration<_Rep1, _Period1>			__dur1;
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<__dur1,__dur2>::type	__cd;
+	return __cd(__cd(__lhs).count() + __cd(__rhs).count());
+      }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+				     duration<_Rep2, _Period2>>::type
+      operator-(const duration<_Rep1, _Period1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      {
+	typedef duration<_Rep1, _Period1>			__dur1;
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<__dur1,__dur2>::type	__cd;
+	return __cd(__cd(__lhs).count() - __cd(__rhs).count());
+      }
+
+    template<typename _Rep1, typename _Rep2, bool =
+	     is_convertible<_Rep2,
+			    typename common_type<_Rep1, _Rep2>::type>::value>
+      struct __common_rep_type { };
+
+    template<typename _Rep1, typename _Rep2>
+      struct __common_rep_type<_Rep1, _Rep2, true>
+      { typedef typename common_type<_Rep1, _Rep2>::type type; };
+
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr
+      duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
+      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+	typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+	  __cd;
+	return __cd(__cd(__d).count() * __s);
+      }
+
+    template<typename _Rep1, typename _Rep2, typename _Period>
+      constexpr
+      duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
+      operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
+      { return __d * __s; }
+
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr duration<typename __common_rep_type<_Rep1, typename
+	enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
+      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+	typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+	  __cd;
+	return __cd(__cd(__d).count() / __s);
+      }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr typename common_type<_Rep1, _Rep2>::type
+      operator/(const duration<_Rep1, _Period1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      {
+	typedef duration<_Rep1, _Period1>			__dur1;
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<__dur1,__dur2>::type	__cd;
+	return __cd(__lhs).count() / __cd(__rhs).count();
+      }
+
+    // DR 934.
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr duration<typename __common_rep_type<_Rep1, typename
+	enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
+      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+	typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+	  __cd;
+	return __cd(__cd(__d).count() % __s);
+      }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+				     duration<_Rep2, _Period2>>::type
+      operator%(const duration<_Rep1, _Period1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      {
+	typedef duration<_Rep1, _Period1>			__dur1;
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<__dur1,__dur2>::type	__cd;
+	return __cd(__cd(__lhs).count() % __cd(__rhs).count());
+      }
+
+    // comparisons
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr bool
+      operator==(const duration<_Rep1, _Period1>& __lhs,
+		 const duration<_Rep2, _Period2>& __rhs)
+      {
+	typedef duration<_Rep1, _Period1>			__dur1;
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<__dur1,__dur2>::type	__ct;
+	return __ct(__lhs).count() == __ct(__rhs).count();
+      }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr bool
+      operator<(const duration<_Rep1, _Period1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      {
+	typedef duration<_Rep1, _Period1>			__dur1;
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<__dur1,__dur2>::type	__ct;
+	return __ct(__lhs).count() < __ct(__rhs).count();
+      }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr bool
+      operator!=(const duration<_Rep1, _Period1>& __lhs,
+		 const duration<_Rep2, _Period2>& __rhs)
+      { return !(__lhs == __rhs); }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr bool
+      operator<=(const duration<_Rep1, _Period1>& __lhs,
+		 const duration<_Rep2, _Period2>& __rhs)
+      { return !(__rhs < __lhs); }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr bool
+      operator>(const duration<_Rep1, _Period1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      { return __rhs < __lhs; }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Rep2, typename _Period2>
+      constexpr bool
+      operator>=(const duration<_Rep1, _Period1>& __lhs,
+		 const duration<_Rep2, _Period2>& __rhs)
+      { return !(__lhs < __rhs); }
+
+    /// nanoseconds
+    typedef duration<int64_t, nano> 	    nanoseconds;
+
+    /// microseconds
+    typedef duration<int64_t, micro> 	    microseconds;
+
+    /// milliseconds
+    typedef duration<int64_t, milli> 	    milliseconds;
+
+    /// seconds
+    typedef duration<int64_t> 		    seconds;
+
+    /// minutes
+    typedef duration<int64_t, ratio< 60>>   minutes;
+
+    /// hours
+    typedef duration<int64_t, ratio<3600>>  hours;
+
+    /// time_point
+    template<typename _Clock, typename _Dur>
+      struct time_point
+      {
+	typedef _Clock			  			clock;
+	typedef _Dur		  				duration;
+	typedef typename duration::rep	  			rep;
+	typedef typename duration::period			period;
+
+	constexpr time_point() : __d(duration::zero())
+	{ }
+
+	constexpr explicit time_point(const duration& __dur)
+	: __d(__dur)
+	{ }
+
+	// conversions
+	template<typename _Dur2>
+	  constexpr time_point(const time_point<clock, _Dur2>& __t)
+	  : __d(__t.time_since_epoch())
+	  { }
+
+	// observer
+	constexpr duration
+	time_since_epoch() const
+	{ return __d; }
+
+	// arithmetic
+	time_point&
+	operator+=(const duration& __dur)
+	{
+	  __d += __dur;
+	  return *this;
+	}
+
+	time_point&
+	operator-=(const duration& __dur)
+	{
+	  __d -= __dur;
+	  return *this;
+	}
+
+	// special values
+	static constexpr time_point
+	min()
+	{ return time_point(duration::min()); }
+
+	static constexpr time_point
+	max()
+	{ return time_point(duration::max()); }
+
+      private:
+	duration __d;
+      };
+
+    /// time_point_cast
+    template<typename _ToDur, typename _Clock, typename _Dur>
+      constexpr typename enable_if<__is_duration<_ToDur>::value,
+				   time_point<_Clock, _ToDur>>::type
+      time_point_cast(const time_point<_Clock, _Dur>& __t)
+      {
+	typedef time_point<_Clock, _ToDur> 			__time_point;
+	return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
+      }
+
+    template<typename _Clock, typename _Dur1,
+	     typename _Rep2, typename _Period2>
+      constexpr time_point<_Clock,
+	typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
+      operator+(const time_point<_Clock, _Dur1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      {
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<_Dur1,__dur2>::type	__ct;
+	typedef time_point<_Clock, __ct> 			__time_point;
+	return __time_point(__lhs.time_since_epoch() + __rhs);
+      }
+
+    template<typename _Rep1, typename _Period1,
+	     typename _Clock, typename _Dur2>
+      constexpr time_point<_Clock,
+	typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
+      operator+(const duration<_Rep1, _Period1>& __lhs,
+		const time_point<_Clock, _Dur2>& __rhs)
+      { 
+	typedef duration<_Rep1, _Period1>			__dur1;
+	typedef typename common_type<__dur1,_Dur2>::type	__ct;
+	typedef time_point<_Clock, __ct> 			__time_point;
+	return __time_point(__rhs.time_since_epoch() + __lhs); 
+      }
+
+    template<typename _Clock, typename _Dur1,
+	     typename _Rep2, typename _Period2>
+      constexpr time_point<_Clock,
+	typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
+      operator-(const time_point<_Clock, _Dur1>& __lhs,
+		const duration<_Rep2, _Period2>& __rhs)
+      { 
+	typedef duration<_Rep2, _Period2>			__dur2;
+	typedef typename common_type<_Dur1,__dur2>::type	__ct;
+	typedef time_point<_Clock, __ct> 			__time_point;
+	return __time_point(__lhs.time_since_epoch() -__rhs); 
+      }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr typename common_type<_Dur1, _Dur2>::type
+      operator-(const time_point<_Clock, _Dur1>& __lhs,
+		const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator==(const time_point<_Clock, _Dur1>& __lhs,
+		 const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator!=(const time_point<_Clock, _Dur1>& __lhs,
+		 const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__lhs == __rhs); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator<(const time_point<_Clock, _Dur1>& __lhs,
+		const time_point<_Clock, _Dur2>& __rhs)
+      { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator<=(const time_point<_Clock, _Dur1>& __lhs,
+		 const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__rhs < __lhs); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator>(const time_point<_Clock, _Dur1>& __lhs,
+		const time_point<_Clock, _Dur2>& __rhs)
+      { return __rhs < __lhs; }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator>=(const time_point<_Clock, _Dur1>& __lhs,
+		 const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__lhs < __rhs); }
+
+
+    // Clocks. 
+
+    // Why nanosecond resolution as the default?  
+    // Why have std::system_clock always count in the higest
+    // resolution (ie nanoseconds), even if on some OSes the low 3
+    // or 9 decimal digits will be always zero? This allows later
+    // implementations to change the system_clock::now()
+    // implementation any time to provide better resolution without
+    // changing function signature or units.
+
+    // To support the (forward) evolution of the library's defined
+    // clocks, wrap inside inline namespace so that the current
+    // defintions of system_clock, steady_clock, and
+    // high_resolution_clock types are uniquely mangled. This way, new
+    // code can use the latests clocks, while the library can contain
+    // compatibility definitions for previous versions.  At some
+    // point, when these clocks settle down, the inlined namespaces
+    // can be removed.  XXX GLIBCXX_ABI Deprecated
+    inline namespace _V2 {
+
+    /**
+     *  @brief System clock.
+     *
+     *  Time returned represents wall time from the system-wide clock.
+    */
+    struct system_clock
+    {
+      typedef chrono::nanoseconds     				duration;
+      typedef duration::rep    					rep;
+      typedef duration::period 					period;
+      typedef chrono::time_point<system_clock, duration> 	time_point;
+
+      static_assert(system_clock::duration::min()
+		    < system_clock::duration::zero(),
+		    "a clock's minimum duration cannot be less than its epoch");
+
+      static constexpr bool is_steady = false;
+
+      static time_point
+      now() noexcept;
+
+      // Map to C API
+      static std::time_t
+      to_time_t(const time_point& __t) noexcept
+      {
+	return std::time_t(duration_cast<chrono::seconds>
+			   (__t.time_since_epoch()).count());
+      }
+
+      static time_point
+      from_time_t(std::time_t __t) noexcept
+      {
+	typedef chrono::time_point<system_clock, seconds>	__from;
+	return time_point_cast<system_clock::duration>
+	       (__from(chrono::seconds(__t)));
+      }
+    };
+
+
+    /**
+     *  @brief Monotonic clock
+     *
+     *  Time returned has the property of only increasing at a uniform rate.
+    */
+    struct steady_clock
+    {
+      typedef chrono::nanoseconds 				duration;
+      typedef duration::rep	  				rep;
+      typedef duration::period	  				period;
+      typedef chrono::time_point<steady_clock, duration> 	time_point;
+
+      static constexpr bool is_steady = true;
+
+      static time_point
+      now() noexcept;
+    };
+
+
+    /**
+     *  @brief Highest-resolution clock
+     *
+     *  This is the clock "with the shortest tick period." Alias to
+     *  std::system_clock until higher-than-nanosecond definitions
+     *  become feasible.
+    */
+    using high_resolution_clock = system_clock;
+
+    } // end inline namespace _V2
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace chrono
+
+#if __cplusplus > 201103L
+
+  inline namespace literals
+  {
+  inline namespace chrono_literals
+  {
+
+    namespace __select_type
+    {
+
+      using namespace __parse_int;
+
+      template<unsigned long long _Val, typename _Dur>
+	struct _Select_type
+	: conditional<
+	    _Val <= static_cast<unsigned long long>
+		      (numeric_limits<typename _Dur::rep>::max()),
+	    _Dur, void>
+	{
+	  static constexpr typename _Select_type::type
+	    value{static_cast<typename _Select_type::type>(_Val)};
+	};
+
+      template<unsigned long long _Val, typename _Dur>
+	constexpr typename _Select_type<_Val, _Dur>::type
+	_Select_type<_Val, _Dur>::value;
+
+    } // __select_type
+
+    constexpr chrono::duration<long double, ratio<3600,1>>
+    operator""h(long double __hours)
+    { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
+
+    template <char... _Digits>
+      constexpr typename
+      __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
+			     chrono::hours>::type
+      operator""h()
+      {
+	return __select_type::_Select_type<
+			  __select_int::_Select_int<_Digits...>::value,
+			  chrono::hours>::value;
+      }
+
+    constexpr chrono::duration<long double, ratio<60,1>>
+    operator""min(long double __mins)
+    { return chrono::duration<long double, ratio<60,1>>{__mins}; }
+
+    template <char... _Digits>
+      constexpr typename
+      __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
+			     chrono::minutes>::type
+      operator""min()
+      {
+	return __select_type::_Select_type<
+			  __select_int::_Select_int<_Digits...>::value,
+			  chrono::minutes>::value;
+      }
+
+    constexpr chrono::duration<long double>
+    operator""s(long double __secs)
+    { return chrono::duration<long double>{__secs}; }
+
+    template <char... _Digits>
+      constexpr typename
+      __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
+			     chrono::seconds>::type
+      operator""s()
+      {
+	return __select_type::_Select_type<
+			  __select_int::_Select_int<_Digits...>::value,
+			  chrono::seconds>::value;
+      }
+
+    constexpr chrono::duration<long double, milli>
+    operator""ms(long double __msecs)
+    { return chrono::duration<long double, milli>{__msecs}; }
+
+    template <char... _Digits>
+      constexpr typename
+      __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
+			     chrono::milliseconds>::type
+      operator""ms()
+      {
+	return __select_type::_Select_type<
+			  __select_int::_Select_int<_Digits...>::value,
+			  chrono::milliseconds>::value;
+      }
+
+    constexpr chrono::duration<long double, micro>
+    operator""us(long double __usecs)
+    { return chrono::duration<long double, micro>{__usecs}; }
+
+    template <char... _Digits>
+      constexpr typename
+      __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
+			     chrono::microseconds>::type
+      operator""us()
+      {
+	return __select_type::_Select_type<
+			  __select_int::_Select_int<_Digits...>::value,
+			  chrono::microseconds>::value;
+      }
+
+    constexpr chrono::duration<long double, nano>
+    operator""ns(long double __nsecs)
+    { return chrono::duration<long double, nano>{__nsecs}; }
+
+    template <char... _Digits>
+      constexpr typename
+      __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
+			     chrono::nanoseconds>::type
+      operator""ns()
+      {
+	return __select_type::_Select_type<
+			  __select_int::_Select_int<_Digits...>::value,
+			  chrono::nanoseconds>::value;
+      }
+
+  } // inline namespace chrono_literals
+  } // inline namespace literals
+
+#endif // __cplusplus > 201103L
+
+  // @} group chrono
+} // namespace std
+
+#endif //_GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif //_GLIBCXX_CHRONO
diff --git a/gcc-4.9/libstdc++-v3/include/std/complex b/gcc-4.9/libstdc++-v3/include/std/complex
new file mode 100644
index 0000000..34fa1dd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/complex
@@ -0,0 +1,1966 @@
+// The template and inlines for the -*- C++ -*- complex number classes.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/complex
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 26.2  Complex Numbers
+// Note: this is not a conforming implementation.
+// Initially implemented by Ulrich Drepper <drepper@cygnus.com>
+// Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
+//
+
+#ifndef _GLIBCXX_COMPLEX
+#define _GLIBCXX_COMPLEX 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+#include <cmath>
+#include <sstream>
+
+// Get rid of a macro possibly defined in <complex.h>
+#undef complex
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup complex_numbers Complex Numbers
+   * @ingroup numerics
+   *
+   * Classes and functions for complex numbers.
+   * @{
+   */
+
+  // Forward declarations.
+  template<typename _Tp> class complex;
+  template<> class complex<float>;
+  template<> class complex<double>;
+  template<> class complex<long double>;
+
+  ///  Return magnitude of @a z.
+  template<typename _Tp> _Tp abs(const complex<_Tp>&);
+  ///  Return phase angle of @a z.
+  template<typename _Tp> _Tp arg(const complex<_Tp>&);
+  ///  Return @a z magnitude squared.
+  template<typename _Tp> _Tp norm(const complex<_Tp>&);
+
+  ///  Return complex conjugate of @a z.
+  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
+  ///  Return complex with magnitude @a rho and angle @a theta.
+  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
+
+  // Transcendentals:
+  /// Return complex cosine of @a z.
+  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
+  /// Return complex hyperbolic cosine of @a z.
+  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
+  /// Return complex base e exponential of @a z.
+  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
+  /// Return complex natural logarithm of @a z.
+  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
+  /// Return complex base 10 logarithm of @a z.
+  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
+  /// Return @a x to the @a y'th power.
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
+  /// Return @a x to the @a y'th power.
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
+  /// Return @a x to the @a y'th power.
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, 
+                                          const complex<_Tp>&);
+  /// Return @a x to the @a y'th power.
+  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
+  /// Return complex sine of @a z.
+  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
+  /// Return complex hyperbolic sine of @a z.
+  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
+  /// Return complex square root of @a z.
+  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
+  /// Return complex tangent of @a z.
+  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
+  /// Return complex hyperbolic tangent of @a z.
+  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
+    
+    
+  // 26.2.2  Primary template class complex
+  /**
+   *  Template to represent complex numbers.
+   *
+   *  Specializations for float, double, and long double are part of the
+   *  library.  Results with any other type are not guaranteed.
+   *
+   *  @param  Tp  Type of real and imaginary values.
+  */
+  template<typename _Tp>
+    struct complex
+    {
+      /// Value typedef.
+      typedef _Tp value_type;
+      
+      ///  Default constructor.  First parameter is x, second parameter is y.
+      ///  Unspecified parameters default to 0.
+      _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
+      : _M_real(__r), _M_imag(__i) { }
+
+      // Lets the compiler synthesize the copy constructor   
+      // complex (const complex<_Tp>&);
+      ///  Copy constructor.
+      template<typename _Up>
+        _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
+	: _M_real(__z.real()), _M_imag(__z.imag()) { }
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      _GLIBCXX_ABI_TAG_CXX11
+      constexpr _Tp 
+      real() { return _M_real; }
+
+      _GLIBCXX_ABI_TAG_CXX11
+      constexpr _Tp 
+      imag() { return _M_imag; }
+#else
+      ///  Return real part of complex number.
+      _Tp& 
+      real() { return _M_real; }
+
+      ///  Return real part of complex number.
+      const _Tp& 
+      real() const { return _M_real; }
+
+      ///  Return imaginary part of complex number.
+      _Tp& 
+      imag() { return _M_imag; }
+
+      ///  Return imaginary part of complex number.
+      const _Tp& 
+      imag() const { return _M_imag; }
+#endif
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      void 
+      real(_Tp __val) { _M_real = __val; }
+
+      void 
+      imag(_Tp __val) { _M_imag = __val; }
+
+      /// Assign this complex number to scalar @a t.
+      complex<_Tp>& operator=(const _Tp&);
+      
+      /// Add @a t to this complex number.
+      // 26.2.5/1
+      complex<_Tp>&
+      operator+=(const _Tp& __t)
+      {
+	_M_real += __t;
+	return *this;
+      }
+
+      /// Subtract @a t from this complex number.
+      // 26.2.5/3
+      complex<_Tp>&
+      operator-=(const _Tp& __t)
+      {
+	_M_real -= __t;
+	return *this;
+      }
+
+      /// Multiply this complex number by @a t.
+      complex<_Tp>& operator*=(const _Tp&);
+      /// Divide this complex number by @a t.
+      complex<_Tp>& operator/=(const _Tp&);
+
+      // Lets the compiler synthesize the
+      // copy and assignment operator
+      // complex<_Tp>& operator= (const complex<_Tp>&);
+      /// Assign this complex number to complex @a z.
+      template<typename _Up>
+        complex<_Tp>& operator=(const complex<_Up>&);
+      /// Add @a z to this complex number.
+      template<typename _Up>
+        complex<_Tp>& operator+=(const complex<_Up>&);
+      /// Subtract @a z from this complex number.
+      template<typename _Up>
+        complex<_Tp>& operator-=(const complex<_Up>&);
+      /// Multiply this complex number by @a z.
+      template<typename _Up>
+        complex<_Tp>& operator*=(const complex<_Up>&);
+      /// Divide this complex number by @a z.
+      template<typename _Up>
+        complex<_Tp>& operator/=(const complex<_Up>&);
+
+      _GLIBCXX_USE_CONSTEXPR complex __rep() const
+      { return *this; }
+
+    private:
+      _Tp _M_real;
+      _Tp _M_imag;
+    };
+
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const _Tp& __t)
+    {
+     _M_real = __t;
+     _M_imag = _Tp();
+     return *this;
+    } 
+
+  // 26.2.5/5
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const _Tp& __t)
+    {
+      _M_real *= __t;
+      _M_imag *= __t;
+      return *this;
+    }
+
+  // 26.2.5/7
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const _Tp& __t)
+    {
+      _M_real /= __t;
+      _M_imag /= __t;
+      return *this;
+    }
+
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const complex<_Up>& __z)
+    {
+      _M_real = __z.real();
+      _M_imag = __z.imag();
+      return *this;
+    }
+
+  // 26.2.5/9
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator+=(const complex<_Up>& __z)
+    {
+      _M_real += __z.real();
+      _M_imag += __z.imag();
+      return *this;
+    }
+
+  // 26.2.5/11
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator-=(const complex<_Up>& __z)
+    {
+      _M_real -= __z.real();
+      _M_imag -= __z.imag();
+      return *this;
+    }
+
+  // 26.2.5/13
+  // XXX: This is a grammar school implementation.
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const complex<_Up>& __z)
+    {
+      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
+      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
+      _M_real = __r;
+      return *this;
+    }
+
+  // 26.2.5/15
+  // XXX: This is a grammar school implementation.
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const complex<_Up>& __z)
+    {
+      const _Tp __r =  _M_real * __z.real() + _M_imag * __z.imag();
+      const _Tp __n = std::norm(__z);
+      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
+      _M_real = __r / __n;
+      return *this;
+    }
+    
+  // Operators:
+  //@{
+  ///  Return new complex value @a x plus @a y.
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r += __x;
+      return __r;
+    }
+  //@}
+
+  //@{
+  ///  Return new complex value @a x minus @a y.
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+    
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r(__x, -__y.imag());
+      __r -= __y.real();
+      return __r;
+    }
+  //@}
+
+  //@{
+  ///  Return new complex value @a x times @a y.
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r *= __x;
+      return __r;
+    }
+  //@}
+
+  //@{
+  ///  Return new complex value @a x divided by @a y.
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+    
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+  //@}
+
+  ///  Return @a x.
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x)
+    { return __x; }
+
+  ///  Return complex negation of @a x.
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x)
+    {  return complex<_Tp>(-__x.real(), -__x.imag()); }
+
+  //@{
+  ///  Return true if @a x is equal to @a y.
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator==(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() == __y && __x.imag() == _Tp(); }
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator==(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x == __y.real() && _Tp() == __y.imag(); }
+  //@}
+
+  //@{
+  ///  Return false if @a x is equal to @a y.
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator!=(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() != __y || __x.imag() != _Tp(); }
+
+  template<typename _Tp>
+    inline _GLIBCXX_CONSTEXPR bool
+    operator!=(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x != __y.real() || _Tp() != __y.imag(); }
+  //@}
+
+  ///  Extraction operator for complex values.
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
+    {
+      _Tp __re_x, __im_x;
+      _CharT __ch;
+      __is >> __ch;
+      if (__ch == '(') 
+	{
+	  __is >> __re_x >> __ch;
+	  if (__ch == ',') 
+	    {
+	      __is >> __im_x >> __ch;
+	      if (__ch == ')') 
+		__x = complex<_Tp>(__re_x, __im_x);
+	      else
+		__is.setstate(ios_base::failbit);
+	    }
+	  else if (__ch == ')') 
+	    __x = __re_x;
+	  else
+	    __is.setstate(ios_base::failbit);
+	}
+      else 
+	{
+	  __is.putback(__ch);
+	  __is >> __re_x;
+	  __x = __re_x;
+	}
+      return __is;
+    }
+
+  ///  Insertion operator for complex values.
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
+    {
+      basic_ostringstream<_CharT, _Traits> __s;
+      __s.flags(__os.flags());
+      __s.imbue(__os.getloc());
+      __s.precision(__os.precision());
+      __s << '(' << __x.real() << ',' << __x.imag() << ')';
+      return __os << __s.str();
+    }
+
+  // Values
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    constexpr _Tp
+    real(const complex<_Tp>& __z)
+    { return __z.real(); }
+
+  template<typename _Tp>
+    constexpr _Tp
+    imag(const complex<_Tp>& __z)
+    { return __z.imag(); }
+#else
+  template<typename _Tp>
+    inline _Tp&
+    real(complex<_Tp>& __z)
+    { return __z.real(); }
+    
+  template<typename _Tp>
+    inline const _Tp&
+    real(const complex<_Tp>& __z)
+    { return __z.real(); }
+    
+  template<typename _Tp>
+    inline _Tp&
+    imag(complex<_Tp>& __z)
+    { return __z.imag(); }
+    
+  template<typename _Tp>
+    inline const _Tp&
+    imag(const complex<_Tp>& __z)
+    { return __z.imag(); }
+#endif
+
+  // 26.2.7/3 abs(__z):  Returns the magnitude of __z.
+  template<typename _Tp>
+    inline _Tp
+    __complex_abs(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+      const _Tp __s = std::max(abs(__x), abs(__y));
+      if (__s == _Tp())  // well ...
+        return __s;
+      __x /= __s; 
+      __y /= __s;
+      return __s * sqrt(__x * __x + __y * __y);
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline float
+  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
+
+  inline double
+  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
+
+  inline long double
+  __complex_abs(const __complex__ long double& __z)
+  { return __builtin_cabsl(__z); }
+
+  template<typename _Tp>
+    inline _Tp
+    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline _Tp
+    abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
+#endif  
+
+
+  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
+  template<typename _Tp>
+    inline _Tp
+    __complex_arg(const complex<_Tp>& __z)
+    { return  atan2(__z.imag(), __z.real()); }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline float
+  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
+
+  inline double
+  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
+
+  inline long double
+  __complex_arg(const __complex__ long double& __z)
+  { return __builtin_cargl(__z); }
+
+  template<typename _Tp>
+    inline _Tp
+    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline _Tp
+    arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
+#endif
+
+  // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
+  //     As defined, norm() is -not- a norm is the common mathematical
+  //     sens used in numerics.  The helper class _Norm_helper<> tries to
+  //     distinguish between builtin floating point and the rest, so as
+  //     to deliver an answer as close as possible to the real value.
+  template<bool>
+    struct _Norm_helper
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          const _Tp __x = __z.real();
+          const _Tp __y = __z.imag();
+          return __x * __x + __y * __y;
+        }
+    };
+
+  template<>
+    struct _Norm_helper<true>
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          _Tp __res = std::abs(__z);
+          return __res * __res;
+        }
+    };
+  
+  template<typename _Tp>
+    inline _Tp
+    norm(const complex<_Tp>& __z)
+    {
+      return _Norm_helper<__is_floating<_Tp>::__value 
+	&& !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    polar(const _Tp& __rho, const _Tp& __theta)
+    { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    conj(const complex<_Tp>& __z)
+    { return complex<_Tp>(__z.real(), -__z.imag()); }
+  
+  // Transcendentals
+
+  // 26.2.8/1 cos(__z):  Returns the cosine of __z.
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cos(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
+
+  inline __complex__ double
+  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
+
+  inline __complex__ long double
+  __complex_cos(const __complex__ long double& __z)
+  { return __builtin_ccosl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
+#endif
+
+  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cosh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
+
+  inline __complex__ double
+  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
+
+  inline __complex__ long double
+  __complex_cosh(const __complex__ long double& __z)
+  { return __builtin_ccoshl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
+#endif
+
+  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_exp(const complex<_Tp>& __z)
+    { return std::polar(exp(__z.real()), __z.imag()); }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
+
+  inline __complex__ double
+  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
+
+  inline __complex__ long double
+  __complex_exp(const __complex__ long double& __z)
+  { return __builtin_cexpl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
+#endif
+
+  // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
+  //                    The branch cut is along the negative axis.
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_log(const complex<_Tp>& __z)
+    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
+
+  inline __complex__ double
+  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
+
+  inline __complex__ long double
+  __complex_log(const __complex__ long double& __z)
+  { return __builtin_clogl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    log(const complex<_Tp>& __z) { return __complex_log(__z); }
+#endif
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    log10(const complex<_Tp>& __z)
+    { return std::log(__z) / log(_Tp(10.0)); }
+
+  // 26.2.8/10 sin(__z): Returns the sine of __z.
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sin(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); 
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
+
+  inline __complex__ double
+  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
+
+  inline __complex__ long double
+  __complex_sin(const __complex__ long double& __z)
+  { return __builtin_csinl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
+#endif
+
+  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sinh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp  __y = __z.imag();
+      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }      
+
+  inline __complex__ double
+  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }      
+
+  inline __complex__ long double
+  __complex_sinh(const __complex__ long double& __z)
+  { return __builtin_csinhl(__z); }      
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
+#endif
+
+  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
+  //                     The branch cut is on the negative axis.
+  template<typename _Tp>
+    complex<_Tp>
+    __complex_sqrt(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+
+      if (__x == _Tp())
+        {
+          _Tp __t = sqrt(abs(__y) / 2);
+          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
+        }
+      else
+        {
+          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
+          _Tp __u = __t / 2;
+          return __x > _Tp()
+            ? complex<_Tp>(__u, __y / __t)
+            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
+        }
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
+
+  inline __complex__ double
+  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
+
+  inline __complex__ long double
+  __complex_sqrt(const __complex__ long double& __z)
+  { return __builtin_csqrtl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
+#endif
+
+  // 26.2.8/14 tan(__z):  Return the complex tangent of __z.
+  
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tan(const complex<_Tp>& __z)
+    { return std::sin(__z) / std::cos(__z); }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
+
+  inline __complex__ double
+  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
+
+  inline __complex__ long double
+  __complex_tan(const __complex__ long double& __z)
+  { return __builtin_ctanl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
+#endif
+
+
+  // 26.2.8/15 tanh(__z):  Returns the hyperbolic tangent of __z.
+  
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tanh(const complex<_Tp>& __z)
+    { return std::sinh(__z) / std::cosh(__z); }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
+
+  inline __complex__ double
+  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
+
+  inline __complex__ long double
+  __complex_tanh(const __complex__ long double& __z)
+  { return __builtin_ctanhl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
+#endif
+
+
+  // 26.2.8/9  pow(__x, __y): Returns the complex power base of __x
+  //                          raised to the __y-th power.  The branch
+  //                          cut is on the negative axis.
+  template<typename _Tp>
+    complex<_Tp>
+    __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
+    {
+      complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
+
+      while (__n >>= 1)
+        {
+          __x *= __x;
+          if (__n % 2)
+            __y *= __x;
+        }
+
+      return __y;
+    }
+
+  // In C++11 mode we used to implement the resolution of
+  // DR 844. complex pow return type is ambiguous.
+  // thus the following overload was disabled in that mode.  However, doing
+  // that causes all sorts of issues, see, for example:
+  //   http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
+  // and also PR57974.
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __z, int __n)
+    {
+      return __n < 0
+	? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
+        : std::__complex_pow_unsigned(__z, __n);
+    }
+
+  template<typename _Tp>
+    complex<_Tp>
+    pow(const complex<_Tp>& __x, const _Tp& __y)
+    {
+#ifndef _GLIBCXX_USE_C99_COMPLEX
+      if (__x == _Tp())
+	return _Tp();
+#endif
+      if (__x.imag() == _Tp() && __x.real() > _Tp())
+        return pow(__x.real(), __y);
+
+      complex<_Tp> __t = std::log(__x);
+      return std::polar(exp(__y * __t.real()), __y * __t.imag());
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_pow(__complex__ float __x, __complex__ float __y)
+  { return __builtin_cpowf(__x, __y); }
+
+  inline __complex__ double
+  __complex_pow(__complex__ double __x, __complex__ double __y)
+  { return __builtin_cpow(__x, __y); }
+
+  inline __complex__ long double
+  __complex_pow(const __complex__ long double& __x,
+		const __complex__ long double& __y)
+  { return __builtin_cpowl(__x, __y); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __complex_pow(__x.__rep(), __y.__rep()); }
+#else
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __complex_pow(__x, __y); }
+#endif
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      return __x > _Tp() ? std::polar(pow(__x, __y.real()),
+				      __y.imag() * log(__x))
+	                 : std::pow(complex<_Tp>(__x), __y);
+    }
+
+  /// 26.2.3  complex specializations
+  /// complex<float> specialization
+  template<>
+    struct complex<float>
+    {
+      typedef float value_type;
+      typedef __complex__ float _ComplexT;
+
+      _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
+
+      _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
+#if __cplusplus >= 201103L
+      : _M_value{ __r, __i } { }
+#else
+      {
+	__real__ _M_value = __r;
+	__imag__ _M_value = __i;
+      }
+#endif
+
+      explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
+      explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);	
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr float 
+      real() const { return __real__ _M_value; }
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr float 
+      imag() const { return __imag__ _M_value; }
+#else
+      float& 
+      real() { return __real__ _M_value; }
+
+      const float& 
+      real() const { return __real__ _M_value; }      
+
+      float& 
+      imag() { return __imag__ _M_value; }
+
+      const float& 
+      imag() const { return __imag__ _M_value; }
+#endif
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      void 
+      real(float __val) { __real__ _M_value = __val; }
+
+      void 
+      imag(float __val) { __imag__ _M_value = __val; }
+
+      complex&
+      operator=(float __f)
+      {
+	_M_value = __f;
+	return *this;
+      }
+
+      complex&
+      operator+=(float __f)
+      {
+	_M_value += __f;
+	return *this;
+      }
+
+      complex&
+      operator-=(float __f)
+      {
+	_M_value -= __f;
+	return *this;
+      }
+
+      complex&
+      operator*=(float __f)
+      {
+	_M_value *= __f;
+	return *this;
+      }
+
+      complex&
+      operator/=(float __f)
+      {
+	_M_value /= __f;
+	return *this;
+      }
+
+      // Let the compiler synthesize the copy and assignment
+      // operator.  It always does a pretty good job.
+      // complex& operator=(const complex&);
+
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>&  __z)
+	{
+	  __real__ _M_value = __z.real();
+	  __imag__ _M_value = __z.imag();
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+        operator+=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value += __z.real();
+	  __imag__ _M_value += __z.imag();
+	  return *this;
+	}
+
+      template<class _Tp>
+        complex&
+        operator-=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value -= __z.real();
+	  __imag__ _M_value -= __z.imag();
+	  return *this;
+	}
+
+      template<class _Tp>
+        complex&
+        operator*=(const complex<_Tp>& __z)
+	{
+	  _ComplexT __t;
+	  __real__ __t = __z.real();
+	  __imag__ __t = __z.imag();
+	  _M_value *= __t;
+	  return *this;
+	}
+
+      template<class _Tp>
+        complex&
+        operator/=(const complex<_Tp>& __z)
+	{
+	  _ComplexT __t;
+	  __real__ __t = __z.real();
+	  __imag__ __t = __z.imag();
+	  _M_value /= __t;
+	  return *this;
+	}
+
+      _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
+
+    private:
+      _ComplexT _M_value;
+    };
+
+  /// 26.2.3  complex specializations
+  /// complex<double> specialization
+  template<>
+    struct complex<double>
+    {
+      typedef double value_type;
+      typedef __complex__ double _ComplexT;
+
+      _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
+
+      _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
+#if __cplusplus >= 201103L
+      : _M_value{ __r, __i } { }
+#else
+      {
+	__real__ _M_value = __r;
+	__imag__ _M_value = __i;
+      }
+#endif
+
+      _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+
+      explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);	
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr double 
+      real() const { return __real__ _M_value; }
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr double 
+      imag() const { return __imag__ _M_value; }
+#else
+      double& 
+      real() { return __real__ _M_value; }
+
+      const double& 
+      real() const { return __real__ _M_value; }
+
+      double& 
+      imag() { return __imag__ _M_value; }
+
+      const double& 
+      imag() const { return __imag__ _M_value; }
+#endif
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      void 
+      real(double __val) { __real__ _M_value = __val; }
+
+      void 
+      imag(double __val) { __imag__ _M_value = __val; }
+
+      complex&
+      operator=(double __d)
+      {
+	_M_value = __d;
+	return *this;
+      }
+
+      complex&
+      operator+=(double __d)
+      {
+	_M_value += __d;
+	return *this;
+      }
+	
+      complex&
+      operator-=(double __d)
+      {
+	_M_value -= __d;
+	return *this;
+      }
+
+      complex&
+      operator*=(double __d)
+      {
+	_M_value *= __d;
+	return *this;
+      }
+
+      complex&
+      operator/=(double __d)
+      {
+	_M_value /= __d;
+	return *this;
+      }
+
+      // The compiler will synthesize this, efficiently.
+      // complex& operator=(const complex&);
+
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value = __z.real();
+	  __imag__ _M_value = __z.imag();
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+        operator+=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value += __z.real();
+	  __imag__ _M_value += __z.imag();
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+        operator-=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value -= __z.real();
+	  __imag__ _M_value -= __z.imag();
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+        operator*=(const complex<_Tp>& __z)
+	{
+	  _ComplexT __t;
+	  __real__ __t = __z.real();
+	  __imag__ __t = __z.imag();
+	  _M_value *= __t;
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+        operator/=(const complex<_Tp>& __z)
+	{
+	  _ComplexT __t;
+	  __real__ __t = __z.real();
+	  __imag__ __t = __z.imag();
+	  _M_value /= __t;
+	  return *this;
+	}
+
+      _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
+
+    private:
+      _ComplexT _M_value;
+    };
+
+  /// 26.2.3  complex specializations
+  /// complex<long double> specialization
+  template<>
+    struct complex<long double>
+    {
+      typedef long double value_type;
+      typedef __complex__ long double _ComplexT;
+
+      _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
+
+      _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L, 
+				 long double __i = 0.0L)
+#if __cplusplus >= 201103L
+      : _M_value{ __r, __i } { }
+#else
+      {
+	__real__ _M_value = __r;
+	__imag__ _M_value = __i;
+      }
+#endif
+
+      _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+
+      _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
+      : _M_value(__z.__rep()) { }
+
+#if __cplusplus >= 201103L
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr long double 
+      real() const { return __real__ _M_value; }
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr long double 
+      imag() const { return __imag__ _M_value; }
+#else
+      long double& 
+      real() { return __real__ _M_value; }
+
+      const long double& 
+      real() const { return __real__ _M_value; }
+
+      long double& 
+      imag() { return __imag__ _M_value; }
+
+      const long double& 
+      imag() const { return __imag__ _M_value; }
+#endif
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 387. std::complex over-encapsulated.
+      void 
+      real(long double __val) { __real__ _M_value = __val; }
+
+      void 
+      imag(long double __val) { __imag__ _M_value = __val; }
+
+      complex&
+      operator=(long double __r)
+      {
+	_M_value = __r;
+	return *this;
+      }
+
+      complex&
+      operator+=(long double __r)
+      {
+	_M_value += __r;
+	return *this;
+      }
+
+      complex&
+      operator-=(long double __r)
+      {
+	_M_value -= __r;
+	return *this;
+      }
+
+      complex&
+      operator*=(long double __r)
+      {
+	_M_value *= __r;
+	return *this;
+      }
+
+      complex&
+      operator/=(long double __r)
+      {
+	_M_value /= __r;
+	return *this;
+      }
+
+      // The compiler knows how to do this efficiently
+      // complex& operator=(const complex&);
+
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value = __z.real();
+	  __imag__ _M_value = __z.imag();
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+	operator+=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value += __z.real();
+	  __imag__ _M_value += __z.imag();
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+	operator-=(const complex<_Tp>& __z)
+	{
+	  __real__ _M_value -= __z.real();
+	  __imag__ _M_value -= __z.imag();
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+	operator*=(const complex<_Tp>& __z)
+	{
+	  _ComplexT __t;
+	  __real__ __t = __z.real();
+	  __imag__ __t = __z.imag();
+	  _M_value *= __t;
+	  return *this;
+	}
+
+      template<typename _Tp>
+        complex&
+	operator/=(const complex<_Tp>& __z)
+	{
+	  _ComplexT __t;
+	  __real__ __t = __z.real();
+	  __imag__ __t = __z.imag();
+	  _M_value /= __t;
+	  return *this;
+	}
+
+      _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
+
+    private:
+      _ComplexT _M_value;
+    };
+
+  // These bits have to be at the end of this file, so that the
+  // specializations have all been defined.
+  inline _GLIBCXX_CONSTEXPR
+  complex<float>::complex(const complex<double>& __z)
+  : _M_value(__z.__rep()) { }
+
+  inline _GLIBCXX_CONSTEXPR
+  complex<float>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+
+  inline _GLIBCXX_CONSTEXPR
+  complex<double>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+  // NB:  This syntax is a GNU extension.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template istream& operator>>(istream&, complex<float>&);
+  extern template ostream& operator<<(ostream&, const complex<float>&);
+  extern template istream& operator>>(istream&, complex<double>&);
+  extern template ostream& operator<<(ostream&, const complex<double>&);
+  extern template istream& operator>>(istream&, complex<long double>&);
+  extern template ostream& operator<<(ostream&, const complex<long double>&);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template wistream& operator>>(wistream&, complex<float>&);
+  extern template wostream& operator<<(wostream&, const complex<float>&);
+  extern template wistream& operator>>(wistream&, complex<double>&);
+  extern template wostream& operator<<(wostream&, const complex<double>&);
+  extern template wistream& operator>>(wistream&, complex<long double>&);
+  extern template wostream& operator<<(wostream&, const complex<long double>&);
+#endif
+#endif
+
+  // @} group complex_numbers
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // See ext/type_traits.h for the primary template.
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, _Up>
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2<_Tp, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+  
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#if __cplusplus >= 201103L
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Forward declarations.
+  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
+
+  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
+  // DR 595.
+  template<typename _Tp> _Tp               fabs(const std::complex<_Tp>&);
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_acos(const std::complex<_Tp>& __z)
+    {
+      const std::complex<_Tp> __t = std::asin(__z);
+      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
+      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_acos(__complex__ float __z)
+  { return __builtin_cacosf(__z); }
+
+  inline __complex__ double
+  __complex_acos(__complex__ double __z)
+  { return __builtin_cacos(__z); }
+
+  inline __complex__ long double
+  __complex_acos(const __complex__ long double& __z)
+  { return __builtin_cacosl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acos(const std::complex<_Tp>& __z)
+    { return __complex_acos(__z.__rep()); }
+#else
+  /// acos(__z) [8.1.2].
+  //  Effects:  Behaves the same as C99 function cacos, defined
+  //            in subclause 7.3.5.1.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acos(const std::complex<_Tp>& __z)
+    { return __complex_acos(__z); }
+#endif
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_asin(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t(-__z.imag(), __z.real());
+      __t = std::asinh(__t);
+      return std::complex<_Tp>(__t.imag(), -__t.real());
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_asin(__complex__ float __z)
+  { return __builtin_casinf(__z); }
+
+  inline __complex__ double
+  __complex_asin(__complex__ double __z)
+  { return __builtin_casin(__z); }
+
+  inline __complex__ long double
+  __complex_asin(const __complex__ long double& __z)
+  { return __builtin_casinl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asin(const std::complex<_Tp>& __z)
+    { return __complex_asin(__z.__rep()); }
+#else
+  /// asin(__z) [8.1.3].
+  //  Effects:  Behaves the same as C99 function casin, defined
+  //            in subclause 7.3.5.2.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asin(const std::complex<_Tp>& __z)
+    { return __complex_asin(__z); }
+#endif
+  
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atan(const std::complex<_Tp>& __z)
+    {
+      const _Tp __r2 = __z.real() * __z.real();
+      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
+
+      _Tp __num = __z.imag() + _Tp(1.0);
+      _Tp __den = __z.imag() - _Tp(1.0);
+
+      __num = __r2 + __num * __num;
+      __den = __r2 + __den * __den;
+
+      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
+			       _Tp(0.25) * log(__num / __den));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_atan(__complex__ float __z)
+  { return __builtin_catanf(__z); }
+
+  inline __complex__ double
+  __complex_atan(__complex__ double __z)
+  { return __builtin_catan(__z); }
+
+  inline __complex__ long double
+  __complex_atan(const __complex__ long double& __z)
+  { return __builtin_catanl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atan(const std::complex<_Tp>& __z)
+    { return __complex_atan(__z.__rep()); }
+#else
+  /// atan(__z) [8.1.4].
+  //  Effects:  Behaves the same as C99 function catan, defined
+  //            in subclause 7.3.5.3.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atan(const std::complex<_Tp>& __z)
+    { return __complex_atan(__z); }
+#endif
+
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_acosh(const std::complex<_Tp>& __z)
+    {
+      // Kahan's formula.
+      return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
+				 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_acosh(__complex__ float __z)
+  { return __builtin_cacoshf(__z); }
+
+  inline __complex__ double
+  __complex_acosh(__complex__ double __z)
+  { return __builtin_cacosh(__z); }
+
+  inline __complex__ long double
+  __complex_acosh(const __complex__ long double& __z)
+  { return __builtin_cacoshl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acosh(const std::complex<_Tp>& __z)
+    { return __complex_acosh(__z.__rep()); }
+#else
+  /// acosh(__z) [8.1.5].
+  //  Effects:  Behaves the same as C99 function cacosh, defined
+  //            in subclause 7.3.6.1.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acosh(const std::complex<_Tp>& __z)
+    { return __complex_acosh(__z); }
+#endif
+
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_asinh(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t((__z.real() - __z.imag())
+			    * (__z.real() + __z.imag()) + _Tp(1.0),
+			    _Tp(2.0) * __z.real() * __z.imag());
+      __t = std::sqrt(__t);
+
+      return std::log(__t + __z);
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_asinh(__complex__ float __z)
+  { return __builtin_casinhf(__z); }
+
+  inline __complex__ double
+  __complex_asinh(__complex__ double __z)
+  { return __builtin_casinh(__z); }
+
+  inline __complex__ long double
+  __complex_asinh(const __complex__ long double& __z)
+  { return __builtin_casinhl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asinh(const std::complex<_Tp>& __z)
+    { return __complex_asinh(__z.__rep()); }
+#else
+  /// asinh(__z) [8.1.6].
+  //  Effects:  Behaves the same as C99 function casin, defined
+  //            in subclause 7.3.6.2.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asinh(const std::complex<_Tp>& __z)
+    { return __complex_asinh(__z); }
+#endif
+
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atanh(const std::complex<_Tp>& __z)
+    {
+      const _Tp __i2 = __z.imag() * __z.imag();
+      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
+
+      _Tp __num = _Tp(1.0) + __z.real();
+      _Tp __den = _Tp(1.0) - __z.real();
+
+      __num = __i2 + __num * __num;
+      __den = __i2 + __den * __den;
+
+      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
+			       _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_atanh(__complex__ float __z)
+  { return __builtin_catanhf(__z); }
+
+  inline __complex__ double
+  __complex_atanh(__complex__ double __z)
+  { return __builtin_catanh(__z); }
+
+  inline __complex__ long double
+  __complex_atanh(const __complex__ long double& __z)
+  { return __builtin_catanhl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atanh(const std::complex<_Tp>& __z)
+    { return __complex_atanh(__z.__rep()); }
+#else
+  /// atanh(__z) [8.1.7].
+  //  Effects:  Behaves the same as C99 function catanh, defined
+  //            in subclause 7.3.6.3.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atanh(const std::complex<_Tp>& __z)
+    { return __complex_atanh(__z); }
+#endif
+
+  template<typename _Tp>
+    inline _Tp
+    /// fabs(__z) [8.1.8].
+    //  Effects:  Behaves the same as C99 function cabs, defined
+    //            in subclause 7.3.8.1.
+    fabs(const std::complex<_Tp>& __z)
+    { return std::abs(__z); }
+
+  /// Additional overloads [8.1.9].
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    arg(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
+      return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
+	                       : __type();
+#else
+      return std::arg(std::complex<__type>(__x));
+#endif
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    imag(_Tp)
+    { return _Tp(); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    norm(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __type(__x) * __type(__x);
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    real(_Tp __x)
+    { return __x; }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const _Up& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x), __type(__y));
+    }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const _Tp& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(__type(__x), std::complex<__type>(__y));
+    }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x),
+		      std::complex<__type>(__y));
+    }
+
+  // Forward declarations.
+  // DR 781.
+  template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
+
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_proj(const std::complex<_Tp>& __z)
+    {
+      const _Tp __den = (__z.real() * __z.real()
+			 + __z.imag() * __z.imag() + _Tp(1.0));
+
+      return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
+			       (_Tp(2.0) * __z.imag()) / __den);
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX
+  inline __complex__ float
+  __complex_proj(__complex__ float __z)
+  { return __builtin_cprojf(__z); }
+
+  inline __complex__ double
+  __complex_proj(__complex__ double __z)
+  { return __builtin_cproj(__z); }
+
+  inline __complex__ long double
+  __complex_proj(const __complex__ long double& __z)
+  { return __builtin_cprojl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    proj(const std::complex<_Tp>& __z)
+    { return __complex_proj(__z.__rep()); }
+#else
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    proj(const std::complex<_Tp>& __z)
+    { return __complex_proj(__z); }
+#endif
+
+  // DR 1137.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    proj(_Tp __x)
+    { return __x; }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    conj(_Tp __x)
+    { return __x; }
+
+#if __cplusplus > 201103L
+
+inline namespace literals {
+inline namespace complex_literals {
+
+  constexpr std::complex<float>
+  operator""if(long double __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+
+  constexpr std::complex<float>
+  operator""if(unsigned long long __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+
+  constexpr std::complex<double>
+  operator""i(long double __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+
+  constexpr std::complex<double>
+  operator""i(unsigned long long __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+
+  constexpr std::complex<long double>
+  operator""il(long double __num)
+  { return std::complex<long double>{0.0L, __num}; }
+
+  constexpr std::complex<long double>
+  operator""il(unsigned long long __num)
+  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
+
+} // inline namespace complex_literals
+} // inline namespace literals
+
+#endif // C++14
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif  // C++11
+
+#endif  /* _GLIBCXX_COMPLEX */
diff --git a/gcc-4.9/libstdc++-v3/include/std/condition_variable b/gcc-4.9/libstdc++-v3/include/std/condition_variable
new file mode 100644
index 0000000..fc111dd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/condition_variable
@@ -0,0 +1,296 @@
+// <condition_variable> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/condition_variable
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_CONDITION_VARIABLE
+#define _GLIBCXX_CONDITION_VARIABLE 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <chrono>
+#include <mutex>
+#include <ext/concurrence.h>
+#include <bits/alloc_traits.h>
+#include <bits/allocator.h>
+#include <bits/unique_ptr.h>
+#include <bits/shared_ptr.h>
+
+#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup condition_variables Condition Variables
+   * @ingroup concurrency
+   *
+   * Classes for condition_variable support.
+   * @{
+   */
+
+  /// cv_status
+  enum class cv_status { no_timeout, timeout };
+  
+  /// condition_variable
+  class condition_variable
+  {
+    typedef chrono::system_clock	__clock_t;
+    typedef __gthread_cond_t		__native_type;
+
+#ifdef __GTHREAD_COND_INIT
+    __native_type			_M_cond = __GTHREAD_COND_INIT;
+#else
+    __native_type			_M_cond;
+#endif
+
+  public:
+    typedef __native_type* 		native_handle_type;
+
+    condition_variable() noexcept;
+    ~condition_variable() noexcept;
+
+    condition_variable(const condition_variable&) = delete;
+    condition_variable& operator=(const condition_variable&) = delete;
+
+    void
+    notify_one() noexcept;
+
+    void
+    notify_all() noexcept;
+
+    void
+    wait(unique_lock<mutex>& __lock);
+
+    template<typename _Predicate>
+      void
+      wait(unique_lock<mutex>& __lock, _Predicate __p)
+      {
+	while (!__p())
+	  wait(__lock);
+      }
+
+    template<typename _Duration>
+      cv_status
+      wait_until(unique_lock<mutex>& __lock,
+		 const chrono::time_point<__clock_t, _Duration>& __atime)
+      { return __wait_until_impl(__lock, __atime); }
+
+    template<typename _Clock, typename _Duration>
+      cv_status
+      wait_until(unique_lock<mutex>& __lock,
+		 const chrono::time_point<_Clock, _Duration>& __atime)
+      {
+	// DR 887 - Sync unknown clock to known clock.
+	const typename _Clock::time_point __c_entry = _Clock::now();
+	const __clock_t::time_point __s_entry = __clock_t::now();
+	const auto __delta = __atime - __c_entry;
+	const auto __s_atime = __s_entry + __delta;
+
+	return __wait_until_impl(__lock, __s_atime);
+      }
+
+    template<typename _Clock, typename _Duration, typename _Predicate>
+      bool
+      wait_until(unique_lock<mutex>& __lock,
+		 const chrono::time_point<_Clock, _Duration>& __atime,
+		 _Predicate __p)
+      {
+	while (!__p())
+	  if (wait_until(__lock, __atime) == cv_status::timeout)
+	    return __p();
+	return true;
+      }
+
+    template<typename _Rep, typename _Period>
+      cv_status
+      wait_for(unique_lock<mutex>& __lock,
+	       const chrono::duration<_Rep, _Period>& __rtime)
+      { return wait_until(__lock, __clock_t::now() + __rtime); }
+
+    template<typename _Rep, typename _Period, typename _Predicate>
+      bool
+      wait_for(unique_lock<mutex>& __lock,
+	       const chrono::duration<_Rep, _Period>& __rtime,
+	       _Predicate __p)
+      { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); }
+
+    native_handle_type
+    native_handle()
+    { return &_M_cond; }
+
+  private:
+    template<typename _Dur>
+      cv_status
+      __wait_until_impl(unique_lock<mutex>& __lock,
+			const chrono::time_point<__clock_t, _Dur>& __atime)
+      {
+	auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
+	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
+
+	__gthread_time_t __ts =
+	  {
+	    static_cast<std::time_t>(__s.time_since_epoch().count()),
+	    static_cast<long>(__ns.count())
+	  };
+
+	__gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(),
+				 &__ts);
+
+	return (__clock_t::now() < __atime
+		? cv_status::no_timeout : cv_status::timeout);
+      }
+  };
+
+  inline namespace _V2 {
+
+  /// condition_variable_any
+  // Like above, but mutex is not required to have try_lock.
+  class condition_variable_any
+  {
+    typedef chrono::system_clock	__clock_t;
+    condition_variable			_M_cond;
+    shared_ptr<mutex>			_M_mutex;
+
+    // scoped unlock - unlocks in ctor, re-locks in dtor
+    template<typename _Lock>
+      struct _Unlock
+      {
+	explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); }
+
+	~_Unlock() noexcept(false)
+	{
+	  if (uncaught_exception())
+	    __try { _M_lock.lock(); } __catch(...) { }
+	  else
+	    _M_lock.lock();
+	}
+
+	_Unlock(const _Unlock&) = delete;
+	_Unlock& operator=(const _Unlock&) = delete;
+
+	_Lock& _M_lock;
+      };
+
+  public:
+    condition_variable_any() : _M_mutex(std::make_shared<mutex>()) { }
+    ~condition_variable_any() = default;
+
+    condition_variable_any(const condition_variable_any&) = delete;
+    condition_variable_any& operator=(const condition_variable_any&) = delete;
+
+    void
+    notify_one() noexcept
+    {
+      lock_guard<mutex> __lock(*_M_mutex);
+      _M_cond.notify_one();
+    }
+
+    void
+    notify_all() noexcept
+    {
+      lock_guard<mutex> __lock(*_M_mutex);
+      _M_cond.notify_all();
+    }
+
+    template<typename _Lock>
+      void
+      wait(_Lock& __lock)
+      {
+	shared_ptr<mutex> __mutex = _M_mutex;
+	unique_lock<mutex> __my_lock(*__mutex);
+	_Unlock<_Lock> __unlock(__lock);
+	// *__mutex must be unlocked before re-locking __lock so move
+	// ownership of *__mutex lock to an object with shorter lifetime.
+	unique_lock<mutex> __my_lock2(std::move(__my_lock));
+	_M_cond.wait(__my_lock2);
+      }
+      
+
+    template<typename _Lock, typename _Predicate>
+      void
+      wait(_Lock& __lock, _Predicate __p)
+      {
+	while (!__p())
+	  wait(__lock);
+      }
+
+    template<typename _Lock, typename _Clock, typename _Duration>
+      cv_status
+      wait_until(_Lock& __lock,
+		 const chrono::time_point<_Clock, _Duration>& __atime)
+      {
+	shared_ptr<mutex> __mutex = _M_mutex;
+	unique_lock<mutex> __my_lock(*__mutex);
+	_Unlock<_Lock> __unlock(__lock);
+	// *__mutex must be unlocked before re-locking __lock so move
+	// ownership of *__mutex lock to an object with shorter lifetime.
+	unique_lock<mutex> __my_lock2(std::move(__my_lock));
+	return _M_cond.wait_until(__my_lock2, __atime);
+      }
+
+    template<typename _Lock, typename _Clock,
+	     typename _Duration, typename _Predicate>
+      bool
+      wait_until(_Lock& __lock,
+		 const chrono::time_point<_Clock, _Duration>& __atime,
+		 _Predicate __p)
+      {
+	while (!__p())
+	  if (wait_until(__lock, __atime) == cv_status::timeout)
+	    return __p();
+	return true;
+      }
+
+    template<typename _Lock, typename _Rep, typename _Period>
+      cv_status
+      wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime)
+      { return wait_until(__lock, __clock_t::now() + __rtime); }
+
+    template<typename _Lock, typename _Rep,
+	     typename _Period, typename _Predicate>
+      bool
+      wait_for(_Lock& __lock,
+	       const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p)
+      { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); }
+  };
+
+  } // end inline namespace
+
+  // @} group condition_variables
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_CONDITION_VARIABLE
diff --git a/gcc-4.9/libstdc++-v3/include/std/deque b/gcc-4.9/libstdc++-v3/include/std/deque
new file mode 100644
index 0000000..816c873
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/deque
@@ -0,0 +1,76 @@
+// <deque> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/deque
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_DEQUE
+#define _GLIBCXX_DEQUE 1
+
+#pragma GCC system_header
+
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/stl_construct.h>
+#include <bits/stl_uninitialized.h>
+#include <bits/stl_deque.h>
+#include <bits/range_access.h>
+#include <bits/deque.tcc>
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/deque>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/deque>
+#endif
+
+#endif /* _GLIBCXX_DEQUE */
diff --git a/gcc-4.9/libstdc++-v3/include/std/forward_list b/gcc-4.9/libstdc++-v3/include/std/forward_list
new file mode 100644
index 0000000..d0c1503
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/forward_list
@@ -0,0 +1,52 @@
+// <forward_list> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/forward_list
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_FORWARD_LIST
+#define _GLIBCXX_FORWARD_LIST 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <bits/forward_list.h>
+#include <bits/range_access.h>
+#include <bits/forward_list.tcc>
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/forward_list>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/forward_list>
+#endif
+
+#endif // C++11
+
+#endif // _GLIBCXX_FORWARD_LIST
diff --git a/gcc-4.9/libstdc++-v3/include/std/fstream b/gcc-4.9/libstdc++-v3/include/std/fstream
new file mode 100644
index 0000000..17ccac6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/fstream
@@ -0,0 +1,941 @@
+// File based streams -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/fstream
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.8  File-based streams
+//
+
+#ifndef _GLIBCXX_FSTREAM
+#define _GLIBCXX_FSTREAM 1
+
+#pragma GCC system_header
+
+#include <istream>
+#include <ostream>
+#include <bits/codecvt.h>
+#include <cstdio>             // For BUFSIZ
+#include <bits/basic_file.h>  // For __basic_file, __c_lock
+#if __cplusplus >= 201103L
+#include <string>             // For std::string overloads.
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // [27.8.1.1] template class basic_filebuf
+  /**
+   *  @brief  The actual work of input and output (for files).
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This class associates both its input and output sequence with an
+   *  external disk file, and maintains a joint file position for both
+   *  sequences.  Many of its semantics are described in terms of similar
+   *  behavior in the Standard C Library's @c FILE streams.
+   *
+   *  Requirements on traits_type, specific to this class:
+   *  - traits_type::pos_type must be fpos<traits_type::state_type>
+   *  - traits_type::off_type must be streamoff
+   *  - traits_type::state_type must be Assignable and DefaultConstructible,
+   *  - traits_type::state_type() must be the initial state for codecvt.
+   */
+  template<typename _CharT, typename _Traits>
+    class basic_filebuf : public basic_streambuf<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT                     	        char_type;
+      typedef _Traits                    	        traits_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      typedef basic_streambuf<char_type, traits_type>  	__streambuf_type;
+      typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
+      typedef __basic_file<char>		        __file_type;
+      typedef typename traits_type::state_type          __state_type;
+      typedef codecvt<char_type, char, __state_type>    __codecvt_type;
+
+      friend class ios_base; // For sync_with_stdio.
+
+    protected:
+      // Data Members:
+      // MT lock inherited from libio or other low-level io library.
+      __c_lock          	_M_lock;
+
+      // External buffer.
+      __file_type 		_M_file;
+
+      /// Place to stash in || out || in | out settings for current filebuf.
+      ios_base::openmode 	_M_mode;
+
+      // Beginning state type for codecvt.
+      __state_type 		_M_state_beg;
+
+      // During output, the state that corresponds to pptr(),
+      // during input, the state that corresponds to egptr() and
+      // _M_ext_next.
+      __state_type		_M_state_cur;
+
+      // Not used for output. During input, the state that corresponds
+      // to eback() and _M_ext_buf.
+      __state_type		_M_state_last;
+
+      /// Pointer to the beginning of internal buffer.
+      char_type*		_M_buf; 	
+
+      /**
+       *  Actual size of internal buffer. This number is equal to the size
+       *  of the put area + 1 position, reserved for the overflow char of
+       *  a full area.
+       */
+      size_t			_M_buf_size;
+
+      // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer.
+      bool			_M_buf_allocated;
+
+      /**
+       *  _M_reading == false && _M_writing == false for @b uncommitted mode;
+       *  _M_reading == true for @b read mode;
+       *  _M_writing == true for @b write mode;
+       *
+       *  NB: _M_reading == true && _M_writing == true is unused.
+       */
+      bool                      _M_reading;
+      bool                      _M_writing;
+
+      //@{
+      /**
+       *  Necessary bits for putback buffer management.
+       *
+       *  @note pbacks of over one character are not currently supported.
+       */
+      char_type			_M_pback;
+      char_type*		_M_pback_cur_save;
+      char_type*		_M_pback_end_save;
+      bool			_M_pback_init;
+      //@}
+
+      // Cached codecvt facet.
+      const __codecvt_type* 	_M_codecvt;
+
+      /**
+       *  Buffer for external characters. Used for input when
+       *  codecvt::always_noconv() == false. When valid, this corresponds
+       *  to eback().
+       */
+      char*			_M_ext_buf;
+
+      /**
+       *  Size of buffer held by _M_ext_buf.
+       */
+      streamsize		_M_ext_buf_size;
+
+      /**
+       *  Pointers into the buffer held by _M_ext_buf that delimit a
+       *  subsequence of bytes that have been read but not yet converted.
+       *  When valid, _M_ext_next corresponds to egptr().
+       */
+      const char*		_M_ext_next;
+      char*			_M_ext_end;
+
+      /**
+       *  Initializes pback buffers, and moves normal buffers to safety.
+       *  Assumptions:
+       *  _M_in_cur has already been moved back
+       */
+      void
+      _M_create_pback()
+      {
+	if (!_M_pback_init)
+	  {
+	    _M_pback_cur_save = this->gptr();
+	    _M_pback_end_save = this->egptr();
+	    this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
+	    _M_pback_init = true;
+	  }
+      }
+
+      /**
+       *  Deactivates pback buffer contents, and restores normal buffer.
+       *  Assumptions:
+       *  The pback buffer has only moved forward.
+       */
+      void
+      _M_destroy_pback() throw()
+      {
+	if (_M_pback_init)
+	  {
+	    // Length _M_in_cur moved in the pback buffer.
+	    _M_pback_cur_save += this->gptr() != this->eback();
+	    this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
+	    _M_pback_init = false;
+	  }
+      }
+
+    public:
+      // Constructors/destructor:
+      /**
+       *  @brief  Does not open any files.
+       *
+       *  The default constructor initializes the parent class using its
+       *  own default ctor.
+       */
+      basic_filebuf();
+
+      /**
+       *  @brief  The destructor closes the file first.
+       */
+      virtual
+      ~basic_filebuf()
+      { this->close(); }
+
+      // Members:
+      /**
+       *  @brief  Returns true if the external file is open.
+       */
+      bool
+      is_open() const throw()
+      { return _M_file.is_open(); }
+
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *  @return  @c this on success, NULL on failure
+       *
+       *  If a file is already open, this function immediately fails.
+       *  Otherwise it tries to open the file named @a __s using the flags
+       *  given in @a __mode.
+       *
+       *  Table 92, adapted here, gives the relation between openmode
+       *  combinations and the equivalent @c fopen() flags.
+       *  (NB: lines app, in|out|app, in|app, binary|app, binary|in|out|app,
+       *  and binary|in|app per DR 596)
+       *  <pre>
+       *  +---------------------------------------------------------+
+       *  | ios_base Flag combination            stdio equivalent   |
+       *  |binary  in  out  trunc  app                              |
+       *  +---------------------------------------------------------+
+       *  |             +                        w                  |
+       *  |             +           +            a                  |
+       *  |                         +            a                  |
+       *  |             +     +                  w                  |
+       *  |         +                            r                  |
+       *  |         +   +                        r+                 |
+       *  |         +   +     +                  w+                 |
+       *  |         +   +           +            a+                 |
+       *  |         +               +            a+                 |
+       *  +---------------------------------------------------------+
+       *  |   +         +                        wb                 |
+       *  |   +         +           +            ab                 |
+       *  |   +                     +            ab                 |
+       *  |   +         +     +                  wb                 |
+       *  |   +     +                            rb                 |
+       *  |   +     +   +                        r+b                |
+       *  |   +     +   +     +                  w+b                |
+       *  |   +     +   +           +            a+b                |
+       *  |   +     +               +            a+b                |
+       *  +---------------------------------------------------------+
+       *  </pre>
+       */
+      __filebuf_type*
+      open(const char* __s, ios_base::openmode __mode);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *  @return  @c this on success, NULL on failure
+       */
+      __filebuf_type*
+      open(const std::string& __s, ios_base::openmode __mode)
+      { return open(__s.c_str(), __mode); }
+#endif
+
+      /**
+       *  @brief  Closes the currently associated file.
+       *  @return  @c this on success, NULL on failure
+       *
+       *  If no file is currently open, this function immediately fails.
+       *
+       *  If a <em>put buffer area</em> exists, @c overflow(eof) is
+       *  called to flush all the characters.  The file is then
+       *  closed.
+       *
+       *  If any operations fail, this function also fails.
+       */
+      __filebuf_type*
+      close();
+
+    protected:
+      void
+      _M_allocate_internal_buffer();
+
+      void
+      _M_destroy_internal_buffer() throw();
+
+      // [27.8.1.4] overridden virtual functions
+      virtual streamsize
+      showmanyc();
+
+      // Stroustrup, 1998, p. 628
+      // underflow() and uflow() functions are called to get the next
+      // character from the real input source when the buffer is empty.
+      // Buffered input uses underflow()
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = _Traits::eof());
+
+      // Stroustrup, 1998, p 648
+      // The overflow() function is called to transfer characters to the
+      // real output destination when the buffer is full. A call to
+      // overflow(c) outputs the contents of the buffer plus the
+      // character c.
+      // 27.5.2.4.5
+      // Consume some sequence of the characters in the pending sequence.
+      virtual int_type
+      overflow(int_type __c = _Traits::eof());
+
+      // Convert internal byte sequence to external, char-based
+      // sequence via codecvt.
+      bool
+      _M_convert_to_external(char_type*, streamsize);
+
+      /**
+       *  @brief  Manipulates the buffer.
+       *  @param  __s  Pointer to a buffer area.
+       *  @param  __n  Size of @a __s.
+       *  @return  @c this
+       *
+       *  If no file has been opened, and both @a __s and @a __n are zero, then
+       *  the stream becomes unbuffered.  Otherwise, @c __s is used as a
+       *  buffer; see
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
+       *  for more.
+       */
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n);
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+	      ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __pos,
+	      ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      // Common code for seekoff, seekpos, and overflow
+      pos_type
+      _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
+      
+      int
+      _M_get_ext_pos(__state_type &__state);
+
+      virtual int
+      sync();
+
+      virtual void
+      imbue(const locale& __loc);
+
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+
+      // Flushes output buffer, then writes unshift sequence.
+      bool
+      _M_terminate_output();
+
+      /**
+       *  This function sets the pointers of the internal buffer, both get
+       *  and put areas. Typically:
+       *
+       *   __off == egptr() - eback() upon underflow/uflow (@b read mode);
+       *   __off == 0 upon overflow (@b write mode);
+       *   __off == -1 upon open, setbuf, seekoff/pos (@b uncommitted mode).
+       *
+       *  NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size
+       *  reflects the actual allocated memory and the last cell is reserved
+       *  for the overflow char of a full put area.
+       */
+      void
+      _M_set_buffer(streamsize __off)
+      {
+	const bool __testin = _M_mode & ios_base::in;
+	const bool __testout = (_M_mode & ios_base::out
+				|| _M_mode & ios_base::app);
+
+	if (__testin && __off > 0)
+	  this->setg(_M_buf, _M_buf, _M_buf + __off);
+	else
+	  this->setg(_M_buf, _M_buf, _M_buf);
+
+	if (__testout && __off == 0 && _M_buf_size > 1 )
+	  this->setp(_M_buf, _M_buf + _M_buf_size - 1);
+	else
+	  this->setp(0, 0);
+      }
+    };
+
+  // [27.8.1.5] Template class basic_ifstream
+  /**
+   *  @brief  Controlling input for files.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This class supports reading from named files, using the inherited
+   *  functions from std::basic_istream.  To control the associated
+   *  sequence, an instance of std::basic_filebuf is used, which this page
+   *  refers to as @c sb.
+   */
+  template<typename _CharT, typename _Traits>
+    class basic_ifstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      // Non-standard types:
+      typedef basic_filebuf<char_type, traits_type> 	__filebuf_type;
+      typedef basic_istream<char_type, traits_type>	__istream_type;
+
+    private:
+      __filebuf_type	_M_filebuf;
+
+    public:
+      // Constructors/Destructors:
+      /**
+       *  @brief  Default constructor.
+       *
+       *  Initializes @c sb using its default constructor, and passes
+       *  @c &sb to the base class initializer.  Does not open any files
+       *  (you haven't given it a filename to open).
+       */
+      basic_ifstream() : __istream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+
+      /**
+       *  @brief  Create an input file stream.
+       *  @param  __s  Null terminated string specifying the filename.
+       *  @param  __mode  Open file in specified mode (see std::ios_base).
+       *
+       *  @c ios_base::in is automatically included in @a __mode.
+       *
+       *  Tip:  When using std::string to hold the filename, you must use
+       *  .c_str() before passing it to this constructor.
+       */
+      explicit
+      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_filebuf()
+      {
+	this->init(&_M_filebuf);
+	this->open(__s, __mode);
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Create an input file stream.
+       *  @param  __s  std::string specifying the filename.
+       *  @param  __mode  Open file in specified mode (see std::ios_base).
+       *
+       *  @c ios_base::in is automatically included in @a __mode.
+       */
+      explicit
+      basic_ifstream(const std::string& __s,
+		     ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_filebuf()
+      {
+	this->init(&_M_filebuf);
+	this->open(__s, __mode);
+      }
+#endif
+
+      /**
+       *  @brief  The destructor does nothing.
+       *
+       *  The file is closed by the filebuf object, not the formatting
+       *  stream.
+       */
+      ~basic_ifstream()
+      { }
+
+      // Members:
+      /**
+       *  @brief  Accessing the underlying buffer.
+       *  @return  The current basic_filebuf buffer.
+       *
+       *  This hides both signatures of std::basic_ios::rdbuf().
+       */
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+      /**
+       *  @brief  Wrapper to test for an open file.
+       *  @return  @c rdbuf()->is_open()
+       */
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 365. Lack of const-qualification in clause 27
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *
+       *  Calls @c std::basic_filebuf::open(s,__mode|in).  If that function
+       *  fails, @c failbit is set in the stream's error state.
+       *
+       *  Tip:  When using std::string to hold the filename, you must use
+       *  .c_str() before passing it to this constructor.
+       */
+      void
+      open(const char* __s, ios_base::openmode __mode = ios_base::in)
+      {
+	if (!_M_filebuf.open(__s, __mode | ios_base::in))
+	  this->setstate(ios_base::failbit);
+	else
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 409. Closing an fstream should clear error state
+	  this->clear();
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *
+       *  Calls @c std::basic_filebuf::open(__s,__mode|in).  If that function
+       *  fails, @c failbit is set in the stream's error state.
+       */
+      void
+      open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
+      {
+	if (!_M_filebuf.open(__s, __mode | ios_base::in))
+	  this->setstate(ios_base::failbit);
+	else
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 409. Closing an fstream should clear error state
+	  this->clear();
+      }
+#endif
+
+      /**
+       *  @brief  Close the file.
+       *
+       *  Calls @c std::basic_filebuf::close().  If that function
+       *  fails, @c failbit is set in the stream's error state.
+       */
+      void
+      close()
+      {
+	if (!_M_filebuf.close())
+	  this->setstate(ios_base::failbit);
+      }
+    };
+
+
+  // [27.8.1.8] Template class basic_ofstream
+  /**
+   *  @brief  Controlling output for files.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This class supports reading from named files, using the inherited
+   *  functions from std::basic_ostream.  To control the associated
+   *  sequence, an instance of std::basic_filebuf is used, which this page
+   *  refers to as @c sb.
+   */
+  template<typename _CharT, typename _Traits>
+    class basic_ofstream : public basic_ostream<_CharT,_Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      // Non-standard types:
+      typedef basic_filebuf<char_type, traits_type> 	__filebuf_type;
+      typedef basic_ostream<char_type, traits_type>	__ostream_type;
+
+    private:
+      __filebuf_type	_M_filebuf;
+
+    public:
+      // Constructors:
+      /**
+       *  @brief  Default constructor.
+       *
+       *  Initializes @c sb using its default constructor, and passes
+       *  @c &sb to the base class initializer.  Does not open any files
+       *  (you haven't given it a filename to open).
+       */
+      basic_ofstream(): __ostream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+
+      /**
+       *  @brief  Create an output file stream.
+       *  @param  __s  Null terminated string specifying the filename.
+       *  @param  __mode  Open file in specified mode (see std::ios_base).
+       *
+       *  @c ios_base::out | @c ios_base::trunc is automatically included in
+       *  @a __mode.
+       *
+       *  Tip:  When using std::string to hold the filename, you must use
+       *  .c_str() before passing it to this constructor.
+       */
+      explicit
+      basic_ofstream(const char* __s,
+		     ios_base::openmode __mode = ios_base::out|ios_base::trunc)
+      : __ostream_type(), _M_filebuf()
+      {
+	this->init(&_M_filebuf);
+	this->open(__s, __mode);
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Create an output file stream.
+       *  @param  __s  std::string specifying the filename.
+       *  @param  __mode  Open file in specified mode (see std::ios_base).
+       *
+       *  @c ios_base::out | @c ios_base::trunc is automatically included in
+       *  @a __mode.
+       */
+      explicit
+      basic_ofstream(const std::string& __s,
+		     ios_base::openmode __mode = ios_base::out|ios_base::trunc)
+      : __ostream_type(), _M_filebuf()
+      {
+	this->init(&_M_filebuf);
+	this->open(__s, __mode);
+      }
+#endif
+
+      /**
+       *  @brief  The destructor does nothing.
+       *
+       *  The file is closed by the filebuf object, not the formatting
+       *  stream.
+       */
+      ~basic_ofstream()
+      { }
+
+      // Members:
+      /**
+       *  @brief  Accessing the underlying buffer.
+       *  @return  The current basic_filebuf buffer.
+       *
+       *  This hides both signatures of std::basic_ios::rdbuf().
+       */
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+      /**
+       *  @brief  Wrapper to test for an open file.
+       *  @return  @c rdbuf()->is_open()
+       */
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 365. Lack of const-qualification in clause 27
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *
+       *  Calls @c std::basic_filebuf::open(__s,__mode|out|trunc).  If that
+       *  function fails, @c failbit is set in the stream's error state.
+       *
+       *  Tip:  When using std::string to hold the filename, you must use
+       *  .c_str() before passing it to this constructor.
+       */
+      void
+      open(const char* __s,
+	   ios_base::openmode __mode = ios_base::out | ios_base::trunc)
+      {
+	if (!_M_filebuf.open(__s, __mode | ios_base::out))
+	  this->setstate(ios_base::failbit);
+	else
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 409. Closing an fstream should clear error state
+	  this->clear();
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *
+       *  Calls @c std::basic_filebuf::open(s,mode|out|trunc).  If that
+       *  function fails, @c failbit is set in the stream's error state.
+       */
+      void
+      open(const std::string& __s,
+	   ios_base::openmode __mode = ios_base::out | ios_base::trunc)
+      {
+	if (!_M_filebuf.open(__s, __mode | ios_base::out))
+	  this->setstate(ios_base::failbit);
+	else
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 409. Closing an fstream should clear error state
+	  this->clear();
+      }
+#endif
+
+      /**
+       *  @brief  Close the file.
+       *
+       *  Calls @c std::basic_filebuf::close().  If that function
+       *  fails, @c failbit is set in the stream's error state.
+       */
+      void
+      close()
+      {
+	if (!_M_filebuf.close())
+	  this->setstate(ios_base::failbit);
+      }
+    };
+
+
+  // [27.8.1.11] Template class basic_fstream
+  /**
+   *  @brief  Controlling input and output for files.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This class supports reading from and writing to named files, using
+   *  the inherited functions from std::basic_iostream.  To control the
+   *  associated sequence, an instance of std::basic_filebuf is used, which
+   *  this page refers to as @c sb.
+   */
+  template<typename _CharT, typename _Traits>
+    class basic_fstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      // Non-standard types:
+      typedef basic_filebuf<char_type, traits_type> 	__filebuf_type;
+      typedef basic_ios<char_type, traits_type>		__ios_type;
+      typedef basic_iostream<char_type, traits_type>	__iostream_type;
+
+    private:
+      __filebuf_type	_M_filebuf;
+
+    public:
+      // Constructors/destructor:
+      /**
+       *  @brief  Default constructor.
+       *
+       *  Initializes @c sb using its default constructor, and passes
+       *  @c &sb to the base class initializer.  Does not open any files
+       *  (you haven't given it a filename to open).
+       */
+      basic_fstream()
+      : __iostream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+
+      /**
+       *  @brief  Create an input/output file stream.
+       *  @param  __s  Null terminated string specifying the filename.
+       *  @param  __mode  Open file in specified mode (see std::ios_base).
+       *
+       *  Tip:  When using std::string to hold the filename, you must use
+       *  .c_str() before passing it to this constructor.
+       */
+      explicit
+      basic_fstream(const char* __s,
+		    ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __iostream_type(0), _M_filebuf()
+      {
+	this->init(&_M_filebuf);
+	this->open(__s, __mode);
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Create an input/output file stream.
+       *  @param  __s  Null terminated string specifying the filename.
+       *  @param  __mode  Open file in specified mode (see std::ios_base).
+       */
+      explicit
+      basic_fstream(const std::string& __s,
+		    ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __iostream_type(0), _M_filebuf()
+      {
+	this->init(&_M_filebuf);
+	this->open(__s, __mode);
+      }
+#endif
+
+      /**
+       *  @brief  The destructor does nothing.
+       *
+       *  The file is closed by the filebuf object, not the formatting
+       *  stream.
+       */
+      ~basic_fstream()
+      { }
+
+      // Members:
+      /**
+       *  @brief  Accessing the underlying buffer.
+       *  @return  The current basic_filebuf buffer.
+       *
+       *  This hides both signatures of std::basic_ios::rdbuf().
+       */
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+      /**
+       *  @brief  Wrapper to test for an open file.
+       *  @return  @c rdbuf()->is_open()
+       */
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 365. Lack of const-qualification in clause 27
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *
+       *  Calls @c std::basic_filebuf::open(__s,__mode).  If that
+       *  function fails, @c failbit is set in the stream's error state.
+       *
+       *  Tip:  When using std::string to hold the filename, you must use
+       *  .c_str() before passing it to this constructor.
+       */
+      void
+      open(const char* __s,
+	   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      {
+	if (!_M_filebuf.open(__s, __mode))
+	  this->setstate(ios_base::failbit);
+	else
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 409. Closing an fstream should clear error state
+	  this->clear();
+      }
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Opens an external file.
+       *  @param  __s  The name of the file.
+       *  @param  __mode  The open mode flags.
+       *
+       *  Calls @c std::basic_filebuf::open(__s,__mode).  If that
+       *  function fails, @c failbit is set in the stream's error state.
+       */
+      void
+      open(const std::string& __s,
+	   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      {
+	if (!_M_filebuf.open(__s, __mode))
+	  this->setstate(ios_base::failbit);
+	else
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 409. Closing an fstream should clear error state
+	  this->clear();
+      }
+#endif
+
+      /**
+       *  @brief  Close the file.
+       *
+       *  Calls @c std::basic_filebuf::close().  If that function
+       *  fails, @c failbit is set in the stream's error state.
+       */
+      void
+      close()
+      {
+	if (!_M_filebuf.close())
+	  this->setstate(ios_base::failbit);
+      }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/fstream.tcc>
+
+#endif /* _GLIBCXX_FSTREAM */
diff --git a/gcc-4.9/libstdc++-v3/include/std/functional b/gcc-4.9/libstdc++-v3/include/std/functional
new file mode 100644
index 0000000..5a987d9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/functional
@@ -0,0 +1,2542 @@
+// <functional> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file include/functional
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_FUNCTIONAL
+#define _GLIBCXX_FUNCTIONAL 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stl_function.h>
+
+#if __cplusplus >= 201103L
+
+#include <typeinfo>
+#include <new>
+#include <tuple>
+#include <type_traits>
+#include <bits/functexcept.h>
+#include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _MemberPointer>
+    class _Mem_fn;
+  template<typename _Tp, typename _Class>
+    _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::*) noexcept;
+
+_GLIBCXX_HAS_NESTED_TYPE(result_type)
+
+  /// If we have found a result_type, extract it.
+  template<bool _Has_result_type, typename _Functor>
+    struct _Maybe_get_result_type
+    { };
+
+  template<typename _Functor>
+    struct _Maybe_get_result_type<true, _Functor>
+    { typedef typename _Functor::result_type result_type; };
+
+  /**
+   *  Base class for any function object that has a weak result type, as
+   *  defined in 3.3/3 of TR1.
+  */
+  template<typename _Functor>
+    struct _Weak_result_type_impl
+    : _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
+    { };
+
+  /// Retrieve the result type for a function type.
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
+    { typedef _Res result_type; };
+
+  /// Retrieve the result type for a function reference.
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+  /// Retrieve the result type for a function pointer.
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+  /// Retrieve result type for a member function pointer.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+  /// Retrieve result type for a const member function pointer.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
+    { typedef _Res result_type; };
+
+  /// Retrieve result type for a volatile member function pointer.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
+    { typedef _Res result_type; };
+
+  /// Retrieve result type for a const volatile member function pointer.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
+				  const volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
+				  const volatile>
+    { typedef _Res result_type; };
+
+  /**
+   *  Strip top-level cv-qualifiers from the function object and let
+   *  _Weak_result_type_impl perform the real work.
+  */
+  template<typename _Functor>
+    struct _Weak_result_type
+    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
+    { };
+
+  /**
+   * Invoke a function object, which may be either a member pointer or a
+   * function object. The first parameter will tell which.
+   */
+  template<typename _Functor, typename... _Args>
+    inline
+    typename enable_if<
+	     (!is_member_pointer<_Functor>::value
+	      && !is_function<_Functor>::value
+	      && !is_function<typename remove_pointer<_Functor>::type>::value),
+	     typename result_of<_Functor&(_Args&&...)>::type
+	   >::type
+    __invoke(_Functor& __f, _Args&&... __args)
+    {
+      return __f(std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Functor, typename... _Args>
+    inline
+    typename enable_if<
+             (is_member_pointer<_Functor>::value
+              && !is_function<_Functor>::value
+              && !is_function<typename remove_pointer<_Functor>::type>::value),
+             typename result_of<_Functor(_Args&&...)>::type
+           >::type
+    __invoke(_Functor& __f, _Args&&... __args)
+    {
+      return std::mem_fn(__f)(std::forward<_Args>(__args)...);
+    }
+
+  // To pick up function references (that will become function pointers)
+  template<typename _Functor, typename... _Args>
+    inline
+    typename enable_if<
+	     (is_pointer<_Functor>::value
+	      && is_function<typename remove_pointer<_Functor>::type>::value),
+	     typename result_of<_Functor(_Args&&...)>::type
+	   >::type
+    __invoke(_Functor __f, _Args&&... __args)
+    {
+      return __f(std::forward<_Args>(__args)...);
+    }
+
+  /**
+   *  Knowing which of unary_function and binary_function _Tp derives
+   *  from, derives from the same and ensures that reference_wrapper
+   *  will have a weak result type. See cases below.
+   */
+  template<bool _Unary, bool _Binary, typename _Tp>
+    struct _Reference_wrapper_base_impl;
+
+  // None of the nested argument types.
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, false, _Tp>
+    : _Weak_result_type<_Tp>
+    { };
+
+  // Nested argument_type only.
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, false, _Tp>
+    : _Weak_result_type<_Tp>
+    {
+      typedef typename _Tp::argument_type argument_type;
+    };
+
+  // Nested first_argument_type and second_argument_type only.
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, true, _Tp>
+    : _Weak_result_type<_Tp>
+    {
+      typedef typename _Tp::first_argument_type first_argument_type;
+      typedef typename _Tp::second_argument_type second_argument_type;
+    };
+
+  // All the nested argument types.
+   template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, true, _Tp>
+    : _Weak_result_type<_Tp>
+    {
+      typedef typename _Tp::argument_type argument_type;
+      typedef typename _Tp::first_argument_type first_argument_type;
+      typedef typename _Tp::second_argument_type second_argument_type;
+    };
+
+  _GLIBCXX_HAS_NESTED_TYPE(argument_type)
+  _GLIBCXX_HAS_NESTED_TYPE(first_argument_type)
+  _GLIBCXX_HAS_NESTED_TYPE(second_argument_type)
+
+  /**
+   *  Derives from unary_function or binary_function when it
+   *  can. Specializations handle all of the easy cases. The primary
+   *  template determines what to do with a class type, which may
+   *  derive from both unary_function and binary_function.
+  */
+  template<typename _Tp>
+    struct _Reference_wrapper_base
+    : _Reference_wrapper_base_impl<
+      __has_argument_type<_Tp>::value,
+      __has_first_argument_type<_Tp>::value
+      && __has_second_argument_type<_Tp>::value,
+      _Tp>
+    { };
+
+  // - a function type (unary)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+  // - a function type (binary)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  // - a function pointer type (unary)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(*)(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+  // - a function pointer type (binary)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, no qualifiers)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)()>
+    : unary_function<_T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, no qualifiers)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
+    : binary_function<_T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, const)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const>
+    : unary_function<const _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, const)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
+    : binary_function<const _T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, volatile)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
+    : unary_function<volatile _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, volatile)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
+    : binary_function<volatile _T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, const volatile)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
+    : unary_function<const volatile _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, const volatile)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
+    : binary_function<const volatile _T1*, _T2, _Res>
+    { };
+
+  /**
+   *  @brief Primary class template for reference_wrapper.
+   *  @ingroup functors
+   *  @{
+   */
+  template<typename _Tp>
+    class reference_wrapper
+    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
+    {
+      _Tp* _M_data;
+
+    public:
+      typedef _Tp type;
+
+      reference_wrapper(_Tp& __indata) noexcept
+      : _M_data(std::__addressof(__indata))
+      { }
+
+      reference_wrapper(_Tp&&) = delete;
+
+      reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
+      : _M_data(__inref._M_data)
+      { }
+
+      reference_wrapper&
+      operator=(const reference_wrapper<_Tp>& __inref) noexcept
+      {
+	_M_data = __inref._M_data;
+	return *this;
+      }
+
+      operator _Tp&() const noexcept
+      { return this->get(); }
+
+      _Tp&
+      get() const noexcept
+      { return *_M_data; }
+
+      template<typename... _Args>
+	typename result_of<_Tp&(_Args&&...)>::type
+	operator()(_Args&&... __args) const
+	{
+	  return __invoke(get(), std::forward<_Args>(__args)...);
+	}
+    };
+
+
+  /// Denotes a reference should be taken to a variable.
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(_Tp& __t) noexcept
+    { return reference_wrapper<_Tp>(__t); }
+
+  /// Denotes a const reference should be taken to a variable.
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(const _Tp& __t) noexcept
+    { return reference_wrapper<const _Tp>(__t); }
+
+  template<typename _Tp>
+    void ref(const _Tp&&) = delete;
+
+  template<typename _Tp>
+    void cref(const _Tp&&) = delete;
+
+  /// Partial specialization.
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(reference_wrapper<_Tp> __t) noexcept
+    { return ref(__t.get()); }
+
+  /// Partial specialization.
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(reference_wrapper<_Tp> __t) noexcept
+    { return cref(__t.get()); }
+
+  // @} group functors
+
+  template<typename... _Types>
+    struct _Pack : integral_constant<size_t, sizeof...(_Types)>
+    { };
+
+  template<typename _From, typename _To, bool = _From::value == _To::value>
+    struct _AllConvertible : false_type
+    { };
+
+  template<typename... _From, typename... _To>
+    struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
+    : __and_<is_convertible<_From, _To>...>
+    { };
+
+  template<typename _Tp1, typename _Tp2>
+    using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
+				    typename std::decay<_Tp2>::type>>;
+
+  /**
+   * Derives from @c unary_function or @c binary_function, or perhaps
+   * nothing, depending on the number of arguments provided. The
+   * primary template is the basis case, which derives nothing.
+   */
+  template<typename _Res, typename... _ArgTypes>
+    struct _Maybe_unary_or_binary_function { };
+
+  /// Derives from @c unary_function, as appropriate.
+  template<typename _Res, typename _T1>
+    struct _Maybe_unary_or_binary_function<_Res, _T1>
+    : std::unary_function<_T1, _Res> { };
+
+  /// Derives from @c binary_function, as appropriate.
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+    : std::binary_function<_T1, _T2, _Res> { };
+
+  /// Implementation of @c mem_fn for member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...);
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __object, const volatile _Class *,
+		_Args&&... __args) const
+	{
+	  return (std::forward<_Tp>(__object).*__pmf)
+	    (std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
+	{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
+
+      // Require each _Args to be convertible to corresponding _ArgTypes
+      template<typename... _Args>
+	using _RequireValidArgs
+	  = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      // Require each _Args to be convertible to corresponding _ArgTypes
+      // and require _Tp is not _Class, _Class& or _Class*
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs2
+	  = _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      // Require each _Args to be convertible to corresponding _ArgTypes
+      // and require _Tp is _Class or derived from _Class
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs3
+	  = _Require<is_base_of<_Class, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(_Class& __object, _Args&&... __args) const
+	{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(_Class&& __object, _Args&&... __args) const
+	{
+	  return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
+	}
+
+      // Handle pointers
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(_Class* __object, _Args&&... __args) const
+	{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs2<_Tp, _Args...>>
+	_Res
+	operator()(_Tp&& __object, _Args&&... __args) const
+	{
+	  return _M_call(std::forward<_Tp>(__object), &__object,
+	      std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs3<_Tp, _Args...>>
+	_Res
+	operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
+	{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /// Implementation of @c mem_fn for const member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
+    : public _Maybe_unary_or_binary_function<_Res, const _Class*,
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __object, const volatile _Class *,
+		_Args&&... __args) const
+	{
+	  return (std::forward<_Tp>(__object).*__pmf)
+	    (std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
+	{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args>
+	using _RequireValidArgs
+	  = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs2
+	  = _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs3
+	  = _Require<is_base_of<_Class, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(const _Class& __object, _Args&&... __args) const
+	{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(const _Class&& __object, _Args&&... __args) const
+	{
+	  return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
+	}
+
+      // Handle pointers
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(const _Class* __object, _Args&&... __args) const
+	{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs2<_Tp, _Args...>>
+	_Res operator()(_Tp&& __object, _Args&&... __args) const
+	{
+	  return _M_call(std::forward<_Tp>(__object), &__object,
+	      std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs3<_Tp, _Args...>>
+	_Res
+	operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
+	{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /// Implementation of @c mem_fn for volatile member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
+    : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __object, const volatile _Class *,
+		_Args&&... __args) const
+	{
+	  return (std::forward<_Tp>(__object).*__pmf)
+	    (std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
+	{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args>
+	using _RequireValidArgs
+	  = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs2
+	  = _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs3
+	  = _Require<is_base_of<_Class, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(volatile _Class& __object, _Args&&... __args) const
+	{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(volatile _Class&& __object, _Args&&... __args) const
+	{
+	  return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
+	}
+
+      // Handle pointers
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(volatile _Class* __object, _Args&&... __args) const
+	{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs2<_Tp, _Args...>>
+	_Res
+	operator()(_Tp&& __object, _Args&&... __args) const
+	{
+	  return _M_call(std::forward<_Tp>(__object), &__object,
+	      std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs3<_Tp, _Args...>>
+	_Res
+	operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
+	{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /// Implementation of @c mem_fn for const volatile member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
+    : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __object, const volatile _Class *,
+		_Args&&... __args) const
+	{
+	  return (std::forward<_Tp>(__object).*__pmf)
+	    (std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args>
+	_Res
+	_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
+	{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args>
+	using _RequireValidArgs
+	  = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs2
+	  = _Require<_NotSame<_Class, _Tp>,
+		     _NotSame<const volatile _Class*, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+      template<typename _Tp, typename... _Args>
+	using _RequireValidArgs3
+	  = _Require<is_base_of<_Class, _Tp>,
+		     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(const volatile _Class& __object, _Args&&... __args) const
+	{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
+
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(const volatile _Class&& __object, _Args&&... __args) const
+	{
+	  return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
+	}
+
+      // Handle pointers
+      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
+	_Res
+	operator()(const volatile _Class* __object, _Args&&... __args) const
+	{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs2<_Tp, _Args...>>
+	_Res operator()(_Tp&& __object, _Args&&... __args) const
+	{
+	  return _M_call(std::forward<_Tp>(__object), &__object,
+	      std::forward<_Args>(__args)...);
+	}
+
+      template<typename _Tp, typename... _Args,
+	       typename _Req = _RequireValidArgs3<_Tp, _Args...>>
+	_Res
+	operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
+	{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+
+  template<typename _Tp, bool>
+    struct _Mem_fn_const_or_non
+    {
+      typedef const _Tp& type;
+    };
+
+  template<typename _Tp>
+    struct _Mem_fn_const_or_non<_Tp, false>
+    {
+      typedef _Tp& type;
+    };
+
+  template<typename _Res, typename _Class>
+    class _Mem_fn<_Res _Class::*>
+    {
+      using __pm_type = _Res _Class::*;
+
+      // This bit of genius is due to Peter Dimov, improved slightly by
+      // Douglas Gregor.
+      // Made less elegant to support perfect forwarding and noexcept.
+      template<typename _Tp>
+	auto
+	_M_call(_Tp&& __object, const _Class *) const noexcept
+	-> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>())
+	{ return std::forward<_Tp>(__object).*__pm; }
+
+      template<typename _Tp, typename _Up>
+	auto
+	_M_call(_Tp&& __object, _Up * const *) const noexcept
+	-> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>())
+	{ return (*std::forward<_Tp>(__object)).*__pm; }
+
+      template<typename _Tp>
+	auto
+	_M_call(_Tp&& __ptr, const volatile void*) const
+	noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
+	-> decltype((*__ptr).*std::declval<__pm_type&>())
+	{ return (*__ptr).*__pm; }
+
+    public:
+      explicit
+      _Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { }
+
+      // Handle objects
+      _Res&
+      operator()(_Class& __object) const noexcept
+      { return __object.*__pm; }
+
+      const _Res&
+      operator()(const _Class& __object) const noexcept
+      { return __object.*__pm; }
+
+      _Res&&
+      operator()(_Class&& __object) const noexcept
+      { return std::forward<_Class>(__object).*__pm; }
+
+      const _Res&&
+      operator()(const _Class&& __object) const noexcept
+      { return std::forward<const _Class>(__object).*__pm; }
+
+      // Handle pointers
+      _Res&
+      operator()(_Class* __object) const noexcept
+      { return __object->*__pm; }
+
+      const _Res&
+      operator()(const _Class* __object) const noexcept
+      { return __object->*__pm; }
+
+      // Handle smart pointers and derived
+      template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>>
+	auto
+	operator()(_Tp&& __unknown) const
+	noexcept(noexcept(std::declval<_Mem_fn*>()->_M_call
+			  (std::forward<_Tp>(__unknown), &__unknown)))
+	-> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown))
+	{ return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
+
+      template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>>
+	auto
+	operator()(reference_wrapper<_Tp> __ref) const
+	noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get())))
+	-> decltype((*this)(__ref.get()))
+	{ return (*this)(__ref.get()); }
+
+    private:
+      _Res _Class::*__pm;
+    };
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 2048.  Unnecessary mem_fn overloads
+  /**
+   *  @brief Returns a function object that forwards to the member
+   *  pointer @a pm.
+   *  @ingroup functors
+   */
+  template<typename _Tp, typename _Class>
+    inline _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::* __pm) noexcept
+    {
+      return _Mem_fn<_Tp _Class::*>(__pm);
+    }
+
+  /**
+   *  @brief Determines if the given type _Tp is a function object
+   *  should be treated as a subexpression when evaluating calls to
+   *  function objects returned by bind(). [TR1 3.6.1]
+   *  @ingroup binders
+   */
+  template<typename _Tp>
+    struct is_bind_expression
+    : public false_type { };
+
+  /**
+   *  @brief Determines if the given type _Tp is a placeholder in a
+   *  bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
+   *  @ingroup binders
+   */
+  template<typename _Tp>
+    struct is_placeholder
+    : public integral_constant<int, 0>
+    { };
+
+  /** @brief The type of placeholder objects defined by libstdc++.
+   *  @ingroup binders
+   */
+  template<int _Num> struct _Placeholder { };
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+
+  /** @namespace std::placeholders
+   *  @brief ISO C++11 entities sub-namespace for functional.
+   *  @ingroup binders
+   */
+  namespace placeholders
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+  /* Define a large number of placeholders. There is no way to
+   * simplify this with variadic templates, because we're introducing
+   * unique names for each.
+   */
+    extern const _Placeholder<1> _1;
+    extern const _Placeholder<2> _2;
+    extern const _Placeholder<3> _3;
+    extern const _Placeholder<4> _4;
+    extern const _Placeholder<5> _5;
+    extern const _Placeholder<6> _6;
+    extern const _Placeholder<7> _7;
+    extern const _Placeholder<8> _8;
+    extern const _Placeholder<9> _9;
+    extern const _Placeholder<10> _10;
+    extern const _Placeholder<11> _11;
+    extern const _Placeholder<12> _12;
+    extern const _Placeholder<13> _13;
+    extern const _Placeholder<14> _14;
+    extern const _Placeholder<15> _15;
+    extern const _Placeholder<16> _16;
+    extern const _Placeholder<17> _17;
+    extern const _Placeholder<18> _18;
+    extern const _Placeholder<19> _19;
+    extern const _Placeholder<20> _20;
+    extern const _Placeholder<21> _21;
+    extern const _Placeholder<22> _22;
+    extern const _Placeholder<23> _23;
+    extern const _Placeholder<24> _24;
+    extern const _Placeholder<25> _25;
+    extern const _Placeholder<26> _26;
+    extern const _Placeholder<27> _27;
+    extern const _Placeholder<28> _28;
+    extern const _Placeholder<29> _29;
+  _GLIBCXX_END_NAMESPACE_VERSION
+  }
+
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  Partial specialization of is_placeholder that provides the placeholder
+   *  number for the placeholder objects defined by libstdc++.
+   *  @ingroup binders
+   */
+  template<int _Num>
+    struct is_placeholder<_Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+  template<int _Num>
+    struct is_placeholder<const _Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+  /**
+   * Used by _Safe_tuple_element to indicate that there is no tuple
+   * element at this position.
+   */
+  struct _No_tuple_element;
+
+  /**
+   * Implementation helper for _Safe_tuple_element. This primary
+   * template handles the case where it is safe to use @c
+   * tuple_element.
+   */
+  template<std::size_t __i, typename _Tuple, bool _IsSafe>
+    struct _Safe_tuple_element_impl
+    : tuple_element<__i, _Tuple> { };
+
+  /**
+   * Implementation helper for _Safe_tuple_element. This partial
+   * specialization handles the case where it is not safe to use @c
+   * tuple_element. We just return @c _No_tuple_element.
+   */
+  template<std::size_t __i, typename _Tuple>
+    struct _Safe_tuple_element_impl<__i, _Tuple, false>
+    {
+      typedef _No_tuple_element type;
+    };
+
+  /**
+   * Like tuple_element, but returns @c _No_tuple_element when
+   * tuple_element would return an error.
+   */
+ template<std::size_t __i, typename _Tuple>
+   struct _Safe_tuple_element
+   : _Safe_tuple_element_impl<__i, _Tuple,
+			      (__i < tuple_size<_Tuple>::value)>
+   { };
+
+  /**
+   *  Maps an argument to bind() into an actual argument to the bound
+   *  function object [TR1 3.6.3/5]. Only the first parameter should
+   *  be specified: the rest are used to determine among the various
+   *  implementations. Note that, although this class is a function
+   *  object, it isn't entirely normal because it takes only two
+   *  parameters regardless of the number of parameters passed to the
+   *  bind expression. The first parameter is the bound argument and
+   *  the second parameter is a tuple containing references to the
+   *  rest of the arguments.
+   */
+  template<typename _Arg,
+	   bool _IsBindExp = is_bind_expression<_Arg>::value,
+	   bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+    class _Mu;
+
+  /**
+   *  If the argument is reference_wrapper<_Tp>, returns the
+   *  underlying reference. [TR1 3.6.3/5 bullet 1]
+   */
+  template<typename _Tp>
+    class _Mu<reference_wrapper<_Tp>, false, false>
+    {
+    public:
+      typedef _Tp& result_type;
+
+      /* Note: This won't actually work for const volatile
+       * reference_wrappers, because reference_wrapper::get() is const
+       * but not volatile-qualified. This might be a defect in the TR.
+       */
+      template<typename _CVRef, typename _Tuple>
+	result_type
+	operator()(_CVRef& __arg, _Tuple&) const volatile
+	{ return __arg.get(); }
+    };
+
+  /**
+   *  If the argument is a bind expression, we invoke the underlying
+   *  function object with the same cv-qualifiers as we are given and
+   *  pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, true, false>
+    {
+    public:
+      template<typename _CVArg, typename... _Args>
+	auto
+	operator()(_CVArg& __arg,
+		   tuple<_Args...>& __tuple) const volatile
+	-> decltype(__arg(declval<_Args>()...))
+	{
+	  // Construct an index tuple and forward to __call
+	  typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+	    _Indexes;
+	  return this->__call(__arg, __tuple, _Indexes());
+	}
+
+    private:
+      // Invokes the underlying function object __arg by unpacking all
+      // of the arguments in the tuple.
+      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
+	auto
+	__call(_CVArg& __arg, tuple<_Args...>& __tuple,
+	       const _Index_tuple<_Indexes...>&) const volatile
+	-> decltype(__arg(declval<_Args>()...))
+	{
+	  return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
+	}
+    };
+
+  /**
+   *  If the argument is a placeholder for the Nth argument, returns
+   *  a reference to the Nth argument to the bind function object.
+   *  [TR1 3.6.3/5 bullet 3]
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, false, true>
+    {
+    public:
+      template<typename _Signature> class result;
+
+      template<typename _CVMu, typename _CVArg, typename _Tuple>
+	class result<_CVMu(_CVArg, _Tuple)>
+	{
+	  // Add a reference, if it hasn't already been done for us.
+	  // This allows us to be a little bit sloppy in constructing
+	  // the tuple that we pass to result_of<...>.
+	  typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
+						- 1), _Tuple>::type
+	    __base_type;
+
+	public:
+	  typedef typename add_rvalue_reference<__base_type>::type type;
+	};
+
+      template<typename _Tuple>
+	typename result<_Mu(_Arg, _Tuple)>::type
+	operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
+	{
+	  return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
+	      ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
+	}
+    };
+
+  /**
+   *  If the argument is just a value, returns a reference to that
+   *  value. The cv-qualifiers on the reference are the same as the
+   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, false, false>
+    {
+    public:
+      template<typename _Signature> struct result;
+
+      template<typename _CVMu, typename _CVArg, typename _Tuple>
+	struct result<_CVMu(_CVArg, _Tuple)>
+	{
+	  typedef typename add_lvalue_reference<_CVArg>::type type;
+	};
+
+      // Pick up the cv-qualifiers of the argument
+      template<typename _CVArg, typename _Tuple>
+	_CVArg&&
+	operator()(_CVArg&& __arg, _Tuple&) const volatile
+	{ return std::forward<_CVArg>(__arg); }
+    };
+
+  /**
+   *  Maps member pointers into instances of _Mem_fn but leaves all
+   *  other function objects untouched. Used by tr1::bind(). The
+   *  primary template handles the non--member-pointer case.
+   */
+  template<typename _Tp>
+    struct _Maybe_wrap_member_pointer
+    {
+      typedef _Tp type;
+
+      static const _Tp&
+      __do_wrap(const _Tp& __x)
+      { return __x; }
+
+      static _Tp&&
+      __do_wrap(_Tp&& __x)
+      { return static_cast<_Tp&&>(__x); }
+    };
+
+  /**
+   *  Maps member pointers into instances of _Mem_fn but leaves all
+   *  other function objects untouched. Used by tr1::bind(). This
+   *  partial specialization handles the member pointer case.
+   */
+  template<typename _Tp, typename _Class>
+    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
+    {
+      typedef _Mem_fn<_Tp _Class::*> type;
+
+      static type
+      __do_wrap(_Tp _Class::* __pm)
+      { return type(__pm); }
+    };
+
+  // Specialization needed to prevent "forming reference to void" errors when
+  // bind<void>() is called, because argument deduction instantiates
+  // _Maybe_wrap_member_pointer<void> outside the immediate context where
+  // SFINAE applies.
+  template<>
+    struct _Maybe_wrap_member_pointer<void>
+    {
+      typedef void type;
+    };
+
+  // std::get<I> for volatile-qualified tuples
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(volatile tuple<_Tp...>& __tuple)
+    -> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile&
+    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
+
+  // std::get<I> for const-volatile-qualified tuples
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(const volatile tuple<_Tp...>& __tuple)
+    -> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile&
+    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
+
+  /// Type of the function object returned from bind().
+  template<typename _Signature>
+    struct _Bind;
+
+   template<typename _Functor, typename... _Bound_args>
+    class _Bind<_Functor(_Bound_args...)>
+    : public _Weak_result_type<_Functor>
+    {
+      typedef _Bind __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+	_Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+      // Call unqualified
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (get<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as const
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (get<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as volatile
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call_v(tuple<_Args...>&& __args,
+		 _Index_tuple<_Indexes...>) volatile
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (__volget<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as const volatile
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call_c_v(tuple<_Args...>&& __args,
+		   _Index_tuple<_Indexes...>) const volatile
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (__volget<_Indexes>(_M_bound_args), __args)...);
+	}
+
+     public:
+      template<typename... _Args>
+	explicit _Bind(const _Functor& __f, _Args&&... __args)
+	: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+	{ }
+
+      template<typename... _Args>
+	explicit _Bind(_Functor&& __f, _Args&&... __args)
+	: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+	{ }
+
+      _Bind(const _Bind&) = default;
+
+      _Bind(_Bind&& __b)
+      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
+      { }
+
+      // Call unqualified
+      template<typename... _Args, typename _Result
+	= decltype( std::declval<_Functor>()(
+	      _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
+				  std::declval<tuple<_Args...>&>() )... ) )>
+	_Result
+	operator()(_Args&&... __args)
+	{
+	  return this->__call<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+
+      // Call as const
+      template<typename... _Args, typename _Result
+	= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
+		       typename add_const<_Functor>::type>::type>()(
+	      _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
+				  std::declval<tuple<_Args...>&>() )... ) )>
+	_Result
+	operator()(_Args&&... __args) const
+	{
+	  return this->__call_c<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+
+      // Call as volatile
+      template<typename... _Args, typename _Result
+	= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
+                       typename add_volatile<_Functor>::type>::type>()(
+	      _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
+				  std::declval<tuple<_Args...>&>() )... ) )>
+	_Result
+	operator()(_Args&&... __args) volatile
+	{
+	  return this->__call_v<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+
+      // Call as const volatile
+      template<typename... _Args, typename _Result
+	= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
+                       typename add_cv<_Functor>::type>::type>()(
+	      _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
+				  std::declval<tuple<_Args...>&>() )... ) )>
+	_Result
+	operator()(_Args&&... __args) const volatile
+	{
+	  return this->__call_c_v<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+    };
+
+  /// Type of the function object returned from bind<R>().
+  template<typename _Result, typename _Signature>
+    struct _Bind_result;
+
+  template<typename _Result, typename _Functor, typename... _Bound_args>
+    class _Bind_result<_Result, _Functor(_Bound_args...)>
+    {
+      typedef _Bind_result __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+	_Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+      // sfinae types
+      template<typename _Res>
+	struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
+      template<typename _Res>
+	struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
+
+      // Call unqualified
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+	    typename __disable_if_void<_Res>::type = 0)
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (get<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call unqualified, return void
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	void
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+	    typename __enable_if_void<_Res>::type = 0)
+	{
+	  _M_f(_Mu<_Bound_args>()
+	       (get<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as const
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+	    typename __disable_if_void<_Res>::type = 0) const
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (get<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as const, return void
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	void
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+	    typename __enable_if_void<_Res>::type = 0) const
+	{
+	  _M_f(_Mu<_Bound_args>()
+	       (get<_Indexes>(_M_bound_args),  __args)...);
+	}
+
+      // Call as volatile
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+	    typename __disable_if_void<_Res>::type = 0) volatile
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (__volget<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as volatile, return void
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	void
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+	    typename __enable_if_void<_Res>::type = 0) volatile
+	{
+	  _M_f(_Mu<_Bound_args>()
+	       (__volget<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as const volatile
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	_Result
+	__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+	    typename __disable_if_void<_Res>::type = 0) const volatile
+	{
+	  return _M_f(_Mu<_Bound_args>()
+		      (__volget<_Indexes>(_M_bound_args), __args)...);
+	}
+
+      // Call as const volatile, return void
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+	void
+	__call(tuple<_Args...>&& __args,
+	       _Index_tuple<_Indexes...>,
+	    typename __enable_if_void<_Res>::type = 0) const volatile
+	{
+	  _M_f(_Mu<_Bound_args>()
+	       (__volget<_Indexes>(_M_bound_args), __args)...);
+	}
+
+    public:
+      typedef _Result result_type;
+
+      template<typename... _Args>
+	explicit _Bind_result(const _Functor& __f, _Args&&... __args)
+	: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+	{ }
+
+      template<typename... _Args>
+	explicit _Bind_result(_Functor&& __f, _Args&&... __args)
+	: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+	{ }
+
+      _Bind_result(const _Bind_result&) = default;
+
+      _Bind_result(_Bind_result&& __b)
+      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
+      { }
+
+      // Call unqualified
+      template<typename... _Args>
+	result_type
+	operator()(_Args&&... __args)
+	{
+	  return this->__call<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+
+      // Call as const
+      template<typename... _Args>
+	result_type
+	operator()(_Args&&... __args) const
+	{
+	  return this->__call<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+
+      // Call as volatile
+      template<typename... _Args>
+	result_type
+	operator()(_Args&&... __args) volatile
+	{
+	  return this->__call<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+
+      // Call as const volatile
+      template<typename... _Args>
+	result_type
+	operator()(_Args&&... __args) const volatile
+	{
+	  return this->__call<_Result>(
+	      std::forward_as_tuple(std::forward<_Args>(__args)...),
+	      _Bound_indexes());
+	}
+    };
+
+  /**
+   *  @brief Class template _Bind is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Signature>
+    struct is_bind_expression<_Bind<_Signature> >
+    : public true_type { };
+
+  /**
+   *  @brief Class template _Bind is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Signature>
+    struct is_bind_expression<const _Bind<_Signature> >
+    : public true_type { };
+
+  /**
+   *  @brief Class template _Bind is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Signature>
+    struct is_bind_expression<volatile _Bind<_Signature> >
+    : public true_type { };
+
+  /**
+   *  @brief Class template _Bind is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Signature>
+    struct is_bind_expression<const volatile _Bind<_Signature>>
+    : public true_type { };
+
+  /**
+   *  @brief Class template _Bind_result is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<_Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+  /**
+   *  @brief Class template _Bind_result is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+  /**
+   *  @brief Class template _Bind_result is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+  /**
+   *  @brief Class template _Bind_result is always a bind expression.
+   *  @ingroup binders
+   */
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+  // Trait type used to remove std::bind() from overload set via SFINAE
+  // when first argument has integer type, so that std::bind() will
+  // not be a better match than ::bind() from the BSD Sockets API.
+  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
+    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
+
+  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
+    struct _Bind_helper
+    {
+      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
+	__maybe_type;
+      typedef typename __maybe_type::type __func_type;
+      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
+    };
+
+  // Partial specialization for is_socketlike == true, does not define
+  // nested type so std::bind() will not participate in overload resolution
+  // when the first argument might be a socket file descriptor.
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_helper<true, _Func, _BoundArgs...>
+    { };
+
+  /**
+   *  @brief Function template for std::bind.
+   *  @ingroup binders
+   */
+  template<typename _Func, typename... _BoundArgs>
+    inline typename
+    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
+      typedef typename __helper_type::__maybe_type __maybe_type;
+      typedef typename __helper_type::type __result_type;
+      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
+			   std::forward<_BoundArgs>(__args)...);
+    }
+
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    struct _Bindres_helper
+    {
+      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
+	__maybe_type;
+      typedef typename __maybe_type::type __functor_type;
+      typedef _Bind_result<_Result,
+			   __functor_type(typename decay<_BoundArgs>::type...)>
+	type;
+    };
+
+  /**
+   *  @brief Function template for std::bind<R>.
+   *  @ingroup binders
+   */
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    inline
+    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
+      typedef typename __helper_type::__maybe_type __maybe_type;
+      typedef typename __helper_type::type __result_type;
+      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
+			   std::forward<_BoundArgs>(__args)...);
+    }
+
+  template<typename _Signature>
+    struct _Bind_simple;
+
+  template<typename _Callable, typename... _Args>
+    struct _Bind_simple<_Callable(_Args...)>
+    {
+      typedef typename result_of<_Callable(_Args...)>::type result_type;
+
+      template<typename... _Args2, typename = typename
+               enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
+        explicit
+        _Bind_simple(const _Callable& __callable, _Args2&&... __args)
+        : _M_bound(__callable, std::forward<_Args2>(__args)...)
+        { }
+
+      template<typename... _Args2, typename = typename
+               enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
+        explicit
+        _Bind_simple(_Callable&& __callable, _Args2&&... __args)
+        : _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
+        { }
+
+      _Bind_simple(const _Bind_simple&) = default;
+      _Bind_simple(_Bind_simple&&) = default;
+
+      result_type
+      operator()()
+      {
+        typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
+        return _M_invoke(_Indices());
+      }
+
+    private:
+
+      template<std::size_t... _Indices>
+        typename result_of<_Callable(_Args...)>::type
+        _M_invoke(_Index_tuple<_Indices...>)
+        {
+	  // std::bind always forwards bound arguments as lvalues,
+	  // but this type can call functions which only accept rvalues.
+          return std::forward<_Callable>(std::get<0>(_M_bound))(
+              std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
+        }
+
+      std::tuple<_Callable, _Args...> _M_bound;
+    };
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_simple_helper
+    {
+      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
+        __maybe_type;
+      typedef typename __maybe_type::type __func_type;
+      typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
+       	__type;
+    };
+
+  // Simplified version of std::bind for internal use, without support for
+  // unbound arguments, placeholders or nested bind expressions.
+  template<typename _Callable, typename... _Args>
+    typename _Bind_simple_helper<_Callable, _Args...>::__type
+    __bind_simple(_Callable&& __callable, _Args&&... __args)
+    {
+      typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
+      typedef typename __helper_type::__maybe_type __maybe_type;
+      typedef typename __helper_type::__type __result_type;
+      return __result_type(
+          __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
+          std::forward<_Args>(__args)...);
+    }
+
+  /**
+   *  @brief Exception class thrown when class template function's
+   *  operator() is called with an empty target.
+   *  @ingroup exceptions
+   */
+  class bad_function_call : public std::exception
+  {
+  public:
+    virtual ~bad_function_call() noexcept;
+
+    const char* what() const noexcept;
+  };
+
+  /**
+   *  Trait identifying "location-invariant" types, meaning that the
+   *  address of the object (or any of its members) will not escape.
+   *  Also implies a trivial copy constructor and assignment operator.
+   */
+  template<typename _Tp>
+    struct __is_location_invariant
+    : integral_constant<bool, (is_pointer<_Tp>::value
+			       || is_member_pointer<_Tp>::value)>
+    { };
+
+  class _Undefined_class;
+
+  union _Nocopy_types
+  {
+    void*       _M_object;
+    const void* _M_const_object;
+    void (*_M_function_pointer)();
+    void (_Undefined_class::*_M_member_pointer)();
+  };
+
+  union _Any_data
+  {
+    void*       _M_access()       { return &_M_pod_data[0]; }
+    const void* _M_access() const { return &_M_pod_data[0]; }
+
+    template<typename _Tp>
+      _Tp&
+      _M_access()
+      { return *static_cast<_Tp*>(_M_access()); }
+
+    template<typename _Tp>
+      const _Tp&
+      _M_access() const
+      { return *static_cast<const _Tp*>(_M_access()); }
+
+    _Nocopy_types _M_unused;
+    char _M_pod_data[sizeof(_Nocopy_types)];
+  };
+
+  enum _Manager_operation
+  {
+    __get_type_info,
+    __get_functor_ptr,
+    __clone_functor,
+    __destroy_functor
+  };
+
+  // Simple type wrapper that helps avoid annoying const problems
+  // when casting between void pointers and pointers-to-pointers.
+  template<typename _Tp>
+    struct _Simple_type_wrapper
+    {
+      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+
+      _Tp __value;
+    };
+
+  template<typename _Tp>
+    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+    : __is_location_invariant<_Tp>
+    { };
+
+  // Converts a reference to a function object into a callable
+  // function object.
+  template<typename _Functor>
+    inline _Functor&
+    __callable_functor(_Functor& __f)
+    { return __f; }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* const &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* volatile &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* const volatile &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Signature>
+    class function;
+
+  /// Base class of all polymorphic function object wrappers.
+  class _Function_base
+  {
+  public:
+    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
+    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
+
+    template<typename _Functor>
+      class _Base_manager
+      {
+      protected:
+	static const bool __stored_locally =
+	(__is_location_invariant<_Functor>::value
+	 && sizeof(_Functor) <= _M_max_size
+	 && __alignof__(_Functor) <= _M_max_align
+	 && (_M_max_align % __alignof__(_Functor) == 0));
+
+	typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+	// Retrieve a pointer to the function object
+	static _Functor*
+	_M_get_pointer(const _Any_data& __source)
+	{
+	  const _Functor* __ptr =
+	    __stored_locally? std::__addressof(__source._M_access<_Functor>())
+	    /* have stored a pointer */ : __source._M_access<_Functor*>();
+	  return const_cast<_Functor*>(__ptr);
+	}
+
+	// Clone a location-invariant function object that fits within
+	// an _Any_data structure.
+	static void
+	_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+	{
+	  new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+	}
+
+	// Clone a function object that is not location-invariant or
+	// that cannot fit into an _Any_data structure.
+	static void
+	_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+	{
+	  __dest._M_access<_Functor*>() =
+	    new _Functor(*__source._M_access<_Functor*>());
+	}
+
+	// Destroying a location-invariant object may still require
+	// destruction.
+	static void
+	_M_destroy(_Any_data& __victim, true_type)
+	{
+	  __victim._M_access<_Functor>().~_Functor();
+	}
+
+	// Destroying an object located on the heap.
+	static void
+	_M_destroy(_Any_data& __victim, false_type)
+	{
+	  delete __victim._M_access<_Functor*>();
+	}
+
+      public:
+	static bool
+	_M_manager(_Any_data& __dest, const _Any_data& __source,
+		   _Manager_operation __op)
+	{
+	  switch (__op)
+	    {
+#ifdef __GXX_RTTI
+	    case __get_type_info:
+	      __dest._M_access<const type_info*>() = &typeid(_Functor);
+	      break;
+#endif
+	    case __get_functor_ptr:
+	      __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+	      break;
+
+	    case __clone_functor:
+	      _M_clone(__dest, __source, _Local_storage());
+	      break;
+
+	    case __destroy_functor:
+	      _M_destroy(__dest, _Local_storage());
+	      break;
+	    }
+	  return false;
+	}
+
+	static void
+	_M_init_functor(_Any_data& __functor, _Functor&& __f)
+	{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }
+
+	template<typename _Signature>
+	  static bool
+	  _M_not_empty_function(const function<_Signature>& __f)
+	  { return static_cast<bool>(__f); }
+
+	template<typename _Tp>
+	  static bool
+	  _M_not_empty_function(_Tp* const& __fp)
+	  { return __fp; }
+
+	template<typename _Class, typename _Tp>
+	  static bool
+	  _M_not_empty_function(_Tp _Class::* const& __mp)
+	  { return __mp; }
+
+	template<typename _Tp>
+	  static bool
+	  _M_not_empty_function(const _Tp&)
+	  { return true; }
+
+      private:
+	static void
+	_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
+	{ new (__functor._M_access()) _Functor(std::move(__f)); }
+
+	static void
+	_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
+	{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
+      };
+
+    template<typename _Functor>
+      class _Ref_manager : public _Base_manager<_Functor*>
+      {
+	typedef _Function_base::_Base_manager<_Functor*> _Base;
+
+      public:
+	static bool
+	_M_manager(_Any_data& __dest, const _Any_data& __source,
+		   _Manager_operation __op)
+	{
+	  switch (__op)
+	    {
+#ifdef __GXX_RTTI
+	    case __get_type_info:
+	      __dest._M_access<const type_info*>() = &typeid(_Functor);
+	      break;
+#endif
+	    case __get_functor_ptr:
+	      __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
+	      return is_const<_Functor>::value;
+	      break;
+
+	    default:
+	      _Base::_M_manager(__dest, __source, __op);
+	    }
+	  return false;
+	}
+
+	static void
+	_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
+	{
+	  _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
+	}
+      };
+
+    _Function_base() : _M_manager(0) { }
+
+    ~_Function_base()
+    {
+      if (_M_manager)
+	_M_manager(_M_functor, _M_functor, __destroy_functor);
+    }
+
+
+    bool _M_empty() const { return !_M_manager; }
+
+    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+				  _Manager_operation);
+
+    _Any_data     _M_functor;
+    _Manager_type _M_manager;
+  };
+
+  template<typename _Signature, typename _Functor>
+    class _Function_handler;
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+    public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+	return (*_Base::_M_get_pointer(__functor))(
+	    std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+	(*_Base::_M_get_pointer(__functor))(
+	    std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+	return __callable_functor(**_Base::_M_get_pointer(__functor))(
+	      std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+	__callable_functor(**_Base::_M_get_pointer(__functor))(
+	    std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename _Res,
+	   typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
+    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    {
+      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
+	_Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+	return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
+	    std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    : public _Function_base::_Base_manager<
+		 _Simple_type_wrapper< _Member _Class::* > >
+    {
+      typedef _Member _Class::* _Functor;
+      typedef _Simple_type_wrapper<_Functor> _Wrapper;
+      typedef _Function_base::_Base_manager<_Wrapper> _Base;
+
+    public:
+      static bool
+      _M_manager(_Any_data& __dest, const _Any_data& __source,
+		 _Manager_operation __op)
+      {
+	switch (__op)
+	  {
+#ifdef __GXX_RTTI
+	  case __get_type_info:
+	    __dest._M_access<const type_info*>() = &typeid(_Functor);
+	    break;
+#endif
+	  case __get_functor_ptr:
+	    __dest._M_access<_Functor*>() =
+	      &_Base::_M_get_pointer(__source)->__value;
+	    break;
+
+	  default:
+	    _Base::_M_manager(__dest, __source, __op);
+	  }
+	return false;
+      }
+
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+	std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
+	    std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _From, typename _To>
+    using __check_func_return_type
+      = __or_<is_void<_To>, is_convertible<_From, _To>>;
+
+  /**
+   *  @brief Primary class template for std::function.
+   *  @ingroup functors
+   *
+   *  Polymorphic function wrapper.
+   */
+  template<typename _Res, typename... _ArgTypes>
+    class function<_Res(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+      private _Function_base
+    {
+      typedef _Res _Signature_type(_ArgTypes...);
+
+      template<typename _Functor>
+	using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
+				 (std::declval<_ArgTypes>()...) );
+
+      template<typename _Functor>
+	using _Callable = __check_func_return_type<_Invoke<_Functor>, _Res>;
+
+      template<typename _Cond, typename _Tp>
+	using _Requires = typename enable_if<_Cond::value, _Tp>::type;
+
+    public:
+      typedef _Res result_type;
+
+      // [3.7.2.1] construct/copy/destroy
+
+      /**
+       *  @brief Default construct creates an empty function call wrapper.
+       *  @post @c !(bool)*this
+       */
+      function() noexcept
+      : _Function_base() { }
+
+      /**
+       *  @brief Creates an empty function call wrapper.
+       *  @post @c !(bool)*this
+       */
+      function(nullptr_t) noexcept
+      : _Function_base() { }
+
+      /**
+       *  @brief %Function copy constructor.
+       *  @param __x A %function object with identical call signature.
+       *  @post @c bool(*this) == bool(__x)
+       *
+       *  The newly-created %function contains a copy of the target of @a
+       *  __x (if it has one).
+       */
+      function(const function& __x);
+
+      /**
+       *  @brief %Function move constructor.
+       *  @param __x A %function object rvalue with identical call signature.
+       *
+       *  The newly-created %function contains the target of @a __x
+       *  (if it has one).
+       */
+      function(function&& __x) : _Function_base()
+      {
+	__x.swap(*this);
+      }
+
+      // TODO: needs allocator_arg_t
+
+      /**
+       *  @brief Builds a %function that targets a copy of the incoming
+       *  function object.
+       *  @param __f A %function object that is callable with parameters of
+       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
+       *  to @c Res.
+       *
+       *  The newly-created %function object will target a copy of 
+       *  @a __f. If @a __f is @c reference_wrapper<F>, then this function
+       *  object will contain a reference to the function object @c
+       *  __f.get(). If @a __f is a NULL function pointer or NULL
+       *  pointer-to-member, the newly-created object will be empty.
+       *
+       *  If @a __f is a non-NULL function pointer or an object of type @c
+       *  reference_wrapper<F>, this function will not throw.
+       */
+      template<typename _Functor,
+	       typename = _Requires<_Callable<_Functor>, void>>
+	function(_Functor);
+
+      /**
+       *  @brief %Function assignment operator.
+       *  @param __x A %function with identical call signature.
+       *  @post @c (bool)*this == (bool)x
+       *  @returns @c *this
+       *
+       *  The target of @a __x is copied to @c *this. If @a __x has no
+       *  target, then @c *this will be empty.
+       *
+       *  If @a __x targets a function pointer or a reference to a function
+       *  object, then this operation will not throw an %exception.
+       */
+      function&
+      operator=(const function& __x)
+      {
+	function(__x).swap(*this);
+	return *this;
+      }
+
+      /**
+       *  @brief %Function move-assignment operator.
+       *  @param __x A %function rvalue with identical call signature.
+       *  @returns @c *this
+       *
+       *  The target of @a __x is moved to @c *this. If @a __x has no
+       *  target, then @c *this will be empty.
+       *
+       *  If @a __x targets a function pointer or a reference to a function
+       *  object, then this operation will not throw an %exception.
+       */
+      function&
+      operator=(function&& __x)
+      {
+	function(std::move(__x)).swap(*this);
+	return *this;
+      }
+
+      /**
+       *  @brief %Function assignment to zero.
+       *  @post @c !(bool)*this
+       *  @returns @c *this
+       *
+       *  The target of @c *this is deallocated, leaving it empty.
+       */
+      function&
+      operator=(nullptr_t)
+      {
+	if (_M_manager)
+	  {
+	    _M_manager(_M_functor, _M_functor, __destroy_functor);
+	    _M_manager = 0;
+	    _M_invoker = 0;
+	  }
+	return *this;
+      }
+
+      /**
+       *  @brief %Function assignment to a new target.
+       *  @param __f A %function object that is callable with parameters of
+       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
+       *  to @c Res.
+       *  @return @c *this
+       *
+       *  This  %function object wrapper will target a copy of @a
+       *  __f. If @a __f is @c reference_wrapper<F>, then this function
+       *  object will contain a reference to the function object @c
+       *  __f.get(). If @a __f is a NULL function pointer or NULL
+       *  pointer-to-member, @c this object will be empty.
+       *
+       *  If @a __f is a non-NULL function pointer or an object of type @c
+       *  reference_wrapper<F>, this function will not throw.
+       */
+      template<typename _Functor>
+	_Requires<_Callable<_Functor>, function&>
+	operator=(_Functor&& __f)
+	{
+	  function(std::forward<_Functor>(__f)).swap(*this);
+	  return *this;
+	}
+
+      /// @overload
+      template<typename _Functor>
+	function&
+	operator=(reference_wrapper<_Functor> __f) noexcept
+	{
+	  function(__f).swap(*this);
+	  return *this;
+	}
+
+      // [3.7.2.2] function modifiers
+
+      /**
+       *  @brief Swap the targets of two %function objects.
+       *  @param __x A %function with identical call signature.
+       *
+       *  Swap the targets of @c this function object and @a __f. This
+       *  function will not throw an %exception.
+       */
+      void swap(function& __x)
+      {
+	std::swap(_M_functor, __x._M_functor);
+	std::swap(_M_manager, __x._M_manager);
+	std::swap(_M_invoker, __x._M_invoker);
+      }
+
+      // TODO: needs allocator_arg_t
+      /*
+      template<typename _Functor, typename _Alloc>
+	void
+	assign(_Functor&& __f, const _Alloc& __a)
+	{
+	  function(allocator_arg, __a,
+		   std::forward<_Functor>(__f)).swap(*this);
+	}
+      */
+
+      // [3.7.2.3] function capacity
+
+      /**
+       *  @brief Determine if the %function wrapper has a target.
+       *
+       *  @return @c true when this %function object contains a target,
+       *  or @c false when it is empty.
+       *
+       *  This function will not throw an %exception.
+       */
+      explicit operator bool() const noexcept
+      { return !_M_empty(); }
+
+      // [3.7.2.4] function invocation
+
+      /**
+       *  @brief Invokes the function targeted by @c *this.
+       *  @returns the result of the target.
+       *  @throws bad_function_call when @c !(bool)*this
+       *
+       *  The function call operator invokes the target function object
+       *  stored by @c this.
+       */
+      _Res operator()(_ArgTypes... __args) const;
+
+#ifdef __GXX_RTTI
+      // [3.7.2.5] function target access
+      /**
+       *  @brief Determine the type of the target of this function object
+       *  wrapper.
+       *
+       *  @returns the type identifier of the target function object, or
+       *  @c typeid(void) if @c !(bool)*this.
+       *
+       *  This function will not throw an %exception.
+       */
+      const type_info& target_type() const noexcept;
+
+      /**
+       *  @brief Access the stored target function object.
+       *
+       *  @return Returns a pointer to the stored target function object,
+       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
+       *  pointer.
+       *
+       * This function will not throw an %exception.
+       */
+      template<typename _Functor>       _Functor* target() noexcept;
+
+      /// @overload
+      template<typename _Functor> const _Functor* target() const noexcept;
+#endif
+
+    private:
+      typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
+      _Invoker_type _M_invoker;
+  };
+
+  // Out-of-line member definitions.
+  template<typename _Res, typename... _ArgTypes>
+    function<_Res(_ArgTypes...)>::
+    function(const function& __x)
+    : _Function_base()
+    {
+      if (static_cast<bool>(__x))
+	{
+	  _M_invoker = __x._M_invoker;
+	  _M_manager = __x._M_manager;
+	  __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+	}
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor, typename>
+      function<_Res(_ArgTypes...)>::
+      function(_Functor __f)
+      : _Function_base()
+      {
+	typedef _Function_handler<_Signature_type, _Functor> _My_handler;
+
+	if (_My_handler::_M_not_empty_function(__f))
+	  {
+	    _My_handler::_M_init_functor(_M_functor, std::move(__f));
+	    _M_invoker = &_My_handler::_M_invoke;
+	    _M_manager = &_My_handler::_M_manager;
+	  }
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    _Res
+    function<_Res(_ArgTypes...)>::
+    operator()(_ArgTypes... __args) const
+    {
+      if (_M_empty())
+	__throw_bad_function_call();
+      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
+    }
+
+#ifdef __GXX_RTTI
+  template<typename _Res, typename... _ArgTypes>
+    const type_info&
+    function<_Res(_ArgTypes...)>::
+    target_type() const noexcept
+    {
+      if (_M_manager)
+	{
+	  _Any_data __typeinfo_result;
+	  _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+	  return *__typeinfo_result._M_access<const type_info*>();
+	}
+      else
+	return typeid(void);
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() noexcept
+      {
+	if (typeid(_Functor) == target_type() && _M_manager)
+	  {
+	    _Any_data __ptr;
+	    if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
+		&& !is_const<_Functor>::value)
+	      return 0;
+	    else
+	      return __ptr._M_access<_Functor*>();
+	  }
+	else
+	  return 0;
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      const _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() const noexcept
+      {
+	if (typeid(_Functor) == target_type() && _M_manager)
+	  {
+	    _Any_data __ptr;
+	    _M_manager(__ptr, _M_functor, __get_functor_ptr);
+	    return __ptr._M_access<const _Functor*>();
+	  }
+	else
+	  return 0;
+      }
+#endif
+
+  // [20.7.15.2.6] null pointer comparisons
+
+  /**
+   *  @brief Compares a polymorphic function object wrapper against 0
+   *  (the NULL pointer).
+   *  @returns @c true if the wrapper has no target, @c false otherwise
+   *
+   *  This function will not throw an %exception.
+   */
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return !static_cast<bool>(__f); }
+
+  /// @overload
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return !static_cast<bool>(__f); }
+
+  /**
+   *  @brief Compares a polymorphic function object wrapper against 0
+   *  (the NULL pointer).
+   *  @returns @c false if the wrapper has no target, @c true otherwise
+   *
+   *  This function will not throw an %exception.
+   */
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return static_cast<bool>(__f); }
+
+  /// @overload
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return static_cast<bool>(__f); }
+
+  // [20.7.15.2.7] specialized algorithms
+
+  /**
+   *  @brief Swap the targets of two polymorphic function object wrappers.
+   *
+   *  This function will not throw an %exception.
+   */
+  template<typename _Res, typename... _Args>
+    inline void
+    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_FUNCTIONAL
diff --git a/gcc-4.9/libstdc++-v3/include/std/future b/gcc-4.9/libstdc++-v3/include/std/future
new file mode 100644
index 0000000..717ce71
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/future
@@ -0,0 +1,1583 @@
+// <future> -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/future
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_FUTURE
+#define _GLIBCXX_FUTURE 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <functional>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+#include <system_error>
+#include <atomic>
+#include <bits/functexcept.h>
+#include <bits/unique_ptr.h>
+#include <bits/shared_ptr.h>
+#include <bits/uses_allocator.h>
+#include <bits/alloc_traits.h>
+#include <ext/aligned_buffer.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup futures Futures
+   * @ingroup concurrency
+   *
+   * Classes for futures support.
+   * @{
+   */
+
+  /// Error code for futures
+  enum class future_errc
+  {
+    future_already_retrieved = 1,
+    promise_already_satisfied,
+    no_state,
+    broken_promise
+  };
+
+  /// Specialization.
+  template<>
+    struct is_error_code_enum<future_errc> : public true_type { };
+
+  /// Points to a statically-allocated object derived from error_category.
+  const error_category&
+  future_category() noexcept;
+
+  /// Overload for make_error_code.
+  inline error_code
+  make_error_code(future_errc __errc) noexcept
+  { return error_code(static_cast<int>(__errc), future_category()); }
+
+  /// Overload for make_error_condition.
+  inline error_condition
+  make_error_condition(future_errc __errc) noexcept
+  { return error_condition(static_cast<int>(__errc), future_category()); }
+
+  /**
+   *  @brief Exception type thrown by futures.
+   *  @ingroup exceptions
+   */
+  class future_error : public logic_error
+  {
+    error_code 			_M_code;
+
+  public:
+    explicit future_error(error_code __ec)
+    : logic_error("std::future_error"), _M_code(__ec)
+    { }
+
+    virtual ~future_error() noexcept;
+
+    virtual const char*
+    what() const noexcept;
+
+    const error_code&
+    code() const noexcept { return _M_code; }
+  };
+
+  // Forward declarations.
+  template<typename _Res>
+    class future;
+
+  template<typename _Res>
+    class shared_future;
+
+  template<typename _Signature>
+    class packaged_task;
+
+  template<typename _Res>
+    class promise;
+
+  /// Launch code for futures
+  enum class launch
+  {
+    async = 1,
+    deferred = 2
+  };
+
+  constexpr launch operator&(launch __x, launch __y)
+  {
+    return static_cast<launch>(
+	static_cast<int>(__x) & static_cast<int>(__y));
+  }
+
+  constexpr launch operator|(launch __x, launch __y)
+  {
+    return static_cast<launch>(
+	static_cast<int>(__x) | static_cast<int>(__y));
+  }
+
+  constexpr launch operator^(launch __x, launch __y)
+  {
+    return static_cast<launch>(
+	static_cast<int>(__x) ^ static_cast<int>(__y));
+  }
+
+  constexpr launch operator~(launch __x)
+  { return static_cast<launch>(~static_cast<int>(__x)); }
+
+  inline launch& operator&=(launch& __x, launch __y)
+  { return __x = __x & __y; }
+
+  inline launch& operator|=(launch& __x, launch __y)
+  { return __x = __x | __y; }
+
+  inline launch& operator^=(launch& __x, launch __y)
+  { return __x = __x ^ __y; }
+
+  /// Status code for futures
+  enum class future_status
+  {
+    ready,
+    timeout,
+    deferred
+  };
+
+  template<typename _Fn, typename... _Args>
+    future<typename result_of<_Fn(_Args...)>::type>
+    async(launch __policy, _Fn&& __fn, _Args&&... __args);
+
+  template<typename _Fn, typename... _Args>
+    future<typename result_of<_Fn(_Args...)>::type>
+    async(_Fn&& __fn, _Args&&... __args);
+
+#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \
+  && (ATOMIC_INT_LOCK_FREE > 1)
+
+  /// Base class and enclosing scope.
+  struct __future_base
+  {
+    /// Base class for results.
+    struct _Result_base
+    {
+      exception_ptr		_M_error;
+
+      _Result_base(const _Result_base&) = delete;
+      _Result_base& operator=(const _Result_base&) = delete;
+
+      // _M_destroy() allows derived classes to control deallocation
+      virtual void _M_destroy() = 0;
+
+      struct _Deleter
+      {
+	void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
+      };
+
+    protected:
+      _Result_base();
+      virtual ~_Result_base();
+    };
+
+    /// Result.
+    template<typename _Res>
+      struct _Result : _Result_base
+      {
+      private:
+	__gnu_cxx::__aligned_buffer<_Res>	_M_storage;
+	bool 					_M_initialized;
+
+      public:
+	typedef _Res result_type;
+
+	_Result() noexcept : _M_initialized() { }
+	
+	~_Result()
+	{
+	  if (_M_initialized)
+	    _M_value().~_Res();
+	}
+
+	// Return lvalue, future will add const or rvalue-reference
+	_Res&
+	_M_value() noexcept { return *_M_storage._M_ptr(); }
+
+	void
+	_M_set(const _Res& __res)
+	{
+	  ::new (_M_storage._M_addr()) _Res(__res);
+	  _M_initialized = true;
+	}
+
+	void
+	_M_set(_Res&& __res)
+	{
+	  ::new (_M_storage._M_addr()) _Res(std::move(__res));
+	  _M_initialized = true;
+	}
+
+      private:
+	void _M_destroy() { delete this; }
+    };
+
+    /// A unique_ptr based on the instantiating type.
+    template<typename _Res>
+      using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>;
+
+    /// Result_alloc.
+    template<typename _Res, typename _Alloc>
+      struct _Result_alloc final : _Result<_Res>, _Alloc
+      {
+        typedef typename allocator_traits<_Alloc>::template
+          rebind_alloc<_Result_alloc> __allocator_type;
+
+        explicit
+	_Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
+        { }
+	
+      private:
+	void _M_destroy()
+        {
+	  typedef allocator_traits<__allocator_type> __traits;
+          __allocator_type __a(*this);
+	  __traits::destroy(__a, this);
+	  __traits::deallocate(__a, this, 1);
+        }
+      };
+
+    template<typename _Res, typename _Allocator>
+      static _Ptr<_Result_alloc<_Res, _Allocator>>
+      _S_allocate_result(const _Allocator& __a)
+      {
+        typedef _Result_alloc<_Res, _Allocator>	__result_type;
+	typedef allocator_traits<typename __result_type::__allocator_type>
+	  __traits;
+        typename __traits::allocator_type __a2(__a);
+        __result_type* __p = __traits::allocate(__a2, 1);
+        __try
+	  {
+	    __traits::construct(__a2, __p, __a);
+	  }
+        __catch(...)
+	  {
+	    __traits::deallocate(__a2, __p, 1);
+	    __throw_exception_again;
+	  }
+        return _Ptr<__result_type>(__p);
+      }
+
+    template<typename _Res, typename _Tp>
+      static _Ptr<_Result<_Res>>
+      _S_allocate_result(const std::allocator<_Tp>& __a)
+      {
+	return _Ptr<_Result<_Res>>(new _Result<_Res>);
+      }
+
+    /// Base class for state between a promise and one or more
+    /// associated futures.
+    class _State_baseV2
+    {
+      typedef _Ptr<_Result_base> _Ptr_type;
+
+      _Ptr_type			_M_result;
+      mutex               	_M_mutex;
+      condition_variable  	_M_cond;
+      atomic_flag         	_M_retrieved;
+      once_flag			_M_once;
+
+    public:
+      _State_baseV2() noexcept : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT)
+	{ }
+      _State_baseV2(const _State_baseV2&) = delete;
+      _State_baseV2& operator=(const _State_baseV2&) = delete;
+      virtual ~_State_baseV2() = default;
+
+      _Result_base&
+      wait()
+      {
+	_M_complete_async();
+	unique_lock<mutex> __lock(_M_mutex);
+	_M_cond.wait(__lock, [&] { return _M_ready(); });
+	return *_M_result;
+      }
+
+      template<typename _Rep, typename _Period>
+        future_status
+        wait_for(const chrono::duration<_Rep, _Period>& __rel)
+        {
+	  unique_lock<mutex> __lock(_M_mutex);
+	  if (_M_ready())
+	    return future_status::ready;
+	  if (_M_has_deferred())
+	    return future_status::deferred;
+	  if (_M_cond.wait_for(__lock, __rel, [&] { return _M_ready(); }))
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 2100.  timed waiting functions must also join
+	      _M_complete_async();
+	      return future_status::ready;
+	    }
+	  return future_status::timeout;
+	}
+
+      template<typename _Clock, typename _Duration>
+        future_status
+        wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
+        {
+	  unique_lock<mutex> __lock(_M_mutex);
+	  if (_M_ready())
+	    return future_status::ready;
+	  if (_M_has_deferred())
+	    return future_status::deferred;
+	  if (_M_cond.wait_until(__lock, __abs, [&] { return _M_ready(); }))
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 2100.  timed waiting functions must also join
+	      _M_complete_async();
+	      return future_status::ready;
+	    }
+	  return future_status::timeout;
+	}
+
+      void
+      _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
+      {
+        bool __set = __ignore_failure;
+        // all calls to this function are serialized,
+        // side-effects of invoking __res only happen once
+        call_once(_M_once, &_State_baseV2::_M_do_set, this, ref(__res),
+            ref(__set));
+        if (!__set)
+          __throw_future_error(int(future_errc::promise_already_satisfied));
+      }
+
+      void
+      _M_break_promise(_Ptr_type __res)
+      {
+	if (static_cast<bool>(__res))
+	  {
+	    error_code __ec(make_error_code(future_errc::broken_promise));
+	    __res->_M_error = make_exception_ptr(future_error(__ec));
+	    {
+	      lock_guard<mutex> __lock(_M_mutex);
+	      _M_result.swap(__res);
+	    }
+	    _M_cond.notify_all();
+	  }
+      }
+
+      // Called when this object is passed to a future.
+      void
+      _M_set_retrieved_flag()
+      {
+	if (_M_retrieved.test_and_set())
+	  __throw_future_error(int(future_errc::future_already_retrieved));
+      }
+
+      template<typename _Res, typename _Arg>
+        struct _Setter;
+
+      // set lvalues
+      template<typename _Res, typename _Arg>
+        struct _Setter<_Res, _Arg&>
+        {
+          // check this is only used by promise<R>::set_value(const R&)
+          // or promise<R>::set_value(R&)
+          static_assert(is_same<_Res, _Arg&>::value  // promise<R&>
+              || is_same<const _Res, _Arg>::value,  // promise<R>
+              "Invalid specialisation");
+
+          typename promise<_Res>::_Ptr_type operator()()
+          {
+            _State_baseV2::_S_check(_M_promise->_M_future);
+            _M_promise->_M_storage->_M_set(_M_arg);
+            return std::move(_M_promise->_M_storage);
+          }
+          promise<_Res>*    _M_promise;
+          _Arg&             _M_arg;
+        };
+
+      // set rvalues
+      template<typename _Res>
+        struct _Setter<_Res, _Res&&>
+        {
+          typename promise<_Res>::_Ptr_type operator()()
+          {
+            _State_baseV2::_S_check(_M_promise->_M_future);
+            _M_promise->_M_storage->_M_set(std::move(_M_arg));
+            return std::move(_M_promise->_M_storage);
+          }
+          promise<_Res>*    _M_promise;
+          _Res&             _M_arg;
+        };
+
+      struct __exception_ptr_tag { };
+
+      // set exceptions
+      template<typename _Res>
+        struct _Setter<_Res, __exception_ptr_tag>
+        {
+          typename promise<_Res>::_Ptr_type operator()()
+          {
+            _State_baseV2::_S_check(_M_promise->_M_future);
+            _M_promise->_M_storage->_M_error = _M_ex;
+            return std::move(_M_promise->_M_storage);
+          }
+
+          promise<_Res>*   _M_promise;
+          exception_ptr&    _M_ex;
+        };
+
+      template<typename _Res, typename _Arg>
+        static _Setter<_Res, _Arg&&>
+        __setter(promise<_Res>* __prom, _Arg&& __arg)
+        {
+          return _Setter<_Res, _Arg&&>{ __prom, __arg };
+        }
+
+      template<typename _Res>
+        static _Setter<_Res, __exception_ptr_tag>
+        __setter(exception_ptr& __ex, promise<_Res>* __prom)
+        {
+          return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex };
+        }
+
+      static _Setter<void, void>
+      __setter(promise<void>* __prom);
+
+      template<typename _Tp>
+        static void
+        _S_check(const shared_ptr<_Tp>& __p)
+        {
+          if (!static_cast<bool>(__p))
+            __throw_future_error((int)future_errc::no_state);
+        }
+
+    private:
+      void
+      _M_do_set(function<_Ptr_type()>& __f, bool& __set)
+      {
+        _Ptr_type __res = __f();
+        {
+          lock_guard<mutex> __lock(_M_mutex);
+          _M_result.swap(__res);
+        }
+        _M_cond.notify_all();
+        __set = true;
+      }
+
+      bool _M_ready() const noexcept { return static_cast<bool>(_M_result); }
+
+      // Wait for completion of async function.
+      virtual void _M_complete_async() { }
+
+      // Return true if state contains a deferred function.
+      virtual bool _M_has_deferred() const { return false; }
+    };
+
+#ifdef _GLIBCXX_ASYNC_ABI_COMPAT
+    class _State_base;
+    class _Async_state_common;
+#else
+    using _State_base = _State_baseV2;
+    class _Async_state_commonV2;
+#endif
+
+    template<typename _BoundFn, typename = typename _BoundFn::result_type>
+      class _Deferred_state;
+
+    template<typename _BoundFn, typename = typename _BoundFn::result_type>
+      class _Async_state_impl;
+
+    template<typename _Signature>
+      class _Task_state_base;
+
+    template<typename _Fn, typename _Alloc, typename _Signature>
+      class _Task_state;
+
+    template<typename _BoundFn>
+      static std::shared_ptr<_State_base>
+      _S_make_deferred_state(_BoundFn&& __fn);
+
+    template<typename _BoundFn>
+      static std::shared_ptr<_State_base>
+      _S_make_async_state(_BoundFn&& __fn);
+
+    template<typename _Res_ptr,
+	     typename _Res = typename _Res_ptr::element_type::result_type>
+      struct _Task_setter;
+
+    template<typename _Res_ptr, typename _BoundFn>
+      static _Task_setter<_Res_ptr>
+      _S_task_setter(_Res_ptr& __ptr, _BoundFn&& __call)
+      {
+	return _Task_setter<_Res_ptr>{ __ptr, std::ref(__call) };
+      }
+  };
+
+  /// Partial specialization for reference types.
+  template<typename _Res>
+    struct __future_base::_Result<_Res&> : __future_base::_Result_base
+    {
+      typedef _Res& result_type;
+
+      _Result() noexcept : _M_value_ptr() { }
+
+      void _M_set(_Res& __res) noexcept { _M_value_ptr = &__res; }
+
+      _Res& _M_get() noexcept { return *_M_value_ptr; }
+
+    private:
+      _Res* 			_M_value_ptr;
+
+      void _M_destroy() { delete this; }
+    };
+
+  /// Explicit specialization for void.
+  template<>
+    struct __future_base::_Result<void> : __future_base::_Result_base
+    {
+      typedef void result_type;
+
+    private:
+      void _M_destroy() { delete this; }
+    };
+
+#ifndef _GLIBCXX_ASYNC_ABI_COMPAT
+
+  /// Common implementation for future and shared_future.
+  template<typename _Res>
+    class __basic_future : public __future_base
+    {
+    protected:
+      typedef shared_ptr<_State_base>		__state_type;
+      typedef __future_base::_Result<_Res>&	__result_type;
+
+    private:
+      __state_type 		_M_state;
+
+    public:
+      // Disable copying.
+      __basic_future(const __basic_future&) = delete;
+      __basic_future& operator=(const __basic_future&) = delete;
+
+      bool
+      valid() const noexcept { return static_cast<bool>(_M_state); }
+
+      void
+      wait() const
+      {
+        _State_base::_S_check(_M_state);
+        _M_state->wait();
+      }
+
+      template<typename _Rep, typename _Period>
+        future_status
+        wait_for(const chrono::duration<_Rep, _Period>& __rel) const
+        {
+          _State_base::_S_check(_M_state);
+          return _M_state->wait_for(__rel);
+        }
+
+      template<typename _Clock, typename _Duration>
+        future_status
+        wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
+        {
+          _State_base::_S_check(_M_state);
+          return _M_state->wait_until(__abs);
+        }
+
+    protected:
+      /// Wait for the state to be ready and rethrow any stored exception
+      __result_type
+      _M_get_result() const
+      {
+        _State_base::_S_check(_M_state);
+        _Result_base& __res = _M_state->wait();
+        if (!(__res._M_error == 0))
+          rethrow_exception(__res._M_error);
+        return static_cast<__result_type>(__res);
+      }
+
+      void _M_swap(__basic_future& __that) noexcept
+      {
+        _M_state.swap(__that._M_state);
+      }
+
+      // Construction of a future by promise::get_future()
+      explicit
+      __basic_future(const __state_type& __state) : _M_state(__state)
+      {
+        _State_base::_S_check(_M_state);
+        _M_state->_M_set_retrieved_flag();
+      }
+
+      // Copy construction from a shared_future
+      explicit
+      __basic_future(const shared_future<_Res>&) noexcept;
+
+      // Move construction from a shared_future
+      explicit
+      __basic_future(shared_future<_Res>&&) noexcept;
+
+      // Move construction from a future
+      explicit
+      __basic_future(future<_Res>&&) noexcept;
+
+      constexpr __basic_future() noexcept : _M_state() { }
+
+      struct _Reset
+      {
+        explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { }
+        ~_Reset() { _M_fut._M_state.reset(); }
+        __basic_future& _M_fut;
+      };
+    };
+
+
+  /// Primary template for future.
+  template<typename _Res>
+    class future : public __basic_future<_Res>
+    {
+      friend class promise<_Res>;
+      template<typename> friend class packaged_task;
+      template<typename _Fn, typename... _Args>
+        friend future<typename result_of<_Fn(_Args...)>::type>
+        async(launch, _Fn&&, _Args&&...);
+
+      typedef __basic_future<_Res> _Base_type;
+      typedef typename _Base_type::__state_type __state_type;
+
+      explicit
+      future(const __state_type& __state) : _Base_type(__state) { }
+
+    public:
+      constexpr future() noexcept : _Base_type() { }
+
+      /// Move constructor
+      future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
+
+      // Disable copying
+      future(const future&) = delete;
+      future& operator=(const future&) = delete;
+
+      future& operator=(future&& __fut) noexcept
+      {
+        future(std::move(__fut))._M_swap(*this);
+        return *this;
+      }
+
+      /// Retrieving the value
+      _Res
+      get()
+      {
+        typename _Base_type::_Reset __reset(*this);
+        return std::move(this->_M_get_result()._M_value());
+      }
+
+      shared_future<_Res> share();
+    };
+
+  /// Partial specialization for future<R&>
+  template<typename _Res>
+    class future<_Res&> : public __basic_future<_Res&>
+    {
+      friend class promise<_Res&>;
+      template<typename> friend class packaged_task;
+      template<typename _Fn, typename... _Args>
+        friend future<typename result_of<_Fn(_Args...)>::type>
+        async(launch, _Fn&&, _Args&&...);
+
+      typedef __basic_future<_Res&> _Base_type;
+      typedef typename _Base_type::__state_type __state_type;
+
+      explicit
+      future(const __state_type& __state) : _Base_type(__state) { }
+
+    public:
+      constexpr future() noexcept : _Base_type() { }
+
+      /// Move constructor
+      future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
+
+      // Disable copying
+      future(const future&) = delete;
+      future& operator=(const future&) = delete;
+
+      future& operator=(future&& __fut) noexcept
+      {
+        future(std::move(__fut))._M_swap(*this);
+        return *this;
+      }
+
+      /// Retrieving the value
+      _Res&
+      get()
+      {
+        typename _Base_type::_Reset __reset(*this);
+        return this->_M_get_result()._M_get();
+      }
+
+      shared_future<_Res&> share();
+    };
+
+  /// Explicit specialization for future<void>
+  template<>
+    class future<void> : public __basic_future<void>
+    {
+      friend class promise<void>;
+      template<typename> friend class packaged_task;
+      template<typename _Fn, typename... _Args>
+        friend future<typename result_of<_Fn(_Args...)>::type>
+        async(launch, _Fn&&, _Args&&...);
+
+      typedef __basic_future<void> _Base_type;
+      typedef typename _Base_type::__state_type __state_type;
+
+      explicit
+      future(const __state_type& __state) : _Base_type(__state) { }
+
+    public:
+      constexpr future() noexcept : _Base_type() { }
+
+      /// Move constructor
+      future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
+
+      // Disable copying
+      future(const future&) = delete;
+      future& operator=(const future&) = delete;
+
+      future& operator=(future&& __fut) noexcept
+      {
+        future(std::move(__fut))._M_swap(*this);
+        return *this;
+      }
+
+      /// Retrieving the value
+      void
+      get()
+      {
+        typename _Base_type::_Reset __reset(*this);
+        this->_M_get_result();
+      }
+
+      shared_future<void> share();
+    };
+
+
+  /// Primary template for shared_future.
+  template<typename _Res>
+    class shared_future : public __basic_future<_Res>
+    {
+      typedef __basic_future<_Res> _Base_type;
+
+    public:
+      constexpr shared_future() noexcept : _Base_type() { }
+
+      /// Copy constructor
+      shared_future(const shared_future& __sf) : _Base_type(__sf) { }
+
+      /// Construct from a future rvalue
+      shared_future(future<_Res>&& __uf) noexcept
+      : _Base_type(std::move(__uf))
+      { }
+
+      /// Construct from a shared_future rvalue
+      shared_future(shared_future&& __sf) noexcept
+      : _Base_type(std::move(__sf))
+      { }
+
+      shared_future& operator=(const shared_future& __sf)
+      {
+        shared_future(__sf)._M_swap(*this);
+        return *this;
+      }
+
+      shared_future& operator=(shared_future&& __sf) noexcept
+      {
+        shared_future(std::move(__sf))._M_swap(*this);
+        return *this;
+      }
+
+      /// Retrieving the value
+      const _Res&
+      get() const { return this->_M_get_result()._M_value(); }
+    };
+
+  /// Partial specialization for shared_future<R&>
+  template<typename _Res>
+    class shared_future<_Res&> : public __basic_future<_Res&>
+    {
+      typedef __basic_future<_Res&>           _Base_type;
+
+    public:
+      constexpr shared_future() noexcept : _Base_type() { }
+
+      /// Copy constructor
+      shared_future(const shared_future& __sf) : _Base_type(__sf) { }
+
+      /// Construct from a future rvalue
+      shared_future(future<_Res&>&& __uf) noexcept
+      : _Base_type(std::move(__uf))
+      { }
+
+      /// Construct from a shared_future rvalue
+      shared_future(shared_future&& __sf) noexcept
+      : _Base_type(std::move(__sf))
+      { }
+
+      shared_future& operator=(const shared_future& __sf)
+      {
+        shared_future(__sf)._M_swap(*this);
+        return *this;
+      }
+
+      shared_future& operator=(shared_future&& __sf) noexcept
+      {
+        shared_future(std::move(__sf))._M_swap(*this);
+        return *this;
+      }
+
+      /// Retrieving the value
+      _Res&
+      get() const { return this->_M_get_result()._M_get(); }
+    };
+
+  /// Explicit specialization for shared_future<void>
+  template<>
+    class shared_future<void> : public __basic_future<void>
+    {
+      typedef __basic_future<void> _Base_type;
+
+    public:
+      constexpr shared_future() noexcept : _Base_type() { }
+
+      /// Copy constructor
+      shared_future(const shared_future& __sf) : _Base_type(__sf) { }
+
+      /// Construct from a future rvalue
+      shared_future(future<void>&& __uf) noexcept
+      : _Base_type(std::move(__uf))
+      { }
+
+      /// Construct from a shared_future rvalue
+      shared_future(shared_future&& __sf) noexcept
+      : _Base_type(std::move(__sf))
+      { }
+
+      shared_future& operator=(const shared_future& __sf)
+      {
+        shared_future(__sf)._M_swap(*this);
+        return *this;
+      }
+
+      shared_future& operator=(shared_future&& __sf) noexcept
+      {
+        shared_future(std::move(__sf))._M_swap(*this);
+        return *this;
+      }
+
+      // Retrieving the value
+      void
+      get() const { this->_M_get_result(); }
+    };
+
+  // Now we can define the protected __basic_future constructors.
+  template<typename _Res>
+    inline __basic_future<_Res>::
+    __basic_future(const shared_future<_Res>& __sf) noexcept
+    : _M_state(__sf._M_state)
+    { }
+
+  template<typename _Res>
+    inline __basic_future<_Res>::
+    __basic_future(shared_future<_Res>&& __sf) noexcept
+    : _M_state(std::move(__sf._M_state))
+    { }
+
+  template<typename _Res>
+    inline __basic_future<_Res>::
+    __basic_future(future<_Res>&& __uf) noexcept
+    : _M_state(std::move(__uf._M_state))
+    { }
+
+  template<typename _Res>
+    inline shared_future<_Res>
+    future<_Res>::share()
+    { return shared_future<_Res>(std::move(*this)); }
+
+  template<typename _Res>
+    inline shared_future<_Res&>
+    future<_Res&>::share()
+    { return shared_future<_Res&>(std::move(*this)); }
+
+  inline shared_future<void>
+  future<void>::share()
+  { return shared_future<void>(std::move(*this)); }
+
+  /// Primary template for promise
+  template<typename _Res>
+    class promise
+    {
+      typedef __future_base::_State_base 	_State;
+      typedef __future_base::_Result<_Res>	_Res_type;
+      typedef __future_base::_Ptr<_Res_type>	_Ptr_type;
+      template<typename, typename> friend class _State::_Setter;
+
+      shared_ptr<_State>                        _M_future;
+      _Ptr_type                                 _M_storage;
+
+    public:
+      promise()
+      : _M_future(std::make_shared<_State>()),
+	_M_storage(new _Res_type())
+      { }
+
+      promise(promise&& __rhs) noexcept
+      : _M_future(std::move(__rhs._M_future)),
+	_M_storage(std::move(__rhs._M_storage))
+      { }
+
+      template<typename _Allocator>
+        promise(allocator_arg_t, const _Allocator& __a)
+        : _M_future(std::allocate_shared<_State>(__a)),
+	  _M_storage(__future_base::_S_allocate_result<_Res>(__a))
+        { }
+
+      template<typename _Allocator>
+        promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
+        : _M_future(std::move(__rhs._M_future)),
+	  _M_storage(std::move(__rhs._M_storage))
+        { }
+
+      promise(const promise&) = delete;
+
+      ~promise()
+      {
+        if (static_cast<bool>(_M_future) && !_M_future.unique())
+          _M_future->_M_break_promise(std::move(_M_storage));
+      }
+
+      // Assignment
+      promise&
+      operator=(promise&& __rhs) noexcept
+      {
+        promise(std::move(__rhs)).swap(*this);
+        return *this;
+      }
+
+      promise& operator=(const promise&) = delete;
+
+      void
+      swap(promise& __rhs) noexcept
+      {
+        _M_future.swap(__rhs._M_future);
+        _M_storage.swap(__rhs._M_storage);
+      }
+
+      // Retrieving the result
+      future<_Res>
+      get_future()
+      { return future<_Res>(_M_future); }
+
+      // Setting the result
+      void
+      set_value(const _Res& __r)
+      {
+        auto __setter = _State::__setter(this, __r);
+        _M_future->_M_set_result(std::move(__setter));
+      }
+
+      void
+      set_value(_Res&& __r)
+      {
+        auto __setter = _State::__setter(this, std::move(__r));
+        _M_future->_M_set_result(std::move(__setter));
+      }
+
+      void
+      set_exception(exception_ptr __p)
+      {
+        auto __setter = _State::__setter(__p, this);
+        _M_future->_M_set_result(std::move(__setter));
+      }
+    };
+
+  template<typename _Res>
+    inline void
+    swap(promise<_Res>& __x, promise<_Res>& __y) noexcept
+    { __x.swap(__y); }
+
+  template<typename _Res, typename _Alloc>
+    struct uses_allocator<promise<_Res>, _Alloc>
+    : public true_type { };
+
+
+  /// Partial specialization for promise<R&>
+  template<typename _Res>
+    class promise<_Res&>
+    {
+      typedef __future_base::_State_base	_State;
+      typedef __future_base::_Result<_Res&>	_Res_type;
+      typedef __future_base::_Ptr<_Res_type> 	_Ptr_type;
+      template<typename, typename> friend class _State::_Setter;
+
+      shared_ptr<_State>                        _M_future;
+      _Ptr_type                                 _M_storage;
+
+    public:
+      promise()
+      : _M_future(std::make_shared<_State>()),
+	_M_storage(new _Res_type())
+      { }
+
+      promise(promise&& __rhs) noexcept
+      : _M_future(std::move(__rhs._M_future)),
+	_M_storage(std::move(__rhs._M_storage))
+      { }
+
+      template<typename _Allocator>
+        promise(allocator_arg_t, const _Allocator& __a)
+        : _M_future(std::allocate_shared<_State>(__a)),
+	  _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
+        { }
+
+      template<typename _Allocator>
+        promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
+        : _M_future(std::move(__rhs._M_future)),
+	  _M_storage(std::move(__rhs._M_storage))
+        { }
+
+      promise(const promise&) = delete;
+
+      ~promise()
+      {
+        if (static_cast<bool>(_M_future) && !_M_future.unique())
+          _M_future->_M_break_promise(std::move(_M_storage));
+      }
+
+      // Assignment
+      promise&
+      operator=(promise&& __rhs) noexcept
+      {
+        promise(std::move(__rhs)).swap(*this);
+        return *this;
+      }
+
+      promise& operator=(const promise&) = delete;
+
+      void
+      swap(promise& __rhs) noexcept
+      {
+        _M_future.swap(__rhs._M_future);
+        _M_storage.swap(__rhs._M_storage);
+      }
+
+      // Retrieving the result
+      future<_Res&>
+      get_future()
+      { return future<_Res&>(_M_future); }
+
+      // Setting the result
+      void
+      set_value(_Res& __r)
+      {
+        auto __setter = _State::__setter(this, __r);
+        _M_future->_M_set_result(std::move(__setter));
+      }
+
+      void
+      set_exception(exception_ptr __p)
+      {
+        auto __setter = _State::__setter(__p, this);
+        _M_future->_M_set_result(std::move(__setter));
+      }
+    };
+
+  /// Explicit specialization for promise<void>
+  template<>
+    class promise<void>
+    {
+      typedef __future_base::_State_base	_State;
+      typedef __future_base::_Result<void>	_Res_type;
+      typedef __future_base::_Ptr<_Res_type> 	_Ptr_type;
+      template<typename, typename> friend class _State::_Setter;
+
+      shared_ptr<_State>                        _M_future;
+      _Ptr_type                                 _M_storage;
+
+    public:
+      promise()
+      : _M_future(std::make_shared<_State>()),
+	_M_storage(new _Res_type())
+      { }
+
+      promise(promise&& __rhs) noexcept
+      : _M_future(std::move(__rhs._M_future)),
+	_M_storage(std::move(__rhs._M_storage))
+      { }
+
+      template<typename _Allocator>
+        promise(allocator_arg_t, const _Allocator& __a)
+        : _M_future(std::allocate_shared<_State>(__a)),
+	  _M_storage(__future_base::_S_allocate_result<void>(__a))
+        { }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2095.  missing constructors needed for uses-allocator construction
+      template<typename _Allocator>
+        promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
+        : _M_future(std::move(__rhs._M_future)),
+	  _M_storage(std::move(__rhs._M_storage))
+        { }
+
+      promise(const promise&) = delete;
+
+      ~promise()
+      {
+        if (static_cast<bool>(_M_future) && !_M_future.unique())
+          _M_future->_M_break_promise(std::move(_M_storage));
+      }
+
+      // Assignment
+      promise&
+      operator=(promise&& __rhs) noexcept
+      {
+        promise(std::move(__rhs)).swap(*this);
+        return *this;
+      }
+
+      promise& operator=(const promise&) = delete;
+
+      void
+      swap(promise& __rhs) noexcept
+      {
+        _M_future.swap(__rhs._M_future);
+        _M_storage.swap(__rhs._M_storage);
+      }
+
+      // Retrieving the result
+      future<void>
+      get_future()
+      { return future<void>(_M_future); }
+
+      // Setting the result
+      void set_value();
+
+      void
+      set_exception(exception_ptr __p)
+      {
+        auto __setter = _State::__setter(__p, this);
+        _M_future->_M_set_result(std::move(__setter));
+      }
+    };
+
+  // set void
+  template<>
+    struct __future_base::_State_base::_Setter<void, void>
+    {
+      promise<void>::_Ptr_type operator()()
+      {
+        _State_base::_S_check(_M_promise->_M_future);
+        return std::move(_M_promise->_M_storage);
+      }
+
+      promise<void>*    _M_promise;
+    };
+
+  inline __future_base::_State_base::_Setter<void, void>
+  __future_base::_State_base::__setter(promise<void>* __prom)
+  {
+    return _Setter<void, void>{ __prom };
+  }
+
+  inline void
+  promise<void>::set_value()
+  {
+    auto __setter = _State::__setter(this);
+    _M_future->_M_set_result(std::move(__setter));
+  }
+
+
+  template<typename _Ptr_type, typename _Res>
+    struct __future_base::_Task_setter
+    {
+      _Ptr_type operator()()
+      {
+	__try
+	  {
+	    _M_result->_M_set(_M_fn());
+	  }
+	__catch(...)
+	  {
+	    _M_result->_M_error = current_exception();
+	  }
+	return std::move(_M_result);
+      }
+      _Ptr_type&                _M_result;
+      std::function<_Res()>     _M_fn;
+    };
+
+  template<typename _Ptr_type>
+    struct __future_base::_Task_setter<_Ptr_type, void>
+    {
+      _Ptr_type operator()()
+      {
+	__try
+	  {
+	    _M_fn();
+	  }
+	__catch(...)
+	  {
+	    _M_result->_M_error = current_exception();
+	  }
+	return std::move(_M_result);
+      }
+      _Ptr_type&                _M_result;
+      std::function<void()>     _M_fn;
+    };
+
+  template<typename _Res, typename... _Args>
+    struct __future_base::_Task_state_base<_Res(_Args...)>
+    : __future_base::_State_base
+    {
+      typedef _Res _Res_type;
+
+      template<typename _Alloc>
+	_Task_state_base(const _Alloc& __a)
+	: _M_result(_S_allocate_result<_Res>(__a))
+	{ }
+
+      virtual void
+      _M_run(_Args... __args) = 0;
+
+      virtual shared_ptr<_Task_state_base>
+      _M_reset() = 0;
+
+      typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
+      _Ptr_type _M_result;
+    };
+
+  template<typename _Fn, typename _Alloc, typename _Res, typename... _Args>
+    struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final
+    : __future_base::_Task_state_base<_Res(_Args...)>
+    {
+      template<typename _Fn2>
+	_Task_state(_Fn2&& __fn, const _Alloc& __a)
+	: _Task_state_base<_Res(_Args...)>(__a),
+	  _M_impl(std::forward<_Fn2>(__fn), __a)
+	{ }
+
+    private:
+      virtual void
+      _M_run(_Args... __args)
+      {
+	// bound arguments decay so wrap lvalue references
+	auto __boundfn = std::__bind_simple(std::ref(_M_impl._M_fn),
+	    _S_maybe_wrap_ref(std::forward<_Args>(__args))...);
+	auto __setter = _S_task_setter(this->_M_result, std::move(__boundfn));
+	this->_M_set_result(std::move(__setter));
+      }
+
+      virtual shared_ptr<_Task_state_base<_Res(_Args...)>>
+      _M_reset();
+
+      template<typename _Tp>
+	static reference_wrapper<_Tp>
+	_S_maybe_wrap_ref(_Tp& __t)
+	{ return std::ref(__t); }
+
+      template<typename _Tp>
+	static
+	typename enable_if<!is_lvalue_reference<_Tp>::value, _Tp>::type&&
+	_S_maybe_wrap_ref(_Tp&& __t)
+	{ return std::forward<_Tp>(__t); }
+
+      struct _Impl : _Alloc
+      {
+	template<typename _Fn2>
+	  _Impl(_Fn2&& __fn, const _Alloc& __a)
+	  : _Alloc(__a), _M_fn(std::forward<_Fn2>(__fn)) { }
+	_Fn _M_fn;
+      } _M_impl;
+    };
+
+  template<typename _Signature, typename _Fn, typename _Alloc>
+    static shared_ptr<__future_base::_Task_state_base<_Signature>>
+    __create_task_state(_Fn&& __fn, const _Alloc& __a)
+    {
+      typedef typename decay<_Fn>::type _Fn2;
+      typedef __future_base::_Task_state<_Fn2, _Alloc, _Signature> _State;
+      return std::allocate_shared<_State>(__a, std::forward<_Fn>(__fn), __a);
+    }
+
+  template<typename _Fn, typename _Alloc, typename _Res, typename... _Args>
+    shared_ptr<__future_base::_Task_state_base<_Res(_Args...)>>
+    __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)>::_M_reset()
+    {
+      return __create_task_state<_Res(_Args...)>(std::move(_M_impl._M_fn),
+						 static_cast<_Alloc&>(_M_impl));
+    }
+
+  template<typename _Task, typename _Fn, bool
+	   = is_same<_Task, typename decay<_Fn>::type>::value>
+    struct __constrain_pkgdtask
+    { typedef void __type; };
+
+  template<typename _Task, typename _Fn>
+    struct __constrain_pkgdtask<_Task, _Fn, true>
+    { };
+
+  /// packaged_task
+  template<typename _Res, typename... _ArgTypes>
+    class packaged_task<_Res(_ArgTypes...)>
+    {
+      typedef __future_base::_Task_state_base<_Res(_ArgTypes...)> _State_type;
+      shared_ptr<_State_type>                   _M_state;
+
+    public:
+      // Construction and destruction
+      packaged_task() noexcept { }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2095.  missing constructors needed for uses-allocator construction
+      template<typename _Allocator>
+	packaged_task(allocator_arg_t, const _Allocator& __a) noexcept
+	{ }
+
+      template<typename _Fn, typename = typename
+	       __constrain_pkgdtask<packaged_task, _Fn>::__type>
+	explicit
+	packaged_task(_Fn&& __fn)
+	: packaged_task(allocator_arg, std::allocator<int>(),
+			std::forward<_Fn>(__fn))
+	{ }
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2097.  packaged_task constructors should be constrained
+      template<typename _Fn, typename _Alloc, typename = typename
+	       __constrain_pkgdtask<packaged_task, _Fn>::__type>
+	explicit
+	packaged_task(allocator_arg_t, const _Alloc& __a, _Fn&& __fn)
+	: _M_state(__create_task_state<_Res(_ArgTypes...)>(
+		    std::forward<_Fn>(__fn), __a))
+	{ }
+
+      ~packaged_task()
+      {
+        if (static_cast<bool>(_M_state) && !_M_state.unique())
+	  _M_state->_M_break_promise(std::move(_M_state->_M_result));
+      }
+
+      // No copy
+      packaged_task(const packaged_task&) = delete;
+      packaged_task& operator=(const packaged_task&) = delete;
+
+      template<typename _Allocator>
+	packaged_task(allocator_arg_t, const _Allocator&,
+		      const packaged_task&) = delete;
+
+      // Move support
+      packaged_task(packaged_task&& __other) noexcept
+      { this->swap(__other); }
+
+      template<typename _Allocator>
+	packaged_task(allocator_arg_t, const _Allocator&,
+		      packaged_task&& __other) noexcept
+	{ this->swap(__other); }
+
+      packaged_task& operator=(packaged_task&& __other) noexcept
+      {
+	packaged_task(std::move(__other)).swap(*this);
+	return *this;
+      }
+
+      void
+      swap(packaged_task& __other) noexcept
+      { _M_state.swap(__other._M_state); }
+
+      bool
+      valid() const noexcept
+      { return static_cast<bool>(_M_state); }
+
+      // Result retrieval
+      future<_Res>
+      get_future()
+      { return future<_Res>(_M_state); }
+
+      // Execution
+      void
+      operator()(_ArgTypes... __args)
+      {
+	__future_base::_State_base::_S_check(_M_state);
+	_M_state->_M_run(std::forward<_ArgTypes>(__args)...);
+      }
+
+      void
+      reset()
+      {
+	__future_base::_State_base::_S_check(_M_state);
+	packaged_task __tmp;
+	__tmp._M_state = _M_state;
+	_M_state = _M_state->_M_reset();
+      }
+    };
+
+  /// swap
+  template<typename _Res, typename... _ArgTypes>
+    inline void
+    swap(packaged_task<_Res(_ArgTypes...)>& __x,
+	 packaged_task<_Res(_ArgTypes...)>& __y) noexcept
+    { __x.swap(__y); }
+
+  template<typename _Res, typename _Alloc>
+    struct uses_allocator<packaged_task<_Res>, _Alloc>
+    : public true_type { };
+
+
+  template<typename _BoundFn, typename _Res>
+    class __future_base::_Deferred_state final
+    : public __future_base::_State_base
+    {
+    public:
+      explicit
+      _Deferred_state(_BoundFn&& __fn)
+      : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
+      { }
+
+    private:
+      typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
+      _Ptr_type _M_result;
+      _BoundFn _M_fn;
+
+      // Run the deferred function.
+      virtual void
+      _M_complete_async()
+      {
+        // safe to call multiple times so ignore failure
+        _M_set_result(_S_task_setter(_M_result, _M_fn), true);
+      }
+
+      virtual bool
+      _M_has_deferred() const { return static_cast<bool>(_M_result); }
+    };
+
+  class __future_base::_Async_state_commonV2
+    : public __future_base::_State_base
+  {
+  protected:
+    ~_Async_state_commonV2() = default;
+
+    // Make waiting functions block until the thread completes, as if joined.
+    virtual void _M_complete_async() { _M_join(); }
+
+    void _M_join() { std::call_once(_M_once, &thread::join, ref(_M_thread)); }
+
+    thread _M_thread;
+    once_flag _M_once;
+  };
+
+  template<typename _BoundFn, typename _Res>
+    class __future_base::_Async_state_impl final
+    : public __future_base::_Async_state_commonV2
+    {
+    public:
+      explicit
+      _Async_state_impl(_BoundFn&& __fn)
+      : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
+      {
+	_M_thread = std::thread{ [this] {
+	  _M_set_result(_S_task_setter(_M_result, _M_fn));
+        } };
+      }
+
+      ~_Async_state_impl() { _M_join(); }
+
+    private:
+      typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
+      _Ptr_type _M_result;
+      _BoundFn _M_fn;
+    };
+
+  template<typename _BoundFn>
+    inline std::shared_ptr<__future_base::_State_base>
+    __future_base::_S_make_deferred_state(_BoundFn&& __fn)
+    {
+      typedef typename remove_reference<_BoundFn>::type __fn_type;
+      typedef _Deferred_state<__fn_type> __state_type;
+      return std::make_shared<__state_type>(std::move(__fn));
+    }
+
+  template<typename _BoundFn>
+    inline std::shared_ptr<__future_base::_State_base>
+    __future_base::_S_make_async_state(_BoundFn&& __fn)
+    {
+      typedef typename remove_reference<_BoundFn>::type __fn_type;
+      typedef _Async_state_impl<__fn_type> __state_type;
+      return std::make_shared<__state_type>(std::move(__fn));
+    }
+
+
+  /// async
+  template<typename _Fn, typename... _Args>
+    future<typename result_of<_Fn(_Args...)>::type>
+    async(launch __policy, _Fn&& __fn, _Args&&... __args)
+    {
+      typedef typename result_of<_Fn(_Args...)>::type result_type;
+      std::shared_ptr<__future_base::_State_base> __state;
+      if ((__policy & (launch::async|launch::deferred)) == launch::async)
+	{
+	  __state = __future_base::_S_make_async_state(std::__bind_simple(
+              std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
+	}
+      else
+	{
+	  __state = __future_base::_S_make_deferred_state(std::__bind_simple(
+              std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
+	}
+      return future<result_type>(__state);
+    }
+
+  /// async, potential overload
+  template<typename _Fn, typename... _Args>
+    inline future<typename result_of<_Fn(_Args...)>::type>
+    async(_Fn&& __fn, _Args&&... __args)
+    {
+      return async(launch::async|launch::deferred, std::forward<_Fn>(__fn),
+		   std::forward<_Args>(__args)...);
+    }
+
+#endif // _GLIBCXX_ASYNC_ABI_COMPAT
+#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
+       // && ATOMIC_INT_LOCK_FREE
+
+  // @} group futures
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // C++11
+
+#endif // _GLIBCXX_FUTURE
diff --git a/gcc-4.9/libstdc++-v3/include/std/iomanip b/gcc-4.9/libstdc++-v3/include/std/iomanip
new file mode 100644
index 0000000..b2c7b95
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/iomanip
@@ -0,0 +1,531 @@
+// Standard stream manipulators -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/iomanip
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.6.3  Standard manipulators
+//
+
+#ifndef _GLIBCXX_IOMANIP
+#define _GLIBCXX_IOMANIP 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <iosfwd>
+#include <bits/ios_base.h>
+
+#if __cplusplus >= 201103L
+#include <locale>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // [27.6.3] standard manipulators
+  // Also see DR 183.
+
+  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
+
+  /**
+   *  @brief  Manipulator for @c setf.
+   *  @param  __mask  A format flags mask.
+   *
+   *  Sent to a stream object, this manipulator resets the specified flags,
+   *  via @e stream.setf(0,__mask).
+  */
+  inline _Resetiosflags 
+  resetiosflags(ios_base::fmtflags __mask)
+  { return { __mask }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>& 
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
+    { 
+      __is.setf(ios_base::fmtflags(0), __f._M_mask); 
+      return __is; 
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>& 
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
+    { 
+      __os.setf(ios_base::fmtflags(0), __f._M_mask); 
+      return __os; 
+    }
+
+
+  struct _Setiosflags { ios_base::fmtflags _M_mask; };
+
+  /**
+   *  @brief  Manipulator for @c setf.
+   *  @param  __mask  A format flags mask.
+   *
+   *  Sent to a stream object, this manipulator sets the format flags
+   *  to @a __mask.
+  */
+  inline _Setiosflags 
+  setiosflags(ios_base::fmtflags __mask)
+  { return { __mask }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>& 
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
+    { 
+      __is.setf(__f._M_mask); 
+      return __is; 
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>& 
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
+    { 
+      __os.setf(__f._M_mask); 
+      return __os; 
+    }
+
+
+  struct _Setbase { int _M_base; };
+
+  /**
+   *  @brief  Manipulator for @c setf.
+   *  @param  __base  A numeric base.
+   *
+   *  Sent to a stream object, this manipulator changes the
+   *  @c ios_base::basefield flags to @c oct, @c dec, or @c hex when @a base
+   *  is 8, 10, or 16, accordingly, and to 0 if @a __base is any other value.
+  */
+  inline _Setbase 
+  setbase(int __base)
+  { return { __base }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>& 
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
+    {
+      __is.setf(__f._M_base ==  8 ? ios_base::oct : 
+		__f._M_base == 10 ? ios_base::dec : 
+		__f._M_base == 16 ? ios_base::hex : 
+		ios_base::fmtflags(0), ios_base::basefield);
+      return __is; 
+    }
+  
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>& 
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
+    {
+      __os.setf(__f._M_base ==  8 ? ios_base::oct : 
+		__f._M_base == 10 ? ios_base::dec : 
+		__f._M_base == 16 ? ios_base::hex : 
+		ios_base::fmtflags(0), ios_base::basefield);
+      return __os; 
+    }
+  
+
+  template<typename _CharT>
+    struct _Setfill { _CharT _M_c; };
+
+  /**
+   *  @brief  Manipulator for @c fill.
+   *  @param  __c  The new fill character.
+   *
+   *  Sent to a stream object, this manipulator calls @c fill(__c) for that
+   *  object.
+  */
+  template<typename _CharT>
+    inline _Setfill<_CharT>
+    setfill(_CharT __c)
+    { return { __c }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>& 
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
+    { 
+      __is.fill(__f._M_c); 
+      return __is; 
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>& 
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
+    { 
+      __os.fill(__f._M_c); 
+      return __os; 
+    }
+
+
+  struct _Setprecision { int _M_n; };
+
+  /**
+   *  @brief  Manipulator for @c precision.
+   *  @param  __n  The new precision.
+   *
+   *  Sent to a stream object, this manipulator calls @c precision(__n) for
+   *  that object.
+  */
+  inline _Setprecision 
+  setprecision(int __n)
+  { return { __n }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>& 
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
+    { 
+      __is.precision(__f._M_n); 
+      return __is; 
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>& 
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
+    { 
+      __os.precision(__f._M_n); 
+      return __os; 
+    }
+
+
+  struct _Setw { int _M_n; };
+
+  /**
+   *  @brief  Manipulator for @c width.
+   *  @param  __n  The new width.
+   *
+   *  Sent to a stream object, this manipulator calls @c width(__n) for
+   *  that object.
+  */
+  inline _Setw 
+  setw(int __n)
+  { return { __n }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>& 
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
+    {
+      __is.width(__f._M_n);
+      return __is; 
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>& 
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
+    {
+      __os.width(__f._M_n);
+      return __os; 
+    }
+
+#if __cplusplus >= 201103L
+  
+  template<typename _MoneyT>
+    struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
+
+  /**
+   *  @brief  Extended manipulator for extracting money.
+   *  @param  __mon  Either long double or a specialization of @c basic_string.
+   *  @param  __intl A bool indicating whether international format 
+   *                 is to be used.
+   *
+   *  Sent to a stream object, this manipulator extracts @a __mon.
+  */
+  template<typename _MoneyT>
+    inline _Get_money<_MoneyT>
+    get_money(_MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
+    {
+      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      typedef istreambuf_iterator<_CharT, _Traits>   _Iter;
+	      typedef money_get<_CharT, _Iter>               _MoneyGet;
+
+	      const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
+	      __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
+		       __is, __err, __f._M_mon);
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __is._M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __is._M_setstate(ios_base::badbit); }
+	  if (__err)
+	    __is.setstate(__err);
+	}
+      return __is; 
+    }
+
+
+  template<typename _MoneyT>
+    struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
+
+  /**
+   *  @brief  Extended manipulator for inserting money.
+   *  @param  __mon  Either long double or a specialization of @c basic_string.
+   *  @param  __intl A bool indicating whether international format 
+   *                 is to be used.
+   *
+   *  Sent to a stream object, this manipulator inserts @a __mon.
+  */
+  template<typename _MoneyT>
+    inline _Put_money<_MoneyT>
+    put_money(const _MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_ostream<_CharT, _Traits>& 
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
+    {
+      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
+      if (__cerb)
+	{
+	  ios_base::iostate __err = ios_base::goodbit;
+	  __try
+	    {
+	      typedef ostreambuf_iterator<_CharT, _Traits>   _Iter;
+	      typedef money_put<_CharT, _Iter>               _MoneyPut;
+
+	      const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
+	      if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
+			   __os.fill(), __f._M_mon).failed())
+		__err |= ios_base::badbit;
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __os._M_setstate(ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __os._M_setstate(ios_base::badbit); }
+	  if (__err)
+	    __os.setstate(__err);
+	}
+      return __os; 
+    }
+
+#if __cplusplus > 201103L
+
+_GLIBCXX_END_NAMESPACE_VERSION
+  namespace __detail {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     * @brief Struct for delimited strings.
+     *        The left and right delimiters can be different.
+     */
+    template<typename _String, typename _CharT>
+      struct _Quoted_string
+      {
+	static_assert(is_reference<_String>::value
+		   || is_pointer<_String>::value,
+		      "String type must be pointer or reference");
+
+	_Quoted_string(_String __str, _CharT __del, _CharT __esc)
+	: _M_string(__str), _M_delim{__del}, _M_escape{__esc}
+	{ }
+
+	_Quoted_string&
+	operator=(_Quoted_string&) = delete;
+
+	_String _M_string;
+	_CharT _M_delim;
+	_CharT _M_escape;
+      };
+
+    /**
+     * @brief Inserter for delimited strings.
+     *        The left and right delimiters can be different.
+     */
+    template<typename _CharT, typename _Traits>
+      auto&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		 const _Quoted_string<const _CharT*, _CharT>& __str)
+      {
+	__os << __str._M_delim;
+	for (const _CharT* __c = __str._M_string; *__c; ++__c)
+	  {
+	    if (*__c == __str._M_delim || *__c == __str._M_escape)
+	      __os << __str._M_escape;
+	    __os << *__c;
+	  }
+	__os << __str._M_delim;
+
+	return __os;
+      }
+
+    /**
+     * @brief Inserter for delimited strings.
+     *        The left and right delimiters can be different.
+     */
+    template<typename _CharT, typename _Traits, typename _String>
+      auto&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		 const _Quoted_string<_String, _CharT>& __str)
+      {
+	__os << __str._M_delim;
+	for (auto& __c : __str._M_string)
+	  {
+	    if (__c == __str._M_delim || __c == __str._M_escape)
+	      __os << __str._M_escape;
+	    __os << __c;
+	  }
+	__os << __str._M_delim;
+
+	return __os;
+      }
+
+    /**
+     * @brief Extractor for delimited strings.
+     *        The left and right delimiters can be different.
+     */
+    template<typename _CharT, typename _Traits, typename _Alloc>
+      auto&
+      operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		 const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
+				      _CharT>& __str)
+      {
+	__str._M_string.clear();
+
+	_CharT __c;
+	__is >> __c;
+	if (!__is.good())
+	  return __is;
+	if (__c != __str._M_delim)
+	  {
+	    __is.unget();
+	    __is >> __str._M_string;
+	    return __is;
+	  }
+	std::ios_base::fmtflags __flags
+	  = __is.flags(__is.flags() & ~std::ios_base::skipws);
+	do
+	  {
+	    __is >> __c;
+	    if (!__is.good())
+	      break;
+	    if (__c == __str._M_escape)
+	      {
+		__is >> __c;
+		if (!__is.good())
+		  break;
+	      }
+	    else if (__c == __str._M_delim)
+	      break;
+	    __str._M_string += __c;
+	  }
+	while (true);
+	__is.setf(__flags);
+
+	return __is;
+      }
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace __detail
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @brief Manipulator for quoted strings.
+   * @param __str    String to quote.
+   * @param __delim  Character to quote string with.
+   * @param __escape Escape character to escape itself or quote character.
+   */
+  template<typename _CharT>
+    inline auto
+    quoted(const _CharT* __string,
+	   _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<const _CharT*, _CharT>(__string, __delim,
+							     __escape);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline auto
+    quoted(const basic_string<_CharT, _Traits, _Alloc>& __string,
+	   _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<
+			const basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
+				__string, __delim, __escape);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline auto
+    quoted(basic_string<_CharT, _Traits, _Alloc>& __string,
+	   _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<
+			basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
+				__string, __delim, __escape);
+    }
+
+#endif // __cplusplus > 201103L
+
+#endif // __cplusplus >= 201103L
+
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.  
+  // NB:  This syntax is a GNU extension.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template ostream& operator<<(ostream&, _Setfill<char>);
+  extern template ostream& operator<<(ostream&, _Setiosflags);
+  extern template ostream& operator<<(ostream&, _Resetiosflags);
+  extern template ostream& operator<<(ostream&, _Setbase);
+  extern template ostream& operator<<(ostream&, _Setprecision);
+  extern template ostream& operator<<(ostream&, _Setw);
+  extern template istream& operator>>(istream&, _Setfill<char>);
+  extern template istream& operator>>(istream&, _Setiosflags);
+  extern template istream& operator>>(istream&, _Resetiosflags);
+  extern template istream& operator>>(istream&, _Setbase);
+  extern template istream& operator>>(istream&, _Setprecision);
+  extern template istream& operator>>(istream&, _Setw);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
+  extern template wostream& operator<<(wostream&, _Setiosflags);
+  extern template wostream& operator<<(wostream&, _Resetiosflags);
+  extern template wostream& operator<<(wostream&, _Setbase);
+  extern template wostream& operator<<(wostream&, _Setprecision);
+  extern template wostream& operator<<(wostream&, _Setw);
+  extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
+  extern template wistream& operator>>(wistream&, _Setiosflags);
+  extern template wistream& operator>>(wistream&, _Resetiosflags);
+  extern template wistream& operator>>(wistream&, _Setbase);
+  extern template wistream& operator>>(wistream&, _Setprecision);
+  extern template wistream& operator>>(wistream&, _Setw);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GLIBCXX_IOMANIP */
diff --git a/gcc-4.9/libstdc++-v3/include/std/ios b/gcc-4.9/libstdc++-v3/include/std/ios
new file mode 100644
index 0000000..5d69c4b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/ios
@@ -0,0 +1,46 @@
+// Iostreams base classes -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/ios
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.4  Iostreams base classes
+//
+
+#ifndef _GLIBCXX_IOS
+#define _GLIBCXX_IOS 1
+
+#pragma GCC system_header
+
+#include <iosfwd>
+#include <exception> 		// For ios_base::failure
+#include <bits/char_traits.h> 	// For char_traits, streamoff, streamsize, fpos
+#include <bits/localefwd.h>	// For class locale
+#include <bits/ios_base.h>	// For ios_base declarations.
+#include <streambuf> 
+#include <bits/basic_ios.h>
+
+#endif	/* _GLIBCXX_IOS */
diff --git a/gcc-4.9/libstdc++-v3/include/std/iosfwd b/gcc-4.9/libstdc++-v3/include/std/iosfwd
new file mode 100644
index 0000000..50dd949
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/iosfwd
@@ -0,0 +1,210 @@
+// <iosfwd> Forward declarations -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/iosfwd
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.2  Forward declarations
+//
+
+#ifndef _GLIBCXX_IOSFWD
+#define _GLIBCXX_IOSFWD 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stringfwd.h> 	// For string forward declarations.
+#include <bits/postypes.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @defgroup io I/O
+   *
+   *  Nearly all of the I/O classes are parameterized on the type of
+   *  characters they read and write.  (The major exception is ios_base at
+   *  the top of the hierarchy.)  This is a change from pre-Standard
+   *  streams, which were not templates.
+   *
+   *  For ease of use and compatibility, all of the basic_* I/O-related
+   *  classes are given typedef names for both of the builtin character
+   *  widths (wide and narrow).  The typedefs are the same as the
+   *  pre-Standard names, for example:
+   *
+   *  @code
+   *     typedef basic_ifstream<char>  ifstream;
+   *  @endcode
+   *
+   *  Because properly forward-declaring these classes can be difficult, you
+   *  should not do it yourself.  Instead, include the &lt;iosfwd&gt;
+   *  header, which contains only declarations of all the I/O classes as
+   *  well as the typedefs.  Trying to forward-declare the typedefs
+   *  themselves (e.g., <code>class ostream;</code>) is not valid ISO C++.
+   *
+   *  For more specific declarations, see
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html
+   *
+   *  @{
+  */
+  class ios_base;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+	    typename _Alloc = allocator<_CharT> >
+    class basic_stringbuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+	   typename _Alloc = allocator<_CharT> >
+    class basic_istringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+	   typename _Alloc = allocator<_CharT> >
+    class basic_ostringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+	   typename _Alloc = allocator<_CharT> >
+    class basic_stringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_filebuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ifstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ofstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_fstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class ostreambuf_iterator;
+
+
+  /// Base class for @c char streams.
+  typedef basic_ios<char> 		ios; 
+
+  /// Base class for @c char buffers.
+  typedef basic_streambuf<char> 	streambuf;
+
+  /// Base class for @c char input streams.
+  typedef basic_istream<char> 		istream;
+
+  /// Base class for @c char output streams.
+  typedef basic_ostream<char> 		ostream;
+
+  /// Base class for @c char mixed input and output streams.
+  typedef basic_iostream<char> 		iostream;
+
+  /// Class for @c char memory buffers.
+  typedef basic_stringbuf<char> 	stringbuf;
+
+  /// Class for @c char input memory streams.
+  typedef basic_istringstream<char> 	istringstream;
+
+  /// Class for @c char output memory streams.
+  typedef basic_ostringstream<char> 	ostringstream;
+
+  /// Class for @c char mixed input and output memory streams.
+  typedef basic_stringstream<char> 	stringstream;
+
+  /// Class for @c char file buffers.
+  typedef basic_filebuf<char> 		filebuf;
+
+  /// Class for @c char input file streams.
+  typedef basic_ifstream<char> 		ifstream;
+
+  /// Class for @c char output file streams.
+  typedef basic_ofstream<char> 		ofstream;
+
+  /// Class for @c char mixed input and output file streams.
+  typedef basic_fstream<char> 		fstream;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /// Base class for @c wchar_t streams.
+  typedef basic_ios<wchar_t> 		wios;
+
+  /// Base class for @c wchar_t buffers.
+  typedef basic_streambuf<wchar_t> 	wstreambuf;
+
+  /// Base class for @c wchar_t input streams.
+  typedef basic_istream<wchar_t> 	wistream;
+
+  /// Base class for @c wchar_t output streams.
+  typedef basic_ostream<wchar_t> 	wostream;
+
+  /// Base class for @c wchar_t mixed input and output streams.
+  typedef basic_iostream<wchar_t> 	wiostream;
+
+  /// Class for @c wchar_t memory buffers.
+  typedef basic_stringbuf<wchar_t> 	wstringbuf;
+
+  /// Class for @c wchar_t input memory streams.
+  typedef basic_istringstream<wchar_t> 	wistringstream;
+
+  /// Class for @c wchar_t output memory streams.
+  typedef basic_ostringstream<wchar_t> 	wostringstream;
+
+  /// Class for @c wchar_t mixed input and output memory streams.
+  typedef basic_stringstream<wchar_t> 	wstringstream;
+
+  /// Class for @c wchar_t file buffers.
+  typedef basic_filebuf<wchar_t> 	wfilebuf;
+
+  /// Class for @c wchar_t input file streams.
+  typedef basic_ifstream<wchar_t> 	wifstream;
+
+  /// Class for @c wchar_t output file streams.
+  typedef basic_ofstream<wchar_t> 	wofstream;
+
+  /// Class for @c wchar_t mixed input and output file streams.
+  typedef basic_fstream<wchar_t> 	wfstream;
+#endif
+  /** @}  */
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GLIBCXX_IOSFWD */
diff --git a/gcc-4.9/libstdc++-v3/include/std/iostream b/gcc-4.9/libstdc++-v3/include/std/iostream
new file mode 100644
index 0000000..85d2b95
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/iostream
@@ -0,0 +1,79 @@
+// Standard iostream objects -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/iostream
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.3  Standard iostream objects
+//
+
+#ifndef _GLIBCXX_IOSTREAM
+#define _GLIBCXX_IOSTREAM 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <ostream>
+#include <istream>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @name Standard Stream Objects
+   *
+   *  The &lt;iostream&gt; header declares the eight <em>standard stream
+   *  objects</em>.  For other declarations, see
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html
+   *  and the @link iosfwd I/O forward declarations @endlink
+   *
+   *  They are required by default to cooperate with the global C
+   *  library's @c FILE streams, and to be available during program
+   *  startup and termination. For more information, see the HOWTO
+   *  linked to above.
+  */
+  //@{
+  extern istream cin;		/// Linked to standard input
+  extern ostream cout;		/// Linked to standard output
+  extern ostream cerr;		/// Linked to standard error (unbuffered)
+  extern ostream clog;		/// Linked to standard error (buffered)
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern wistream wcin;		/// Linked to standard input
+  extern wostream wcout;	/// Linked to standard output
+  extern wostream wcerr;	/// Linked to standard error (unbuffered)
+  extern wostream wclog;	/// Linked to standard error (buffered)
+#endif
+  //@}
+
+  // For construction of filebuffers for cout, cin, cerr, clog et. al.
+  static ios_base::Init __ioinit;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GLIBCXX_IOSTREAM */
diff --git a/gcc-4.9/libstdc++-v3/include/std/istream b/gcc-4.9/libstdc++-v3/include/std/istream
new file mode 100644
index 0000000..f063768
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/istream
@@ -0,0 +1,881 @@
+// Input streams -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 27.6.1  Input streams
+//
+
+/** @file include/istream
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_ISTREAM
+#define _GLIBCXX_ISTREAM 1
+
+#pragma GCC system_header
+
+#include <ios>
+#include <ostream>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Template class basic_istream.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This is the base class for all input streams.  It provides text
+   *  formatting of all builtin types, and communicates with any class
+   *  derived from basic_streambuf to do the actual input.
+  */
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+      // Types (inherited from basic_ios (27.4.4)):
+      typedef _CharT			 		char_type;
+      typedef typename _Traits::int_type 		int_type;
+      typedef typename _Traits::pos_type 		pos_type;
+      typedef typename _Traits::off_type 		off_type;
+      typedef _Traits			 		traits_type;
+
+      // Non-standard Types:
+      typedef basic_streambuf<_CharT, _Traits> 		__streambuf_type;
+      typedef basic_ios<_CharT, _Traits>		__ios_type;
+      typedef basic_istream<_CharT, _Traits>		__istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+ 							__num_get_type;
+      typedef ctype<_CharT>	      			__ctype_type;
+
+    protected:
+      // Data Members:
+      /**
+       *  The number of characters extracted in the previous unformatted
+       *  function; see gcount().
+      */
+      streamsize 		_M_gcount;
+
+    public:
+      /**
+       *  @brief  Base constructor.
+       *
+       *  This ctor is almost never called by the user directly, rather from
+       *  derived classes' initialization lists, which pass a pointer to
+       *  their own stream buffer.
+      */
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+
+      /**
+       *  @brief  Base destructor.
+       *
+       *  This does very little apart from providing a virtual base dtor.
+      */
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+
+      /// Safe prefix/suffix operations.
+      class sentry;
+      friend class sentry;
+
+      //@{
+      /**
+       *  @brief  Interface for manipulators.
+       *
+       *  Manipulators such as @c std::ws and @c std::dec use these
+       *  functions in constructs like
+       *  <code>std::cin >> std::ws</code>.
+       *  For more information, see the iomanip header.
+      */
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+	__pf(*this);
+	return *this;
+      }
+
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+	__pf(*this);
+	return *this;
+      }
+      //@}
+
+      //@{
+      /**
+       *  @name Extractors
+       *
+       *  All the @c operator>> functions (aka <em>formatted input
+       *  functions</em>) have some common behavior.  Each starts by
+       *  constructing a temporary object of type std::basic_istream::sentry
+       *  with the second argument (noskipws) set to false.  This has several
+       *  effects, concluding with the setting of a status flag; see the
+       *  sentry documentation for more.
+       *
+       *  If the sentry status is good, the function tries to extract
+       *  whatever data is appropriate for the type of the argument.
+       *
+       *  If an exception is thrown during extraction, ios_base::badbit
+       *  will be turned on in the stream's error state without causing an
+       *  ios_base::failure to be thrown.  The original exception will then
+       *  be rethrown.
+      */
+
+      //@{
+      /**
+       *  @brief  Integer arithmetic extractors
+       *  @param  __n A variable of builtin integral type.
+       *  @return  @c *this if successful
+       *
+       *  These functions use the stream's current locale (specifically, the
+       *  @c num_get facet) to parse the input data.
+      */
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(short& __n);
+
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(int& __n);
+
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+#endif
+      //@}
+
+      //@{
+      /**
+       *  @brief  Floating point arithmetic extractors
+       *  @param  __f A variable of builtin floating point type.
+       *  @return  @c *this if successful
+       *
+       *  These functions use the stream's current locale (specifically, the
+       *  @c num_get facet) to parse the input data.
+      */
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+      //@}
+
+      /**
+       *  @brief  Basic arithmetic extractors
+       *  @param  __p A variable of pointer type.
+       *  @return  @c *this if successful
+       *
+       *  These functions use the stream's current locale (specifically, the
+       *  @c num_get facet) to parse the input data.
+      */
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+
+      /**
+       *  @brief  Extracting into another streambuf.
+       *  @param  __sb  A pointer to a streambuf
+       *
+       *  This function behaves like one of the basic arithmetic extractors,
+       *  in that it also constructs a sentry object and has the same error
+       *  handling behavior.
+       *
+       *  If @p __sb is NULL, the stream will set failbit in its error state.
+       *
+       *  Characters are extracted from this stream and inserted into the
+       *  @p __sb streambuf until one of the following occurs:
+       *
+       *  - the input stream reaches end-of-file,
+       *  - insertion into the output buffer fails (in this case, the
+       *    character that would have been inserted is not extracted), or
+       *  - an exception occurs (and in this case is caught)
+       *
+       *  If the function inserts no characters, failbit is set.
+      */
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+      //@}
+
+      // [27.6.1.3] unformatted input
+      /**
+       *  @brief  Character counting
+       *  @return  The number of characters extracted by the previous
+       *           unformatted input function dispatched for this stream.
+      */
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+
+      //@{
+      /**
+       *  @name Unformatted Input Functions
+       *
+       *  All the unformatted input functions have some common behavior.
+       *  Each starts by constructing a temporary object of type
+       *  std::basic_istream::sentry with the second argument (noskipws)
+       *  set to true.  This has several effects, concluding with the
+       *  setting of a status flag; see the sentry documentation for more.
+       *
+       *  If the sentry status is good, the function tries to extract
+       *  whatever data is appropriate for the type of the argument.
+       *
+       *  The number of characters extracted is stored for later retrieval
+       *  by gcount().
+       *
+       *  If an exception is thrown during extraction, ios_base::badbit
+       *  will be turned on in the stream's error state without causing an
+       *  ios_base::failure to be thrown.  The original exception will then
+       *  be rethrown.
+      */
+
+      /**
+       *  @brief  Simple extraction.
+       *  @return  A character, or eof().
+       *
+       *  Tries to extract a character.  If none are available, sets failbit
+       *  and returns traits::eof().
+      */
+      int_type
+      get();
+
+      /**
+       *  @brief  Simple extraction.
+       *  @param  __c  The character in which to store data.
+       *  @return  *this
+       *
+       *  Tries to extract a character and store it in @a __c.  If none are
+       *  available, sets failbit and returns traits::eof().
+       *
+       *  @note  This function is not overloaded on signed char and
+       *         unsigned char.
+      */
+      __istream_type&
+      get(char_type& __c);
+
+      /**
+       *  @brief  Simple multiple-character extraction.
+       *  @param  __s  Pointer to an array.
+       *  @param  __n  Maximum number of characters to store in @a __s.
+       *  @param  __delim  A "stop" character.
+       *  @return  *this
+       *
+       *  Characters are extracted and stored into @a __s until one of the
+       *  following happens:
+       *
+       *  - @c __n-1 characters are stored
+       *  - the input sequence reaches EOF
+       *  - the next character equals @a __delim, in which case the character
+       *    is not extracted
+       *
+       * If no characters are stored, failbit is set in the stream's error
+       * state.
+       *
+       * In any case, a null character is stored into the next location in
+       * the array.
+       *
+       *  @note  This function is not overloaded on signed char and
+       *         unsigned char.
+      */
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+
+      /**
+       *  @brief  Simple multiple-character extraction.
+       *  @param  __s  Pointer to an array.
+       *  @param  __n  Maximum number of characters to store in @a s.
+       *  @return  *this
+       *
+       *  Returns @c get(__s,__n,widen(&apos;\\n&apos;)).
+      */
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+
+      /**
+       *  @brief  Extraction into another streambuf.
+       *  @param  __sb  A streambuf in which to store data.
+       *  @param  __delim  A "stop" character.
+       *  @return  *this
+       *
+       *  Characters are extracted and inserted into @a __sb until one of the
+       *  following happens:
+       *
+       *  - the input sequence reaches EOF
+       *  - insertion into the output buffer fails (in this case, the
+       *    character that would have been inserted is not extracted)
+       *  - the next character equals @a __delim (in this case, the character
+       *    is not extracted)
+       *  - an exception occurs (and in this case is caught)
+       *
+       * If no characters are stored, failbit is set in the stream's error
+       * state.
+      */
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+
+      /**
+       *  @brief  Extraction into another streambuf.
+       *  @param  __sb  A streambuf in which to store data.
+       *  @return  *this
+       *
+       *  Returns @c get(__sb,widen(&apos;\\n&apos;)).
+      */
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+
+      /**
+       *  @brief  String extraction.
+       *  @param  __s  A character array in which to store the data.
+       *  @param  __n  Maximum number of characters to extract.
+       *  @param  __delim  A "stop" character.
+       *  @return  *this
+       *
+       *  Extracts and stores characters into @a __s until one of the
+       *  following happens.  Note that these criteria are required to be
+       *  tested in the order listed here, to allow an input line to exactly
+       *  fill the @a __s array without setting failbit.
+       *
+       *  -# the input sequence reaches end-of-file, in which case eofbit
+       *     is set in the stream error state
+       *  -# the next character equals @c __delim, in which case the character
+       *     is extracted (and therefore counted in @c gcount()) but not stored
+       *  -# @c __n-1 characters are stored, in which case failbit is set
+       *     in the stream error state
+       *
+       *  If no characters are extracted, failbit is set.  (An empty line of
+       *  input should therefore not cause failbit to be set.)
+       *
+       *  In any case, a null character is stored in the next location in
+       *  the array.
+      */
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+
+      /**
+       *  @brief  String extraction.
+       *  @param  __s  A character array in which to store the data.
+       *  @param  __n  Maximum number of characters to extract.
+       *  @return  *this
+       *
+       *  Returns @c getline(__s,__n,widen(&apos;\\n&apos;)).
+      */
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+
+      /**
+       *  @brief  Discarding characters
+       *  @param  __n  Number of characters to discard.
+       *  @param  __delim  A "stop" character.
+       *  @return  *this
+       *
+       *  Extracts characters and throws them away until one of the
+       *  following happens:
+       *  - if @a __n @c != @c std::numeric_limits<int>::max(), @a __n
+       *    characters are extracted
+       *  - the input sequence reaches end-of-file
+       *  - the next character equals @a __delim (in this case, the character
+       *    is extracted); note that this condition will never occur if
+       *    @a __delim equals @c traits::eof().
+       *
+       *  NB: Provide three overloads, instead of the single function
+       *  (with defaults) mandated by the Standard: this leads to a
+       *  better performing implementation, while still conforming to
+       *  the Standard.
+      */
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+
+      __istream_type&
+      ignore(streamsize __n);
+
+      __istream_type&
+      ignore();
+
+      /**
+       *  @brief  Looking ahead in the stream
+       *  @return  The next character, or eof().
+       *
+       *  If, after constructing the sentry object, @c good() is false,
+       *  returns @c traits::eof().  Otherwise reads but does not extract
+       *  the next input character.
+      */
+      int_type
+      peek();
+
+      /**
+       *  @brief  Extraction without delimiters.
+       *  @param  __s  A character array.
+       *  @param  __n  Maximum number of characters to store.
+       *  @return  *this
+       *
+       *  If the stream state is @c good(), extracts characters and stores
+       *  them into @a __s until one of the following happens:
+       *  - @a __n characters are stored
+       *  - the input sequence reaches end-of-file, in which case the error
+       *    state is set to @c failbit|eofbit.
+       *
+       *  @note  This function is not overloaded on signed char and
+       *         unsigned char.
+      */
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+
+      /**
+       *  @brief  Extraction until the buffer is exhausted, but no more.
+       *  @param  __s  A character array.
+       *  @param  __n  Maximum number of characters to store.
+       *  @return  The number of characters extracted.
+       *
+       *  Extracts characters and stores them into @a __s depending on the
+       *  number of characters remaining in the streambuf's buffer,
+       *  @c rdbuf()->in_avail(), called @c A here:
+       *  - if @c A @c == @c -1, sets eofbit and extracts no characters
+       *  - if @c A @c == @c 0, extracts no characters
+       *  - if @c A @c > @c 0, extracts @c min(A,n)
+       *
+       *  The goal is to empty the current buffer, and to not request any
+       *  more from the external input sequence controlled by the streambuf.
+      */
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+
+      /**
+       *  @brief  Unextracting a single character.
+       *  @param  __c  The character to push back into the input stream.
+       *  @return  *this
+       *
+       *  If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c).
+       *
+       *  If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in
+       *  the error state.
+       *
+       *  @note  This function first clears eofbit.  Since no characters
+       *         are extracted, the next call to @c gcount() will return 0,
+       *         as required by DR 60.
+      */
+      __istream_type&
+      putback(char_type __c);
+
+      /**
+       *  @brief  Unextracting the previous character.
+       *  @return  *this
+       *
+       *  If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c).
+       *
+       *  If @c rdbuf() is null or if @c sungetc() fails, sets badbit in
+       *  the error state.
+       *
+       *  @note  This function first clears eofbit.  Since no characters
+       *         are extracted, the next call to @c gcount() will return 0,
+       *         as required by DR 60.
+      */
+      __istream_type&
+      unget();
+
+      /**
+       *  @brief  Synchronizing the stream buffer.
+       *  @return  0 on success, -1 on failure
+       *
+       *  If @c rdbuf() is a null pointer, returns -1.
+       *
+       *  Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
+       *  sets badbit and returns -1.
+       *
+       *  Otherwise, returns 0.
+       *
+       *  @note  This function does not count the number of characters
+       *         extracted, if any, and therefore does not affect the next
+       *         call to @c gcount().
+      */
+      int
+      sync();
+
+      /**
+       *  @brief  Getting the current read position.
+       *  @return  A file position object.
+       *
+       *  If @c fail() is not false, returns @c pos_type(-1) to indicate
+       *  failure.  Otherwise returns @c rdbuf()->pubseekoff(0,cur,in).
+       *
+       *  @note  This function does not count the number of characters
+       *         extracted, if any, and therefore does not affect the next
+       *         call to @c gcount().  At variance with putback, unget and
+       *         seekg, eofbit is not cleared first.
+      */
+      pos_type
+      tellg();
+
+      /**
+       *  @brief  Changing the current read position.
+       *  @param  __pos  A file position object.
+       *  @return  *this
+       *
+       *  If @c fail() is not true, calls @c rdbuf()->pubseekpos(__pos).  If
+       *  that function fails, sets failbit.
+       *
+       *  @note  This function first clears eofbit.  It does not count the
+       *         number of characters extracted, if any, and therefore does
+       *         not affect the next call to @c gcount().
+      */
+      __istream_type&
+      seekg(pos_type);
+
+      /**
+       *  @brief  Changing the current read position.
+       *  @param  __off  A file offset object.
+       *  @param  __dir  The direction in which to seek.
+       *  @return  *this
+       *
+       *  If @c fail() is not true, calls @c rdbuf()->pubseekoff(__off,__dir).
+       *  If that function fails, sets failbit.
+       *
+       *  @note  This function first clears eofbit.  It does not count the
+       *         number of characters extracted, if any, and therefore does
+       *         not affect the next call to @c gcount().
+      */
+      __istream_type&
+      seekg(off_type, ios_base::seekdir);
+      //@}
+
+    protected:
+      basic_istream()
+      : _M_gcount(streamsize(0))
+      { this->init(0); }
+
+      template<typename _ValueT>
+	__istream_type&
+	_M_extract(_ValueT& __v);
+    };
+
+  /// Explicit specialization declarations, defined in src/istream.cc.
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n, int_type __delim);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n, int_type __delim);
+#endif
+
+  /**
+   *  @brief  Performs setup work for input streams.
+   *
+   *  Objects of this class are created before all of the standard
+   *  extractors are run.  It is responsible for <em>exception-safe
+   *  prefix and suffix operations,</em> although only prefix actions
+   *  are currently required by the standard.
+  */
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+      // Data Members.
+      bool _M_ok;
+
+    public:
+      /// Easy access to dependent types.
+      typedef _Traits 					traits_type;
+      typedef basic_streambuf<_CharT, _Traits> 		__streambuf_type;
+      typedef basic_istream<_CharT, _Traits> 		__istream_type;
+      typedef typename __istream_type::__ctype_type 	__ctype_type;
+      typedef typename _Traits::int_type		__int_type;
+
+      /**
+       *  @brief  The constructor performs all the work.
+       *  @param  __is  The input stream to guard.
+       *  @param  __noskipws  Whether to consume whitespace or not.
+       *
+       *  If the stream state is good (@a __is.good() is true), then the
+       *  following actions are performed, otherwise the sentry state
+       *  is false (<em>not okay</em>) and failbit is set in the
+       *  stream state.
+       *
+       *  The sentry's preparatory actions are:
+       *
+       *  -# if the stream is tied to an output stream, @c is.tie()->flush()
+       *     is called to synchronize the output sequence
+       *  -# if @a __noskipws is false, and @c ios_base::skipws is set in
+       *     @c is.flags(), the sentry extracts and discards whitespace
+       *     characters from the stream.  The currently imbued locale is
+       *     used to determine whether each character is whitespace.
+       *
+       *  If the stream state is still good, then the sentry state becomes
+       *  true (@a okay).
+      */
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+
+      /**
+       *  @brief  Quick status checking.
+       *  @return  The sentry state.
+       *
+       *  For ease of use, sentries may be converted to booleans.  The
+       *  return value is that of the sentry state (true == okay).
+      */
+#if __cplusplus >= 201103L
+      explicit
+#endif
+      operator bool() const
+      { return _M_ok; }
+    };
+
+  //@{
+  /**
+   *  @brief  Character extractors
+   *  @param  __in  An input stream.
+   *  @param  __c  A character reference.
+   *  @return  in
+   *
+   *  Behaves like one of the formatted arithmetic extractors described in
+   *  std::basic_istream.  After constructing a sentry object with good
+   *  status, this function extracts a character (if one is available) and
+   *  stores it in @a __c.  Otherwise, sets failbit in the input stream.
+  */
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+  //@}
+
+  //@{
+  /**
+   *  @brief  Character string extractors
+   *  @param  __in  An input stream.
+   *  @param  __s  A pointer to a character array.
+   *  @return  __in
+   *
+   *  Behaves like one of the formatted arithmetic extractors described in
+   *  std::basic_istream.  After constructing a sentry object with good
+   *  status, this function extracts up to @c n characters and stores them
+   *  into the array starting at @a __s.  @c n is defined as:
+   *
+   *  - if @c width() is greater than zero, @c n is width() otherwise
+   *  - @c n is <em>the number of elements of the largest array of *
+   *  - @c char_type that can store a terminating @c eos.</em>
+   *  - [27.6.1.2.3]/6
+   *
+   *  Characters are extracted and stored until one of the following happens:
+   *  - @c n-1 characters are stored
+   *  - EOF is reached
+   *  - the next character is whitespace according to the current locale
+   *  - the next character is a null byte (i.e., @c charT() )
+   *
+   *  @c width(0) is then called for the input stream.
+   *
+   *  If no characters are extracted, sets failbit.
+  */
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+
+  // Explicit specialization declaration, defined in src/istream.cc.
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __in, char* __s);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+  //@}
+
+  /**
+   *  @brief  Template class basic_iostream
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This class multiply inherits from the input and output stream classes
+   *  simply to provide a single interface.
+  */
+  template<typename _CharT, typename _Traits>
+    class basic_iostream
+    : public basic_istream<_CharT, _Traits>,
+      public basic_ostream<_CharT, _Traits>
+    {
+    public:
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 271. basic_iostream missing typedefs
+      // Types (inherited):
+      typedef _CharT			 		char_type;
+      typedef typename _Traits::int_type 		int_type;
+      typedef typename _Traits::pos_type 		pos_type;
+      typedef typename _Traits::off_type 		off_type;
+      typedef _Traits			 		traits_type;
+
+      // Non-standard Types:
+      typedef basic_istream<_CharT, _Traits>		__istream_type;
+      typedef basic_ostream<_CharT, _Traits>		__ostream_type;
+
+      /**
+       *  @brief  Constructor does nothing.
+       *
+       *  Both of the parent classes are initialized with the same
+       *  streambuf pointer passed to this constructor.
+      */
+      explicit
+      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
+      : __istream_type(__sb), __ostream_type(__sb) { }
+
+      /**
+       *  @brief  Destructor does nothing.
+      */
+      virtual
+      ~basic_iostream() { }
+
+    protected:
+      basic_iostream()
+      : __istream_type(), __ostream_type() { }
+    };
+
+  /**
+   *  @brief  Quick and easy way to eat whitespace
+   *
+   *  This manipulator extracts whitespace characters, stopping when the
+   *  next character is non-whitespace, or when the input sequence is empty.
+   *  If the sequence is empty, @c eofbit is set in the stream, but not
+   *  @c failbit.
+   *
+   *  The current locale is used to distinguish whitespace characters.
+   *
+   *  Example:
+   *  @code
+   *     MyClass   mc;
+   *
+   *     std::cin >> std::ws >> mc;
+   *  @endcode
+   *  will skip leading whitespace before calling operator>> on cin and your
+   *  object.  Note that the same effect can be achieved by creating a
+   *  std::basic_istream::sentry inside your definition of operator>>.
+  */
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+
+#if __cplusplus >= 201103L
+  // [27.7.1.6] Rvalue stream extraction
+  /**
+   *  @brief  Generic extractor for rvalue stream
+   *  @param  __is  An input stream.
+   *  @param  __x  A reference to the extraction target.
+   *  @return  is
+   *
+   *  This is just a forwarding function to allow extraction from
+   *  rvalue streams since they won't bind to the extractor functions
+   *  that take an lvalue reference.
+  */
+  template<typename _CharT, typename _Traits, typename _Tp>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
+    { return (__is >> __x); }
+#endif // C++11
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/istream.tcc>
+
+#endif	/* _GLIBCXX_ISTREAM */
diff --git a/gcc-4.9/libstdc++-v3/include/std/iterator b/gcc-4.9/libstdc++-v3/include/std/iterator
new file mode 100644
index 0000000..f9ce095
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/iterator
@@ -0,0 +1,70 @@
+// <iterator> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/iterator
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_ITERATOR
+#define _GLIBCXX_ITERATOR 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stl_iterator_base_types.h>
+#include <bits/stl_iterator_base_funcs.h>
+#include <bits/stl_iterator.h>
+#include <ostream>
+#include <istream>
+#include <bits/stream_iterator.h>
+#include <bits/streambuf_iterator.h>
+#include <bits/range_access.h>
+
+#endif /* _GLIBCXX_ITERATOR */
diff --git a/gcc-4.9/libstdc++-v3/include/std/limits b/gcc-4.9/libstdc++-v3/include/std/limits
new file mode 100644
index 0000000..f39821e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/limits
@@ -0,0 +1,1786 @@
+// The template and inlines for the numeric_limits classes. -*- C++ -*-
+
+// Copyright (C) 1999-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/limits
+ *  This is a Standard C++ Library header.
+ */
+
+// Note: this is not a conforming implementation.
+// Written by Gabriel Dos Reis <gdr@codesourcery.com>
+
+//
+// ISO 14882:1998
+// 18.2.1
+//
+
+#ifndef _GLIBCXX_NUMERIC_LIMITS
+#define _GLIBCXX_NUMERIC_LIMITS 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+//
+// The numeric_limits<> traits document implementation-defined aspects
+// of fundamental arithmetic data types (integers and floating points).
+// From Standard C++ point of view, there are 14 such types:
+//   * integers
+//         bool							(1)
+//         char, signed char, unsigned char, wchar_t            (4)
+//         short, unsigned short				(2)
+//         int, unsigned					(2)
+//         long, unsigned long					(2)
+//
+//   * floating points
+//         float						(1)
+//         double						(1)
+//         long double						(1)
+//
+// GNU C++ understands (where supported by the host C-library)
+//   * integer
+//         long long, unsigned long long			(2)
+//
+// which brings us to 16 fundamental arithmetic data types in GNU C++.
+//
+//
+// Since a numeric_limits<> is a bit tricky to get right, we rely on
+// an interface composed of macros which should be defined in config/os
+// or config/cpu when they differ from the generic (read arbitrary)
+// definitions given here.
+//
+
+// These values can be overridden in the target configuration file.
+// The default values are appropriate for many 32-bit targets.
+
+// GCC only intrinsically supports modulo integral types.  The only remaining
+// integral exceptional values is division by zero.  Only targets that do not
+// signal division by zero in some "hard to ignore" way should use false.
+#ifndef __glibcxx_integral_traps
+# define __glibcxx_integral_traps true
+#endif
+
+// float
+//
+
+// Default values.  Should be overridden in configuration files if necessary.
+
+#ifndef __glibcxx_float_has_denorm_loss
+#  define __glibcxx_float_has_denorm_loss false
+#endif
+#ifndef __glibcxx_float_traps
+#  define __glibcxx_float_traps false
+#endif
+#ifndef __glibcxx_float_tinyness_before
+#  define __glibcxx_float_tinyness_before false
+#endif
+
+// double
+
+// Default values.  Should be overridden in configuration files if necessary.
+
+#ifndef __glibcxx_double_has_denorm_loss
+#  define __glibcxx_double_has_denorm_loss false
+#endif
+#ifndef __glibcxx_double_traps
+#  define __glibcxx_double_traps false
+#endif
+#ifndef __glibcxx_double_tinyness_before
+#  define __glibcxx_double_tinyness_before false
+#endif
+
+// long double
+
+// Default values.  Should be overridden in configuration files if necessary.
+
+#ifndef __glibcxx_long_double_has_denorm_loss
+#  define __glibcxx_long_double_has_denorm_loss false
+#endif
+#ifndef __glibcxx_long_double_traps
+#  define __glibcxx_long_double_traps false
+#endif
+#ifndef __glibcxx_long_double_tinyness_before
+#  define __glibcxx_long_double_tinyness_before false
+#endif
+
+// You should not need to define any macros below this point.
+
+#define __glibcxx_signed(T)	((T)(-1) < 0)
+
+#define __glibcxx_min(T) \
+  (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
+
+#define __glibcxx_max(T) \
+  (__glibcxx_signed (T) ? \
+   (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
+
+#define __glibcxx_digits(T) \
+  (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
+
+// The fraction 643/2136 approximates log10(2) to 7 significant digits.
+#define __glibcxx_digits10(T) \
+  (__glibcxx_digits (T) * 643L / 2136)
+
+#define __glibcxx_max_digits10(T) \
+  (2 + (T) * 643L / 2136)
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief Describes the rounding style for floating-point types.
+   *
+   *  This is used in the std::numeric_limits class.
+  */
+  enum float_round_style
+  {
+    round_indeterminate       = -1,    /// Intermediate.
+    round_toward_zero         = 0,     /// To zero.
+    round_to_nearest          = 1,     /// To the nearest representable value.
+    round_toward_infinity     = 2,     /// To infinity.
+    round_toward_neg_infinity = 3      /// To negative infinity.
+  };
+
+  /**
+   *  @brief Describes the denormalization for floating-point types.
+   *
+   *  These values represent the presence or absence of a variable number
+   *  of exponent bits.  This type is used in the std::numeric_limits class.
+  */
+  enum float_denorm_style
+  {
+    /// Indeterminate at compile time whether denormalized values are allowed.
+    denorm_indeterminate = -1,
+    /// The type does not allow denormalized values.
+    denorm_absent        = 0,
+    /// The type allows denormalized values.
+    denorm_present       = 1
+  };
+
+  /**
+   *  @brief Part of std::numeric_limits.
+   *
+   *  The @c static @c const members are usable as integral constant
+   *  expressions.
+   *
+   *  @note This is a separate class for purposes of efficiency; you
+   *        should only access these members as part of an instantiation
+   *        of the std::numeric_limits class.
+  */
+  struct __numeric_limits_base
+  {
+    /** This will be true for all fundamental types (which have
+	specializations), and false for everything else.  */
+    static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
+
+    /** The number of @c radix digits that be represented without change:  for
+	integer types, the number of non-sign bits in the mantissa; for
+	floating types, the number of @c radix digits in the mantissa.  */
+    static _GLIBCXX_USE_CONSTEXPR int digits = 0;
+
+    /** The number of base 10 digits that can be represented without change. */
+    static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
+
+#if __cplusplus >= 201103L
+    /** The number of base 10 digits required to ensure that values which
+	differ are always differentiated.  */
+    static constexpr int max_digits10 = 0;
+#endif
+
+    /** True if the type is signed.  */
+    static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+
+    /** True if the type is integer.  */
+    static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
+
+    /** True if the type uses an exact representation. All integer types are
+	exact, but not all exact types are integer.  For example, rational and
+	fixed-exponent representations are exact but not integer. */
+    static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
+
+    /** For integer types, specifies the base of the representation.  For
+	floating types, specifies the base of the exponent representation.  */
+    static _GLIBCXX_USE_CONSTEXPR int radix = 0;
+
+    /** The minimum negative integer such that @c radix raised to the power of
+	(one less than that integer) is a normalized floating point number.  */
+    static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+
+    /** The minimum negative integer such that 10 raised to that power is in
+	the range of normalized floating point numbers.  */
+    static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+
+    /** The maximum positive integer such that @c radix raised to the power of
+	(one less than that integer) is a representable finite floating point
+	number.  */
+    static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+
+    /** The maximum positive integer such that 10 raised to that power is in
+	the range of representable finite floating point numbers.  */
+    static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+    /** True if the type has a representation for positive infinity.  */
+    static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+
+    /** True if the type has a representation for a quiet (non-signaling)
+	Not a Number.  */
+    static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+
+    /** True if the type has a representation for a signaling
+	Not a Number.  */
+    static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+
+    /** See std::float_denorm_style for more information.  */
+    static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
+
+    /** True if loss of accuracy is detected as a denormalization loss,
+	rather than as an inexact result. */
+    static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+    /** True if-and-only-if the type adheres to the IEC 559 standard, also
+	known as IEEE 754.  (Only makes sense for floating point types.)  */
+    static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+
+    /** True if the set of values representable by the type is
+	finite.  All built-in types are bounded, this member would be
+	false for arbitrary precision types. */
+    static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
+
+    /** True if the type is @e modulo. A type is modulo if, for any
+	operation involving +, -, or * on values of that type whose
+	result would fall outside the range [min(),max()], the value
+	returned differs from the true value by an integer multiple of
+	max() - min() + 1. On most machines, this is false for floating
+	types, true for unsigned integers, and true for signed integers.
+	See PR22200 about signed integers.  */
+    static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+    /** True if trapping is implemented for this type.  */
+    static _GLIBCXX_USE_CONSTEXPR bool traps = false;
+
+    /** True if tininess is detected before rounding.  (see IEC 559)  */
+    static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+
+    /** See std::float_round_style for more information.  This is only
+	meaningful for floating types; integer types will all be
+	round_toward_zero.  */
+    static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 
+						    round_toward_zero;
+  };
+
+  /**
+   *  @brief Properties of fundamental types.
+   *
+   *  This class allows a program to obtain information about the
+   *  representation of a fundamental type on a given platform.  For
+   *  non-fundamental types, the functions will return 0 and the data
+   *  members will all be @c false.
+   *
+   *  _GLIBCXX_RESOLVE_LIB_DEFECTS:  DRs 201 and 184 (hi Gaby!) are
+   *  noted, but not incorporated in this documented (yet).
+  */
+  template<typename _Tp>
+    struct numeric_limits : public __numeric_limits_base
+    {
+      /** The minimum finite value, or for floating types with
+	  denormalization, the minimum positive normalized value.  */
+      static _GLIBCXX_CONSTEXPR _Tp
+      min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+
+      /** The maximum finite value.  */
+      static _GLIBCXX_CONSTEXPR _Tp
+      max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+
+#if __cplusplus >= 201103L
+      /** A finite value x such that there is no other finite value y
+       *  where y < x.  */
+      static constexpr _Tp
+      lowest() noexcept { return _Tp(); }
+#endif
+
+      /** The @e machine @e epsilon:  the difference between 1 and the least
+	  value greater than 1 that is representable.  */
+      static _GLIBCXX_CONSTEXPR _Tp
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+
+      /** The maximum rounding error measurement (see LIA-1).  */
+      static _GLIBCXX_CONSTEXPR _Tp
+      round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+
+      /** The representation of positive infinity, if @c has_infinity.  */
+      static _GLIBCXX_CONSTEXPR _Tp
+      infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+
+      /** The representation of a quiet Not a Number,
+	  if @c has_quiet_NaN. */
+      static _GLIBCXX_CONSTEXPR _Tp
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+
+      /** The representation of a signaling Not a Number, if
+	  @c has_signaling_NaN. */
+      static _GLIBCXX_CONSTEXPR _Tp
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+
+      /** The minimum positive denormalized value.  For types where
+	  @c has_denorm is false, this is the minimum positive normalized
+	  value.  */
+      static _GLIBCXX_CONSTEXPR _Tp
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
+    };
+
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    struct numeric_limits<const _Tp>
+    : public numeric_limits<_Tp> { };
+
+  template<typename _Tp>
+    struct numeric_limits<volatile _Tp>
+    : public numeric_limits<_Tp> { };
+
+  template<typename _Tp>
+    struct numeric_limits<const volatile _Tp>
+    : public numeric_limits<_Tp> { };
+#endif
+
+  // Now there follow 16 explicit specializations.  Yes, 16.  Make sure
+  // you get the count right. (18 in c++0x mode)
+
+  /// numeric_limits<bool> specialization.
+  template<>
+    struct numeric_limits<bool>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR bool 
+      min() _GLIBCXX_USE_NOEXCEPT { return false; }
+
+      static _GLIBCXX_CONSTEXPR bool 
+      max() _GLIBCXX_USE_NOEXCEPT { return true; }
+
+#if __cplusplus >= 201103L
+      static constexpr bool
+      lowest() noexcept { return min(); }
+#endif
+      static _GLIBCXX_USE_CONSTEXPR int digits = 1;
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR bool 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
+
+      static _GLIBCXX_CONSTEXPR bool 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR bool 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
+
+      static _GLIBCXX_CONSTEXPR bool 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
+
+      static _GLIBCXX_CONSTEXPR bool 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
+
+      static _GLIBCXX_CONSTEXPR bool 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      // It is not clear what it means for a boolean type to trap.
+      // This is a DR on the LWG issue list.  Here, I use integer
+      // promotion semantics.
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<char> specialization.
+  template<>
+    struct numeric_limits<char>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR char 
+      min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
+
+      static _GLIBCXX_CONSTEXPR char 
+      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
+
+#if __cplusplus >= 201103L
+      static constexpr char 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char);
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR char 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR char 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR 
+      char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); }
+
+      static _GLIBCXX_CONSTEXPR char 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
+
+      static _GLIBCXX_CONSTEXPR char 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
+
+      static _GLIBCXX_CONSTEXPR char 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<signed char> specialization.
+  template<>
+    struct numeric_limits<signed char>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr signed char 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (signed char);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<signed char>(0); }
+
+      static _GLIBCXX_CONSTEXPR signed char 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<signed char>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<unsigned char> specialization.
+  template<>
+    struct numeric_limits<unsigned char>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      min() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
+
+#if __cplusplus >= 201103L
+      static constexpr unsigned char 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits 
+       = __glibcxx_digits (unsigned char);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (unsigned char);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      infinity() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned char>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned char>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned char>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned char 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned char>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<wchar_t> specialization.
+  template<>
+    struct numeric_limits<wchar_t>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
+
+#if __cplusplus >= 201103L
+      static constexpr wchar_t
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (wchar_t);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
+
+      static _GLIBCXX_CONSTEXPR wchar_t 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+#if __cplusplus >= 201103L
+  /// numeric_limits<char16_t> specialization.
+  template<>
+    struct numeric_limits<char16_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char16_t 
+      min() noexcept { return __glibcxx_min (char16_t); }
+
+      static constexpr char16_t 
+      max() noexcept { return __glibcxx_max (char16_t); }
+
+      static constexpr char16_t 
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = __glibcxx_digits (char16_t);
+      static constexpr int digits10 = __glibcxx_digits10 (char16_t);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = __glibcxx_signed (char16_t);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char16_t 
+      epsilon() noexcept { return 0; }
+
+      static constexpr char16_t 
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr char16_t 
+      infinity() noexcept { return char16_t(); }
+
+      static constexpr char16_t 
+      quiet_NaN() noexcept { return char16_t(); }
+
+      static constexpr char16_t 
+      signaling_NaN() noexcept { return char16_t(); }
+
+      static constexpr char16_t 
+      denorm_min() noexcept { return char16_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = __glibcxx_integral_traps;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+
+  /// numeric_limits<char32_t> specialization.
+  template<>
+    struct numeric_limits<char32_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char32_t 
+      min() noexcept { return __glibcxx_min (char32_t); }
+
+      static constexpr char32_t 
+      max() noexcept { return __glibcxx_max (char32_t); }
+
+      static constexpr char32_t 
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = __glibcxx_digits (char32_t);
+      static constexpr int digits10 = __glibcxx_digits10 (char32_t);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = __glibcxx_signed (char32_t);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char32_t 
+      epsilon() noexcept { return 0; }
+
+      static constexpr char32_t 
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr char32_t 
+      infinity() noexcept { return char32_t(); }
+
+      static constexpr char32_t 
+      quiet_NaN() noexcept { return char32_t(); }
+
+      static constexpr char32_t 
+      signaling_NaN() noexcept { return char32_t(); }
+
+      static constexpr char32_t 
+      denorm_min() noexcept { return char32_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = __glibcxx_integral_traps;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+#endif
+
+  /// numeric_limits<short> specialization.
+  template<>
+    struct numeric_limits<short>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR short 
+      min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
+
+      static _GLIBCXX_CONSTEXPR short 
+      max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr short 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR short 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR short 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR short 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
+
+      static _GLIBCXX_CONSTEXPR short 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
+
+      static _GLIBCXX_CONSTEXPR short 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
+
+      static _GLIBCXX_CONSTEXPR short 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<unsigned short> specialization.
+  template<>
+    struct numeric_limits<unsigned short>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      min() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
+
+#if __cplusplus >= 201103L
+      static constexpr unsigned short 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits 
+       = __glibcxx_digits (unsigned short);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (unsigned short);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      infinity() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned short>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned short>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned short>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned short 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned short>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<int> specialization.
+  template<>
+    struct numeric_limits<int>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR int 
+      min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
+
+      static _GLIBCXX_CONSTEXPR int 
+      max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr int 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR int 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR int 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR int 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
+
+      static _GLIBCXX_CONSTEXPR int 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
+
+      static _GLIBCXX_CONSTEXPR int 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
+
+      static _GLIBCXX_CONSTEXPR int 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<unsigned int> specialization.
+  template<>
+    struct numeric_limits<unsigned int>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      min() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
+
+#if __cplusplus >= 201103L
+      static constexpr unsigned int 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits 
+       = __glibcxx_digits (unsigned int);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (unsigned int);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned int>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned int>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned int 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned int>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<long> specialization.
+  template<>
+    struct numeric_limits<long>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR long
+      min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
+
+      static _GLIBCXX_CONSTEXPR long 
+      max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr long 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR long 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR long 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR long 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
+
+      static _GLIBCXX_CONSTEXPR long 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
+
+      static _GLIBCXX_CONSTEXPR long 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
+
+      static _GLIBCXX_CONSTEXPR long 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<unsigned long> specialization.
+  template<>
+    struct numeric_limits<unsigned long>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      min() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
+
+#if __cplusplus >= 201103L
+      static constexpr unsigned long 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits 
+       = __glibcxx_digits (unsigned long);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (unsigned long);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      infinity() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned long 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<long long> specialization.
+  template<>
+    struct numeric_limits<long long>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR long long 
+      min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
+
+      static _GLIBCXX_CONSTEXPR long long 
+      max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr long long 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits 
+       = __glibcxx_digits (long long);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (long long);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR long long 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR long long 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR long long 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
+
+      static _GLIBCXX_CONSTEXPR long long 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
+
+      static _GLIBCXX_CONSTEXPR long long 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<long long>(0); }
+
+      static _GLIBCXX_CONSTEXPR long long 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<unsigned long long> specialization.
+  template<>
+    struct numeric_limits<unsigned long long>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      min() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
+
+#if __cplusplus >= 201103L
+      static constexpr unsigned long long 
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits 
+       = __glibcxx_digits (unsigned long long);
+      static _GLIBCXX_USE_CONSTEXPR int digits10 
+       = __glibcxx_digits10 (unsigned long long);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      infinity() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long long>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long long>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long long>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned long long 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned long long>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_toward_zero;
+    };
+
+#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
+  /// numeric_limits<__int128> specialization.
+  template<>
+    struct numeric_limits<__int128>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR __int128
+      min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (__int128); }
+
+      static _GLIBCXX_CONSTEXPR __int128
+      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (__int128); }
+
+#if __cplusplus >= 201103L
+      static constexpr __int128
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits
+       = __glibcxx_digits (__int128);
+      static _GLIBCXX_USE_CONSTEXPR int digits10
+       = __glibcxx_digits10 (__int128);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR __int128
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR __int128
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR __int128
+      infinity() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<__int128>(0); }
+
+      static _GLIBCXX_CONSTEXPR __int128
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<__int128>(0); }
+      
+      static _GLIBCXX_CONSTEXPR __int128
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<__int128>(0); }
+      
+      static _GLIBCXX_CONSTEXPR __int128
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<__int128>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps
+       = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+       = round_toward_zero;
+    };
+
+  /// numeric_limits<unsigned __int128> specialization.
+  template<>
+    struct numeric_limits<unsigned __int128>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      min() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (unsigned __int128); }
+
+#if __cplusplus >= 201103L
+      static constexpr unsigned __int128
+      lowest() noexcept { return min(); }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits
+       = __glibcxx_digits (unsigned __int128);
+      static _GLIBCXX_USE_CONSTEXPR int digits10
+       = __glibcxx_digits10 (unsigned __int128);
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10 = 0;
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
+      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+       = denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      infinity() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned __int128>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned __int128>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned __int128>(0); }
+
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      denorm_min() _GLIBCXX_USE_NOEXCEPT
+      { return static_cast<unsigned __int128>(0); }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+       = round_toward_zero;
+    };
+#endif
+
+  /// numeric_limits<float> specialization.
+  template<>
+    struct numeric_limits<float>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR float 
+      min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
+
+      static _GLIBCXX_CONSTEXPR float 
+      max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr float 
+      lowest() noexcept { return -__FLT_MAX__; }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10
+	 = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
+      static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
+
+      static _GLIBCXX_CONSTEXPR float 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
+
+      static _GLIBCXX_CONSTEXPR float 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+	= bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 
+       = __glibcxx_float_has_denorm_loss;
+
+      static _GLIBCXX_CONSTEXPR float 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
+
+      static _GLIBCXX_CONSTEXPR float 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
+
+      static _GLIBCXX_CONSTEXPR float 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
+
+      static _GLIBCXX_CONSTEXPR float 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559
+	= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 
+       = __glibcxx_float_tinyness_before;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_to_nearest;
+    };
+
+#undef __glibcxx_float_has_denorm_loss
+#undef __glibcxx_float_traps
+#undef __glibcxx_float_tinyness_before
+
+  /// numeric_limits<double> specialization.
+  template<>
+    struct numeric_limits<double>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR double 
+      min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
+
+      static _GLIBCXX_CONSTEXPR double 
+      max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr double 
+      lowest() noexcept { return -__DBL_MAX__; }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
+#if __cplusplus >= 201103L
+      static constexpr int max_digits10
+	 = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
+      static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
+
+      static _GLIBCXX_CONSTEXPR double 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
+
+      static _GLIBCXX_CONSTEXPR double 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+	= bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 
+        = __glibcxx_double_has_denorm_loss;
+
+      static _GLIBCXX_CONSTEXPR double 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
+
+      static _GLIBCXX_CONSTEXPR double 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
+
+      static _GLIBCXX_CONSTEXPR double 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
+
+      static _GLIBCXX_CONSTEXPR double 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559
+	= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 
+       = __glibcxx_double_tinyness_before;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
+       = round_to_nearest;
+    };
+
+#undef __glibcxx_double_has_denorm_loss
+#undef __glibcxx_double_traps
+#undef __glibcxx_double_tinyness_before
+
+  /// numeric_limits<long double> specialization.
+  template<>
+    struct numeric_limits<long double>
+    {
+      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
+
+      static _GLIBCXX_CONSTEXPR long double 
+      min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
+
+      static _GLIBCXX_CONSTEXPR long double 
+      max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
+
+#if __cplusplus >= 201103L
+      static constexpr long double 
+      lowest() noexcept { return -__LDBL_MAX__; }
+#endif
+
+      static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
+      static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
+#if __cplusplus >= 201103L
+      static _GLIBCXX_USE_CONSTEXPR int max_digits10
+	 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
+#endif
+      static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
+      static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
+      static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
+
+      static _GLIBCXX_CONSTEXPR long double 
+      epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
+
+      static _GLIBCXX_CONSTEXPR long double 
+      round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
+
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
+      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
+
+      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
+      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
+      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
+      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+	= bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
+      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
+	= __glibcxx_long_double_has_denorm_loss;
+
+      static _GLIBCXX_CONSTEXPR long double 
+      infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
+
+      static _GLIBCXX_CONSTEXPR long double 
+      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
+
+      static _GLIBCXX_CONSTEXPR long double 
+      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
+
+      static _GLIBCXX_CONSTEXPR long double 
+      denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
+
+      static _GLIBCXX_USE_CONSTEXPR bool is_iec559
+	= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
+      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
+
+      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
+      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = 
+					 __glibcxx_long_double_tinyness_before;
+      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 
+						      round_to_nearest;
+    };
+
+#undef __glibcxx_long_double_has_denorm_loss
+#undef __glibcxx_long_double_traps
+#undef __glibcxx_long_double_tinyness_before
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#undef __glibcxx_signed
+#undef __glibcxx_min
+#undef __glibcxx_max
+#undef __glibcxx_digits
+#undef __glibcxx_digits10
+#undef __glibcxx_max_digits10
+
+#endif // _GLIBCXX_NUMERIC_LIMITS
diff --git a/gcc-4.9/libstdc++-v3/include/std/list b/gcc-4.9/libstdc++-v3/include/std/list
new file mode 100644
index 0000000..c3efc43
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/list
@@ -0,0 +1,75 @@
+// <list> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/list
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_LIST
+#define _GLIBCXX_LIST 1
+
+#pragma GCC system_header
+
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/range_access.h>
+#include <bits/stl_list.h>
+#include <bits/list.tcc>
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/list>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/list>
+#endif
+
+#endif /* _GLIBCXX_LIST */
+
diff --git a/gcc-4.9/libstdc++-v3/include/std/locale b/gcc-4.9/libstdc++-v3/include/std/locale
new file mode 100644
index 0000000..c61c220
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/locale
@@ -0,0 +1,43 @@
+// Locale support -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//
+// ISO C++ 14882: 22.1  Locales
+//
+
+/** @file include/locale
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_LOCALE
+#define _GLIBCXX_LOCALE	1
+
+#pragma GCC system_header
+
+#include <bits/localefwd.h>
+#include <bits/locale_classes.h>
+#include <bits/locale_facets.h>
+#include <bits/locale_facets_nonio.h>
+
+#endif /* _GLIBCXX_LOCALE */
diff --git a/gcc-4.9/libstdc++-v3/include/std/map b/gcc-4.9/libstdc++-v3/include/std/map
new file mode 100644
index 0000000..6a3b2fb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/map
@@ -0,0 +1,73 @@
+// <map> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/map
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_MAP
+#define _GLIBCXX_MAP 1
+
+#pragma GCC system_header
+
+#include <bits/stl_tree.h>
+#include <bits/stl_map.h>
+#include <bits/stl_multimap.h>
+#include <bits/range_access.h>
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/map>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/map>
+#endif
+
+#endif /* _GLIBCXX_MAP */
diff --git a/gcc-4.9/libstdc++-v3/include/std/memory b/gcc-4.9/libstdc++-v3/include/std/memory
new file mode 100644
index 0000000..dafec0c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/memory
@@ -0,0 +1,90 @@
+// <memory> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/** @file include/memory
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_MEMORY
+#define _GLIBCXX_MEMORY 1
+
+#pragma GCC system_header
+
+/**
+ * @defgroup memory Memory
+ * @ingroup utilities
+ *
+ * Components for memory allocation, deallocation, and management.
+ */
+
+/**
+ * @defgroup pointer_abstractions Pointer Abstractions
+ * @ingroup memory
+ *
+ * Smart pointers, etc.
+ */
+
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/stl_construct.h>
+#include <bits/stl_uninitialized.h>
+#include <bits/stl_tempbuf.h>
+#include <bits/stl_raw_storage_iter.h>
+
+#if __cplusplus >= 201103L
+#  include <exception>        	  // std::exception
+#  include <typeinfo>         	  // std::type_info in get_deleter
+#  include <iosfwd>           	  // std::basic_ostream
+#  include <ext/atomicity.h>
+#  include <ext/concurrence.h>
+#  include <bits/functexcept.h>
+#  include <bits/stl_function.h>  // std::less
+#  include <bits/uses_allocator.h>
+#  include <type_traits>
+#  include <functional>
+#  include <debug/debug.h>
+#  include <bits/unique_ptr.h>
+#  include <bits/shared_ptr.h>
+#  if _GLIBCXX_USE_DEPRECATED
+#    include <backward/auto_ptr.h>
+#  endif
+#else
+#  include <backward/auto_ptr.h>
+#endif
+
+#endif /* _GLIBCXX_MEMORY */
diff --git a/gcc-4.9/libstdc++-v3/include/std/mutex b/gcc-4.9/libstdc++-v3/include/std/mutex
new file mode 100644
index 0000000..0b481d6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/mutex
@@ -0,0 +1,767 @@
+// <mutex> -*- C++ -*-
+
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/mutex
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_MUTEX
+#define _GLIBCXX_MUTEX 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <tuple>
+#include <chrono>
+#include <exception>
+#include <type_traits>
+#include <functional>
+#include <system_error>
+#include <bits/functexcept.h>
+#include <bits/gthr.h>
+#include <bits/move.h> // for std::swap
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#ifdef _GLIBCXX_HAS_GTHREADS
+  // Common base class for std::mutex and std::timed_mutex
+  class __mutex_base
+  {
+  protected:
+    typedef __gthread_mutex_t			__native_type;
+
+#ifdef __GTHREAD_MUTEX_INIT
+    __native_type  _M_mutex = __GTHREAD_MUTEX_INIT;
+
+    constexpr __mutex_base() noexcept = default;
+#else
+    __native_type  _M_mutex;
+
+    __mutex_base() noexcept
+    {
+      // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
+      __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
+    }
+
+    ~__mutex_base() noexcept { __gthread_mutex_destroy(&_M_mutex); }
+#endif
+
+    __mutex_base(const __mutex_base&) = delete;
+    __mutex_base& operator=(const __mutex_base&) = delete;
+  };
+
+  // Common base class for std::recursive_mutex and std::recursive_timed_mutex
+  class __recursive_mutex_base
+  {
+  protected:
+    typedef __gthread_recursive_mutex_t		__native_type;
+
+    __recursive_mutex_base(const __recursive_mutex_base&) = delete;
+    __recursive_mutex_base& operator=(const __recursive_mutex_base&) = delete;
+
+#ifdef __GTHREAD_RECURSIVE_MUTEX_INIT
+    __native_type  _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT;
+
+    __recursive_mutex_base() = default;
+#else
+    __native_type  _M_mutex;
+
+    __recursive_mutex_base()
+    {
+      // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
+      __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
+    }
+
+    ~__recursive_mutex_base()
+    { __gthread_recursive_mutex_destroy(&_M_mutex); }
+#endif
+  };
+
+  /**
+   * @defgroup mutexes Mutexes
+   * @ingroup concurrency
+   *
+   * Classes for mutex support.
+   * @{
+   */
+
+  /// mutex
+  class mutex : private __mutex_base
+  {
+  public:
+    typedef __native_type* 			native_handle_type;
+
+#ifdef __GTHREAD_MUTEX_INIT
+    constexpr
+#endif
+    mutex() noexcept = default;
+    ~mutex() = default;
+
+    mutex(const mutex&) = delete;
+    mutex& operator=(const mutex&) = delete;
+
+    void
+    lock()
+    {
+      int __e = __gthread_mutex_lock(&_M_mutex);
+
+      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
+      if (__e)
+	__throw_system_error(__e);
+    }
+
+    bool
+    try_lock() noexcept
+    {
+      // XXX EINVAL, EAGAIN, EBUSY
+      return !__gthread_mutex_trylock(&_M_mutex);
+    }
+
+    void
+    unlock()
+    {
+      // XXX EINVAL, EAGAIN, EPERM
+      __gthread_mutex_unlock(&_M_mutex);
+    }
+
+    native_handle_type
+    native_handle()
+    { return &_M_mutex; }
+  };
+
+  /// recursive_mutex
+  class recursive_mutex : private __recursive_mutex_base
+  {
+  public:
+    typedef __native_type* 			native_handle_type;
+
+    recursive_mutex() = default;
+    ~recursive_mutex() = default;
+
+    recursive_mutex(const recursive_mutex&) = delete;
+    recursive_mutex& operator=(const recursive_mutex&) = delete;
+
+    void
+    lock()
+    {
+      int __e = __gthread_recursive_mutex_lock(&_M_mutex);
+
+      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
+      if (__e)
+	__throw_system_error(__e);
+    }
+
+    bool
+    try_lock() noexcept
+    {
+      // XXX EINVAL, EAGAIN, EBUSY
+      return !__gthread_recursive_mutex_trylock(&_M_mutex);
+    }
+
+    void
+    unlock()
+    {
+      // XXX EINVAL, EAGAIN, EBUSY
+      __gthread_recursive_mutex_unlock(&_M_mutex);
+    }
+
+    native_handle_type
+    native_handle()
+    { return &_M_mutex; }
+  };
+
+#if _GTHREAD_USE_MUTEX_TIMEDLOCK
+  template<typename _Derived>
+    class __timed_mutex_impl
+    {
+    protected:
+      typedef chrono::high_resolution_clock 	__clock_t;
+
+      template<typename _Rep, typename _Period>
+	bool
+	_M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
+	{
+	  using chrono::steady_clock;
+	  auto __rt = chrono::duration_cast<steady_clock::duration>(__rtime);
+	  if (ratio_greater<steady_clock::period, _Period>())
+	    ++__rt;
+	  return _M_try_lock_until(steady_clock::now() + __rt);
+	}
+
+      template<typename _Duration>
+	bool
+	_M_try_lock_until(const chrono::time_point<__clock_t,
+						   _Duration>& __atime)
+	{
+	  auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
+	  auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
+
+	  __gthread_time_t __ts = {
+	    static_cast<std::time_t>(__s.time_since_epoch().count()),
+	    static_cast<long>(__ns.count())
+	  };
+
+	  auto __mutex = static_cast<_Derived*>(this)->native_handle();
+	  return !__gthread_mutex_timedlock(__mutex, &__ts);
+	}
+
+      template<typename _Clock, typename _Duration>
+	bool
+	_M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
+	{
+	  auto __rtime = __atime - _Clock::now();
+	  return _M_try_lock_until(__clock_t::now() + __rtime);
+	}
+    };
+
+  /// timed_mutex
+  class timed_mutex
+  : private __mutex_base, public __timed_mutex_impl<timed_mutex>
+  {
+  public:
+    typedef __native_type* 		  	native_handle_type;
+
+    timed_mutex() = default;
+    ~timed_mutex() = default;
+
+    timed_mutex(const timed_mutex&) = delete;
+    timed_mutex& operator=(const timed_mutex&) = delete;
+
+    void
+    lock()
+    {
+      int __e = __gthread_mutex_lock(&_M_mutex);
+
+      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
+      if (__e)
+	__throw_system_error(__e);
+    }
+
+    bool
+    try_lock() noexcept
+    {
+      // XXX EINVAL, EAGAIN, EBUSY
+      return !__gthread_mutex_trylock(&_M_mutex);
+    }
+
+    template <class _Rep, class _Period>
+      bool
+      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
+      { return _M_try_lock_for(__rtime); }
+
+    template <class _Clock, class _Duration>
+      bool
+      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
+      { return _M_try_lock_until(__atime); }
+
+    void
+    unlock()
+    {
+      // XXX EINVAL, EAGAIN, EBUSY
+      __gthread_mutex_unlock(&_M_mutex);
+    }
+
+    native_handle_type
+    native_handle()
+    { return &_M_mutex; }
+  };
+
+  /// recursive_timed_mutex
+  class recursive_timed_mutex
+  : private __recursive_mutex_base,
+    public __timed_mutex_impl<recursive_timed_mutex>
+  {
+  public:
+    typedef __native_type* 			native_handle_type;
+
+    recursive_timed_mutex() = default;
+    ~recursive_timed_mutex() = default;
+
+    recursive_timed_mutex(const recursive_timed_mutex&) = delete;
+    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
+
+    void
+    lock()
+    {
+      int __e = __gthread_recursive_mutex_lock(&_M_mutex);
+
+      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
+      if (__e)
+	__throw_system_error(__e);
+    }
+
+    bool
+    try_lock() noexcept
+    {
+      // XXX EINVAL, EAGAIN, EBUSY
+      return !__gthread_recursive_mutex_trylock(&_M_mutex);
+    }
+
+    template <class _Rep, class _Period>
+      bool
+      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
+      { return _M_try_lock_for(__rtime); }
+
+    template <class _Clock, class _Duration>
+      bool
+      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
+      { return _M_try_lock_until(__atime); }
+
+    void
+    unlock()
+    {
+      // XXX EINVAL, EAGAIN, EBUSY
+      __gthread_recursive_mutex_unlock(&_M_mutex);
+    }
+
+    native_handle_type
+    native_handle()
+    { return &_M_mutex; }
+  };
+#endif
+#endif // _GLIBCXX_HAS_GTHREADS
+
+  /// Do not acquire ownership of the mutex.
+  struct defer_lock_t { };
+
+  /// Try to acquire ownership of the mutex without blocking.
+  struct try_to_lock_t { };
+
+  /// Assume the calling thread has already obtained mutex ownership
+  /// and manage it.
+  struct adopt_lock_t { };
+
+  constexpr defer_lock_t	defer_lock { };
+  constexpr try_to_lock_t	try_to_lock { };
+  constexpr adopt_lock_t	adopt_lock { };
+
+  /// @brief  Scoped lock idiom.
+  // Acquire the mutex here with a constructor call, then release with
+  // the destructor call in accordance with RAII style.
+  template<typename _Mutex>
+    class lock_guard
+    {
+    public:
+      typedef _Mutex mutex_type;
+
+      explicit lock_guard(mutex_type& __m) : _M_device(__m)
+      { _M_device.lock(); }
+
+      lock_guard(mutex_type& __m, adopt_lock_t) : _M_device(__m)
+      { } // calling thread owns mutex
+
+      ~lock_guard()
+      { _M_device.unlock(); }
+
+      lock_guard(const lock_guard&) = delete;
+      lock_guard& operator=(const lock_guard&) = delete;
+
+    private:
+      mutex_type&  _M_device;
+    };
+
+  /// unique_lock
+  template<typename _Mutex>
+    class unique_lock
+    {
+    public:
+      typedef _Mutex mutex_type;
+
+      unique_lock() noexcept
+      : _M_device(0), _M_owns(false)
+      { }
+
+      explicit unique_lock(mutex_type& __m)
+      : _M_device(&__m), _M_owns(false)
+      {
+	lock();
+	_M_owns = true;
+      }
+
+      unique_lock(mutex_type& __m, defer_lock_t) noexcept
+      : _M_device(&__m), _M_owns(false)
+      { }
+
+      unique_lock(mutex_type& __m, try_to_lock_t)
+      : _M_device(&__m), _M_owns(_M_device->try_lock())
+      { }
+
+      unique_lock(mutex_type& __m, adopt_lock_t)
+      : _M_device(&__m), _M_owns(true)
+      {
+	// XXX calling thread owns mutex
+      }
+
+      template<typename _Clock, typename _Duration>
+	unique_lock(mutex_type& __m,
+		    const chrono::time_point<_Clock, _Duration>& __atime)
+	: _M_device(&__m), _M_owns(_M_device->try_lock_until(__atime))
+	{ }
+
+      template<typename _Rep, typename _Period>
+	unique_lock(mutex_type& __m,
+		    const chrono::duration<_Rep, _Period>& __rtime)
+	: _M_device(&__m), _M_owns(_M_device->try_lock_for(__rtime))
+	{ }
+
+      ~unique_lock()
+      {
+	if (_M_owns)
+	  unlock();
+      }
+
+      unique_lock(const unique_lock&) = delete;
+      unique_lock& operator=(const unique_lock&) = delete;
+
+      unique_lock(unique_lock&& __u) noexcept
+      : _M_device(__u._M_device), _M_owns(__u._M_owns)
+      {
+	__u._M_device = 0;
+	__u._M_owns = false;
+      }
+
+      unique_lock& operator=(unique_lock&& __u) noexcept
+      {
+	if(_M_owns)
+	  unlock();
+
+	unique_lock(std::move(__u)).swap(*this);
+
+	__u._M_device = 0;
+	__u._M_owns = false;
+
+	return *this;
+      }
+
+      void
+      lock()
+      {
+	if (!_M_device)
+	  __throw_system_error(int(errc::operation_not_permitted));
+	else if (_M_owns)
+	  __throw_system_error(int(errc::resource_deadlock_would_occur));
+	else
+	  {
+	    _M_device->lock();
+	    _M_owns = true;
+	  }
+      }
+
+      bool
+      try_lock()
+      {
+	if (!_M_device)
+	  __throw_system_error(int(errc::operation_not_permitted));
+	else if (_M_owns)
+	  __throw_system_error(int(errc::resource_deadlock_would_occur));
+	else
+	  {
+	    _M_owns = _M_device->try_lock();
+	    return _M_owns;
+	  }
+      }
+
+      template<typename _Clock, typename _Duration>
+	bool
+	try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
+	{
+	  if (!_M_device)
+	    __throw_system_error(int(errc::operation_not_permitted));
+	  else if (_M_owns)
+	    __throw_system_error(int(errc::resource_deadlock_would_occur));
+	  else
+	    {
+	      _M_owns = _M_device->try_lock_until(__atime);
+	      return _M_owns;
+	    }
+	}
+
+      template<typename _Rep, typename _Period>
+	bool
+	try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
+	{
+	  if (!_M_device)
+	    __throw_system_error(int(errc::operation_not_permitted));
+	  else if (_M_owns)
+	    __throw_system_error(int(errc::resource_deadlock_would_occur));
+	  else
+	    {
+	      _M_owns = _M_device->try_lock_for(__rtime);
+	      return _M_owns;
+	    }
+	 }
+
+      void
+      unlock()
+      {
+	if (!_M_owns)
+	  __throw_system_error(int(errc::operation_not_permitted));
+	else if (_M_device)
+	  {
+	    _M_device->unlock();
+	    _M_owns = false;
+	  }
+      }
+
+      void
+      swap(unique_lock& __u) noexcept
+      {
+	std::swap(_M_device, __u._M_device);
+	std::swap(_M_owns, __u._M_owns);
+      }
+
+      mutex_type*
+      release() noexcept
+      {
+	mutex_type* __ret = _M_device;
+	_M_device = 0;
+	_M_owns = false;
+	return __ret;
+      }
+
+      bool
+      owns_lock() const noexcept
+      { return _M_owns; }
+
+      explicit operator bool() const noexcept
+      { return owns_lock(); }
+
+      mutex_type*
+      mutex() const noexcept
+      { return _M_device; }
+
+    private:
+      mutex_type*	_M_device;
+      bool		_M_owns; // XXX use atomic_bool
+    };
+
+  /// Partial specialization for unique_lock objects.
+  template<typename _Mutex>
+    inline void
+    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
+    { __x.swap(__y); }
+
+  template<int _Idx>
+    struct __unlock_impl
+    {
+      template<typename... _Lock>
+	static void
+	__do_unlock(tuple<_Lock&...>& __locks)
+	{
+	  std::get<_Idx>(__locks).unlock();
+	  __unlock_impl<_Idx - 1>::__do_unlock(__locks);
+	}
+    };
+
+  template<>
+    struct __unlock_impl<-1>
+    {
+      template<typename... _Lock>
+	static void
+	__do_unlock(tuple<_Lock&...>&)
+	{ }
+    };
+
+  template<typename _Lock>
+    unique_lock<_Lock>
+    __try_to_lock(_Lock& __l)
+    { return unique_lock<_Lock>(__l, try_to_lock); }
+
+  template<int _Idx, bool _Continue = true>
+    struct __try_lock_impl
+    {
+      template<typename... _Lock>
+	static void
+	__do_try_lock(tuple<_Lock&...>& __locks, int& __idx)
+	{
+          __idx = _Idx;
+          auto __lock = __try_to_lock(std::get<_Idx>(__locks));
+          if (__lock.owns_lock())
+            {
+              __try_lock_impl<_Idx + 1, _Idx + 2 < sizeof...(_Lock)>::
+                __do_try_lock(__locks, __idx);
+              if (__idx == -1)
+                __lock.release();
+            }
+	}
+    };
+
+  template<int _Idx>
+    struct __try_lock_impl<_Idx, false>
+    {
+      template<typename... _Lock>
+	static void
+	__do_try_lock(tuple<_Lock&...>& __locks, int& __idx)
+	{
+          __idx = _Idx;
+          auto __lock = __try_to_lock(std::get<_Idx>(__locks));
+          if (__lock.owns_lock())
+            {
+              __idx = -1;
+              __lock.release();
+            }
+	}
+    };
+
+  /** @brief Generic try_lock.
+   *  @param __l1 Meets Mutex requirements (try_lock() may throw).
+   *  @param __l2 Meets Mutex requirements (try_lock() may throw).
+   *  @param __l3 Meets Mutex requirements (try_lock() may throw).
+   *  @return Returns -1 if all try_lock() calls return true. Otherwise returns
+   *          a 0-based index corresponding to the argument that returned false.
+   *  @post Either all arguments are locked, or none will be.
+   *
+   *  Sequentially calls try_lock() on each argument.
+   */
+  template<typename _Lock1, typename _Lock2, typename... _Lock3>
+    int
+    try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3)
+    {
+      int __idx;
+      auto __locks = std::tie(__l1, __l2, __l3...);
+      __try
+      { __try_lock_impl<0>::__do_try_lock(__locks, __idx); }
+      __catch(...)
+      { }
+      return __idx;
+    }
+
+  /** @brief Generic lock.
+   *  @param __l1 Meets Mutex requirements (try_lock() may throw).
+   *  @param __l2 Meets Mutex requirements (try_lock() may throw).
+   *  @param __l3 Meets Mutex requirements (try_lock() may throw).
+   *  @throw An exception thrown by an argument's lock() or try_lock() member.
+   *  @post All arguments are locked.
+   *
+   *  All arguments are locked via a sequence of calls to lock(), try_lock()
+   *  and unlock().  If the call exits via an exception any locks that were
+   *  obtained will be released.
+   */
+  template<typename _L1, typename _L2, typename ..._L3>
+    void
+    lock(_L1& __l1, _L2& __l2, _L3&... __l3)
+    {
+      while (true)
+        {
+          unique_lock<_L1> __first(__l1);
+          int __idx;
+          auto __locks = std::tie(__l2, __l3...);
+          __try_lock_impl<0, sizeof...(_L3)>::__do_try_lock(__locks, __idx);
+          if (__idx == -1)
+            {
+              __first.release();
+              return;
+            }
+        }
+    }
+
+#ifdef _GLIBCXX_HAS_GTHREADS
+  /// once_flag
+  struct once_flag
+  {
+  private:
+    typedef __gthread_once_t __native_type;
+    __native_type  _M_once = __GTHREAD_ONCE_INIT;
+
+  public:
+    /// Constructor
+    constexpr once_flag() noexcept = default;
+
+    /// Deleted copy constructor
+    once_flag(const once_flag&) = delete;
+    /// Deleted assignment operator
+    once_flag& operator=(const once_flag&) = delete;
+
+    template<typename _Callable, typename... _Args>
+      friend void
+      call_once(once_flag& __once, _Callable&& __f, _Args&&... __args);
+  };
+
+#ifdef _GLIBCXX_HAVE_TLS
+  extern __thread void* __once_callable;
+  extern __thread void (*__once_call)();
+
+  template<typename _Callable>
+    inline void
+    __once_call_impl()
+    {
+      (*(_Callable*)__once_callable)();
+    }
+#else
+  extern function<void()> __once_functor;
+
+  extern void
+  __set_once_functor_lock_ptr(unique_lock<mutex>*);
+
+  extern mutex&
+  __get_once_mutex();
+#endif
+
+  extern "C" void __once_proxy(void);
+
+  /// call_once
+  template<typename _Callable, typename... _Args>
+    void
+    call_once(once_flag& __once, _Callable&& __f, _Args&&... __args)
+    {
+#ifdef _GLIBCXX_HAVE_TLS
+      auto __bound_functor = std::__bind_simple(std::forward<_Callable>(__f),
+          std::forward<_Args>(__args)...);
+      __once_callable = &__bound_functor;
+      __once_call = &__once_call_impl<decltype(__bound_functor)>;
+#else
+      unique_lock<mutex> __functor_lock(__get_once_mutex());
+      auto __callable = std::__bind_simple(std::forward<_Callable>(__f),
+          std::forward<_Args>(__args)...);
+      __once_functor = [&]() { __callable(); };
+      __set_once_functor_lock_ptr(&__functor_lock);
+#endif
+
+      int __e = __gthread_once(&__once._M_once, &__once_proxy);
+
+#ifndef _GLIBCXX_HAVE_TLS
+      if (__functor_lock)
+        __set_once_functor_lock_ptr(0);
+#endif
+
+      if (__e)
+	__throw_system_error(__e);
+    }
+#endif // _GLIBCXX_HAS_GTHREADS
+
+  // @} group mutexes
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+#endif // _GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_MUTEX
diff --git a/gcc-4.9/libstdc++-v3/include/std/numeric b/gcc-4.9/libstdc++-v3/include/std/numeric
new file mode 100644
index 0000000..8c04376
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/numeric
@@ -0,0 +1,77 @@
+// <numeric> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/numeric
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_NUMERIC
+#define _GLIBCXX_NUMERIC 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stl_iterator_base_types.h>
+#include <bits/stl_numeric.h>
+
+#ifdef _GLIBCXX_PARALLEL
+# include <parallel/numeric>
+#endif
+
+/**
+ * @defgroup numerics Numerics
+ *
+ * Components for performing numeric operations. Includes support for
+ * for complex number types, random number generation, numeric
+ * (n-at-a-time) arrays, generalized numeric algorithms, and special
+ * math functions.
+ */
+
+#endif /* _GLIBCXX_NUMERIC */
diff --git a/gcc-4.9/libstdc++-v3/include/std/ostream b/gcc-4.9/libstdc++-v3/include/std/ostream
new file mode 100644
index 0000000..18a56ae
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/ostream
@@ -0,0 +1,611 @@
+// Output streams -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/ostream
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.6.2  Output streams
+//
+
+#ifndef _GLIBCXX_OSTREAM
+#define _GLIBCXX_OSTREAM 1
+
+#pragma GCC system_header
+
+#include <ios>
+#include <bits/ostream_insert.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief  Template class basic_ostream.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This is the base class for all output streams.  It provides text
+   *  formatting of all builtin types, and communicates with any class
+   *  derived from basic_streambuf to do the actual output.
+  */
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+      // Types (inherited from basic_ios):
+      typedef _CharT			 		char_type;
+      typedef typename _Traits::int_type 		int_type;
+      typedef typename _Traits::pos_type 		pos_type;
+      typedef typename _Traits::off_type 		off_type;
+      typedef _Traits			 		traits_type;
+
+      // Non-standard Types:
+      typedef basic_streambuf<_CharT, _Traits> 		__streambuf_type;
+      typedef basic_ios<_CharT, _Traits>		__ios_type;
+      typedef basic_ostream<_CharT, _Traits>		__ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+      							__num_put_type;
+      typedef ctype<_CharT>	      			__ctype_type;
+
+      /**
+       *  @brief  Base constructor.
+       *
+       *  This ctor is almost never called by the user directly, rather from
+       *  derived classes' initialization lists, which pass a pointer to
+       *  their own stream buffer.
+      */
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+
+      /**
+       *  @brief  Base destructor.
+       *
+       *  This does very little apart from providing a virtual base dtor.
+      */
+      virtual
+      ~basic_ostream() { }
+
+      /// Safe prefix/suffix operations.
+      class sentry;
+      friend class sentry;
+
+      //@{
+      /**
+       *  @brief  Interface for manipulators.
+       *
+       *  Manipulators such as @c std::endl and @c std::hex use these
+       *  functions in constructs like "std::cout << std::endl".  For more
+       *  information, see the iomanip header.
+      */
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// DR 60. What is a formatted input function?
+	// The inserters for manipulators are *not* formatted output functions.
+	return __pf(*this);
+      }
+
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// DR 60. What is a formatted input function?
+	// The inserters for manipulators are *not* formatted output functions.
+	__pf(*this);
+	return *this;
+      }
+
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// DR 60. What is a formatted input function?
+	// The inserters for manipulators are *not* formatted output functions.
+	__pf(*this);
+	return *this;
+      }
+      //@}
+
+      //@{
+      /**
+       *  @name Inserters
+       *
+       *  All the @c operator<< functions (aka <em>formatted output
+       *  functions</em>) have some common behavior.  Each starts by
+       *  constructing a temporary object of type std::basic_ostream::sentry.
+       *  This can have several effects, concluding with the setting of a
+       *  status flag; see the sentry documentation for more.
+       *
+       *  If the sentry status is good, the function tries to generate
+       *  whatever data is appropriate for the type of the argument.
+       *
+       *  If an exception is thrown during insertion, ios_base::badbit
+       *  will be turned on in the stream's error state without causing an
+       *  ios_base::failure to be thrown.  The original exception will then
+       *  be rethrown.
+      */
+
+      //@{
+      /**
+       *  @brief Integer arithmetic inserters
+       *  @param  __n A variable of builtin integral type.
+       *  @return  @c *this if successful
+       *
+       *  These functions use the stream's current locale (specifically, the
+       *  @c num_get facet) to perform numeric formatting.
+      */
+      __ostream_type&
+      operator<<(long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(bool __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(short __n);
+
+      __ostream_type&
+      operator<<(unsigned short __n)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 117. basic_ostream uses nonexistent num_put member functions.
+	return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+      __ostream_type&
+      operator<<(int __n);
+
+      __ostream_type&
+      operator<<(unsigned int __n)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 117. basic_ostream uses nonexistent num_put member functions.
+	return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+#ifdef _GLIBCXX_USE_LONG_LONG
+      __ostream_type&
+      operator<<(long long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long long __n)
+      { return _M_insert(__n); }
+#endif
+      //@}
+
+      //@{
+      /**
+       *  @brief  Floating point arithmetic inserters
+       *  @param  __f A variable of builtin floating point type.
+       *  @return  @c *this if successful
+       *
+       *  These functions use the stream's current locale (specifically, the
+       *  @c num_get facet) to perform numeric formatting.
+      */
+      __ostream_type&
+      operator<<(double __f)
+      { return _M_insert(__f); }
+
+      __ostream_type&
+      operator<<(float __f)
+      {
+	// _GLIBCXX_RESOLVE_LIB_DEFECTS
+	// 117. basic_ostream uses nonexistent num_put member functions.
+	return _M_insert(static_cast<double>(__f));
+      }
+
+      __ostream_type&
+      operator<<(long double __f)
+      { return _M_insert(__f); }
+      //@}
+
+      /**
+       *  @brief  Pointer arithmetic inserters
+       *  @param  __p A variable of pointer type.
+       *  @return  @c *this if successful
+       *
+       *  These functions use the stream's current locale (specifically, the
+       *  @c num_get facet) to perform numeric formatting.
+      */
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+
+      /**
+       *  @brief  Extracting from another streambuf.
+       *  @param  __sb  A pointer to a streambuf
+       *
+       *  This function behaves like one of the basic arithmetic extractors,
+       *  in that it also constructs a sentry object and has the same error
+       *  handling behavior.
+       *
+       *  If @p __sb is NULL, the stream will set failbit in its error state.
+       *
+       *  Characters are extracted from @p __sb and inserted into @c *this
+       *  until one of the following occurs:
+       *
+       *  - the input stream reaches end-of-file,
+       *  - insertion into the output sequence fails (in this case, the
+       *    character that would have been inserted is not extracted), or
+       *  - an exception occurs while getting a character from @p __sb, which
+       *    sets failbit in the error state
+       *
+       *  If the function inserts no characters, failbit is set.
+      */
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+      //@}
+
+      //@{
+      /**
+       *  @name Unformatted Output Functions
+       *
+       *  All the unformatted output functions have some common behavior.
+       *  Each starts by constructing a temporary object of type
+       *  std::basic_ostream::sentry.  This has several effects, concluding
+       *  with the setting of a status flag; see the sentry documentation
+       *  for more.
+       *
+       *  If the sentry status is good, the function tries to generate
+       *  whatever data is appropriate for the type of the argument.
+       *
+       *  If an exception is thrown during insertion, ios_base::badbit
+       *  will be turned on in the stream's error state.  If badbit is on in
+       *  the stream's exceptions mask, the exception will be rethrown
+       *  without completing its actions.
+      */
+
+      /**
+       *  @brief  Simple insertion.
+       *  @param  __c  The character to insert.
+       *  @return  *this
+       *
+       *  Tries to insert @p __c.
+       *
+       *  @note  This function is not overloaded on signed char and
+       *         unsigned char.
+      */
+      __ostream_type&
+      put(char_type __c);
+
+      /**
+       *  @brief  Core write functionality, without sentry.
+       *  @param  __s  The array to insert.
+       *  @param  __n  Maximum number of characters to insert.
+      */
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+	const streamsize __put = this->rdbuf()->sputn(__s, __n);
+	if (__put != __n)
+	  this->setstate(ios_base::badbit);
+      }
+
+      /**
+       *  @brief  Character string insertion.
+       *  @param  __s  The array to insert.
+       *  @param  __n  Maximum number of characters to insert.
+       *  @return  *this
+       *
+       *  Characters are copied from @p __s and inserted into the stream until
+       *  one of the following happens:
+       *
+       *  - @p __n characters are inserted
+       *  - inserting into the output sequence fails (in this case, badbit
+       *    will be set in the stream's error state)
+       *
+       *  @note  This function is not overloaded on signed char and
+       *         unsigned char.
+      */
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+      //@}
+
+      /**
+       *  @brief  Synchronizing the stream buffer.
+       *  @return  *this
+       *
+       *  If @c rdbuf() is a null pointer, changes nothing.
+       *
+       *  Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
+       *  sets badbit.
+      */
+      __ostream_type&
+      flush();
+
+      /**
+       *  @brief  Getting the current write position.
+       *  @return  A file position object.
+       *
+       *  If @c fail() is not false, returns @c pos_type(-1) to indicate
+       *  failure.  Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
+      */
+      pos_type
+      tellp();
+
+      /**
+       *  @brief  Changing the current write position.
+       *  @param  __pos  A file position object.
+       *  @return  *this
+       *
+       *  If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos).  If
+       *  that function fails, sets failbit.
+      */
+      __ostream_type&
+      seekp(pos_type);
+
+      /**
+       *  @brief  Changing the current write position.
+       *  @param  __off  A file offset object.
+       *  @param  __dir  The direction in which to seek.
+       *  @return  *this
+       *
+       *  If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
+       *  If that function fails, sets failbit.
+      */
+       __ostream_type&
+      seekp(off_type, ios_base::seekdir);
+
+    protected:
+      basic_ostream()
+      { this->init(0); }
+
+      template<typename _ValueT>
+	__ostream_type&
+	_M_insert(_ValueT __v);
+    };
+
+  /**
+   *  @brief  Performs setup work for output streams.
+   *
+   *  Objects of this class are created before all of the standard
+   *  inserters are run.  It is responsible for <em>exception-safe prefix and
+   *  suffix operations</em>.
+  */
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+      // Data Members.
+      bool 				_M_ok;
+      basic_ostream<_CharT, _Traits>& 	_M_os;
+
+    public:
+      /**
+       *  @brief  The constructor performs preparatory work.
+       *  @param  __os  The output stream to guard.
+       *
+       *  If the stream state is good (@a __os.good() is true), then if the
+       *  stream is tied to another output stream, @c is.tie()->flush()
+       *  is called to synchronize the output sequences.
+       *
+       *  If the stream state is still good, then the sentry state becomes
+       *  true (@a okay).
+      */
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+
+      /**
+       *  @brief  Possibly flushes the stream.
+       *
+       *  If @c ios_base::unitbuf is set in @c os.flags(), and
+       *  @c std::uncaught_exception() is true, the sentry destructor calls
+       *  @c flush() on the output stream.
+      */
+      ~sentry()
+      {
+	// XXX MT
+	if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
+	  {
+	    // Can't call flush directly or else will get into recursive lock.
+	    if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
+	      _M_os.setstate(ios_base::badbit);
+	  }
+      }
+
+      /**
+       *  @brief  Quick status checking.
+       *  @return  The sentry state.
+       *
+       *  For ease of use, sentries may be converted to booleans.  The
+       *  return value is that of the sentry state (true == okay).
+      */
+#if __cplusplus >= 201103L
+      explicit
+#endif
+      operator bool() const
+      { return _M_ok; }
+    };
+
+  //@{
+  /**
+   *  @brief  Character inserters
+   *  @param  __out  An output stream.
+   *  @param  __c  A character.
+   *  @return  out
+   *
+   *  Behaves like one of the formatted arithmetic inserters described in
+   *  std::basic_ostream.  After constructing a sentry object with good
+   *  status, this function inserts a single character and any required
+   *  padding (as determined by [22.2.2.2.2]).  @c __out.width(0) is then
+   *  called.
+   *
+   *  If @p __c is of type @c char and the character type of the stream is not
+   *  @c char, the character is widened before insertion.
+  */
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
+    { return (__out << __out.widen(__c)); }
+
+  // Specialization
+  template <class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, char __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+  // Signed and unsigned
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
+    { return (__out << static_cast<char>(__c)); }
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
+    { return (__out << static_cast<char>(__c)); }
+  //@}
+
+  //@{
+  /**
+   *  @brief  String inserters
+   *  @param  __out  An output stream.
+   *  @param  __s  A character string.
+   *  @return  out
+   *  @pre  @p __s must be a non-NULL pointer
+   *
+   *  Behaves like one of the formatted arithmetic inserters described in
+   *  std::basic_ostream.  After constructing a sentry object with good
+   *  status, this function inserts @c traits::length(__s) characters starting
+   *  at @p __s, widened if necessary, followed by any required padding (as
+   *  determined by [22.2.2.2.2]).  @c __out.width(0) is then called.
+  */
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    {
+      if (!__s)
+	__out.setstate(ios_base::badbit);
+      else
+	__ostream_insert(__out, __s,
+			 static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits> &
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+
+  // Partial specializations
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+	__out.setstate(ios_base::badbit);
+      else
+	__ostream_insert(__out, __s,
+			 static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+  // Signed and unsigned
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits> &
+    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+  //@}
+
+  // Standard basic_ostream manipulators
+
+  /**
+   *  @brief  Write a newline and flush the stream.
+   *
+   *  This manipulator is often mistakenly used when a simple newline is
+   *  desired, leading to poor buffering performance.  See
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
+   *  for more on this subject.
+  */
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+
+  /**
+   *  @brief  Write a null character into the output sequence.
+   *
+   *  <em>Null character</em> is @c CharT() by definition.  For CharT
+   *  of @c char, this correctly writes the ASCII @c NUL character
+   *  string terminator.
+  */
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    ends(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.put(_CharT()); }
+
+  /**
+   *  @brief  Flushes the output stream.
+   *
+   *  This manipulator simply calls the stream's @c flush() member function.
+  */
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    flush(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.flush(); }
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief  Generic inserter for rvalue stream
+   *  @param  __os  An input stream.
+   *  @param  __x  A reference to the object being inserted.
+   *  @return  os
+   *
+   *  This is just a forwarding function to allow insertion to
+   *  rvalue streams since they won't bind to the inserter functions
+   *  that take an lvalue reference.
+  */
+  template<typename _CharT, typename _Traits, typename _Tp>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
+    { return (__os << __x); }
+#endif // C++11
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#include <bits/ostream.tcc>
+
+#endif	/* _GLIBCXX_OSTREAM */
diff --git a/gcc-4.9/libstdc++-v3/include/std/queue b/gcc-4.9/libstdc++-v3/include/std/queue
new file mode 100644
index 0000000..43a10f9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/queue
@@ -0,0 +1,66 @@
+// <queue> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/queue
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_QUEUE
+#define _GLIBCXX_QUEUE 1
+
+#pragma GCC system_header
+
+#include <deque>
+#include <vector>
+#include <bits/stl_heap.h>
+#include <bits/stl_function.h>
+#include <bits/stl_queue.h>
+
+#endif /* _GLIBCXX_QUEUE */
diff --git a/gcc-4.9/libstdc++-v3/include/std/random b/gcc-4.9/libstdc++-v3/include/std/random
new file mode 100644
index 0000000..d9d89c3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/random
@@ -0,0 +1,57 @@
+// <random> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/random
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_RANDOM
+#define _GLIBCXX_RANDOM 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <cmath>
+#include <cstdlib>
+#include <string>
+#include <iosfwd>
+#include <limits>
+#include <debug/debug.h>
+#include <type_traits>
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+#include <cstdint> // For uint_fast32_t, uint_fast64_t, uint_least32_t
+#include <bits/random.h>
+#include <bits/opt_random.h>
+#include <bits/random.tcc>
+
+#endif // _GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_RANDOM
diff --git a/gcc-4.9/libstdc++-v3/include/std/ratio b/gcc-4.9/libstdc++-v3/include/std/ratio
new file mode 100644
index 0000000..624e198
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/ratio
@@ -0,0 +1,538 @@
+// ratio -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the 
+// terms of the GNU General Public License as published by the 
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/ratio
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_RATIO
+#define _GLIBCXX_RATIO 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <type_traits>
+#include <cstdint>
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup ratio Rational Arithmetic
+   * @ingroup utilities
+   *
+   * Compile time representation of finite rational numbers.
+   * @{
+   */
+
+  template<intmax_t _Pn>
+    struct __static_sign
+    : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1>
+    { };
+
+  template<intmax_t _Pn>
+    struct __static_abs
+    : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value>
+    { };
+
+  template<intmax_t _Pn, intmax_t _Qn>
+    struct __static_gcd
+    : __static_gcd<_Qn, (_Pn % _Qn)>
+    { };
+
+  template<intmax_t _Pn>
+    struct __static_gcd<_Pn, 0>
+    : integral_constant<intmax_t, __static_abs<_Pn>::value>
+    { };
+
+  template<intmax_t _Qn>
+    struct __static_gcd<0, _Qn>
+    : integral_constant<intmax_t, __static_abs<_Qn>::value>
+    { };
+
+  // Let c = 2^(half # of bits in an intmax_t)
+  // then we find a1, a0, b1, b0 s.t. N = a1*c + a0, M = b1*c + b0
+  // The multiplication of N and M becomes,
+  // N * M = (a1 * b1)c^2 + (a0 * b1 + b0 * a1)c + a0 * b0
+  // Multiplication is safe if each term and the sum of the terms
+  // is representable by intmax_t.
+  template<intmax_t _Pn, intmax_t _Qn>
+    struct __safe_multiply
+    {
+    private:
+      static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
+
+      static const uintmax_t __a0 = __static_abs<_Pn>::value % __c;
+      static const uintmax_t __a1 = __static_abs<_Pn>::value / __c;
+      static const uintmax_t __b0 = __static_abs<_Qn>::value % __c;
+      static const uintmax_t __b1 = __static_abs<_Qn>::value / __c;
+
+      static_assert(__a1 == 0 || __b1 == 0, 
+		    "overflow in multiplication");
+      static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), 
+		    "overflow in multiplication");
+      static_assert(__b0 * __a0 <= __INTMAX_MAX__, 
+		    "overflow in multiplication");
+      static_assert((__a0 * __b1 + __b0 * __a1) * __c
+		    <= __INTMAX_MAX__ -  __b0 * __a0,
+		    "overflow in multiplication");
+
+    public:
+      static const intmax_t value = _Pn * _Qn;
+    };
+
+  // Some double-precision utilities, where numbers are represented as
+  // __hi*2^(8*sizeof(uintmax_t)) + __lo.
+  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
+    struct __big_less
+    : integral_constant<bool, (__hi1 < __hi2
+			       || (__hi1 == __hi2 && __lo1 < __lo2))>
+    { };
+
+  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
+    struct __big_add
+    {
+      static constexpr uintmax_t __lo = __lo1 + __lo2;
+      static constexpr uintmax_t __hi = (__hi1 + __hi2 +
+					 (__lo1 + __lo2 < __lo1)); // carry
+    };
+
+  // Subtract a number from a bigger one.
+  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
+    struct __big_sub
+    {
+      static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value,
+		    "Internal library error");
+      static constexpr uintmax_t __lo = __lo1 - __lo2;
+      static constexpr uintmax_t __hi = (__hi1 - __hi2 -
+					 (__lo1 < __lo2)); // carry
+    };
+
+  // Same principle as __safe_multiply.
+  template<uintmax_t __x, uintmax_t __y>
+    struct __big_mul
+    {
+    private:
+      static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
+      static constexpr uintmax_t __x0 = __x % __c;
+      static constexpr uintmax_t __x1 = __x / __c;
+      static constexpr uintmax_t __y0 = __y % __c;
+      static constexpr uintmax_t __y1 = __y / __c;
+      static constexpr uintmax_t __x0y0 = __x0 * __y0;
+      static constexpr uintmax_t __x0y1 = __x0 * __y1;
+      static constexpr uintmax_t __x1y0 = __x1 * __y0;
+      static constexpr uintmax_t __x1y1 = __x1 * __y1;
+      static constexpr uintmax_t __mix = __x0y1 + __x1y0; // possible carry...
+      static constexpr uintmax_t __mix_lo = __mix * __c;
+      static constexpr uintmax_t __mix_hi
+      = __mix / __c + ((__mix < __x0y1) ? __c : 0); // ... added here
+      typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res;
+    public:
+      static constexpr uintmax_t __hi = _Res::__hi;
+      static constexpr uintmax_t __lo = _Res::__lo;
+    };
+
+  // Adapted from __udiv_qrnnd_c in longlong.h
+  // This version assumes that the high bit of __d is 1.
+  template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
+    struct __big_div_impl
+    {
+    private:
+      static_assert(__d >= (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)),
+		    "Internal library error");
+      static_assert(__n1 < __d, "Internal library error");
+      static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
+      static constexpr uintmax_t __d1 = __d / __c;
+      static constexpr uintmax_t __d0 = __d % __c;
+
+      static constexpr uintmax_t __q1x = __n1 / __d1;
+      static constexpr uintmax_t __r1x = __n1 % __d1;
+      static constexpr uintmax_t __m = __q1x * __d0;
+      static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c;
+      static constexpr uintmax_t __r1z = __r1y + __d;
+      static constexpr uintmax_t __r1
+      = ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m))
+	 ? (__r1z + __d) : __r1z : __r1y) - __m;
+      static constexpr uintmax_t __q1
+      = __q1x - ((__r1y < __m)
+		 ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0);
+      static constexpr uintmax_t __q0x = __r1 / __d1;
+      static constexpr uintmax_t __r0x = __r1 % __d1;
+      static constexpr uintmax_t __n = __q0x * __d0;
+      static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c;
+      static constexpr uintmax_t __r0z = __r0y + __d;
+      static constexpr uintmax_t __r0
+      = ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n))
+	 ? (__r0z + __d) : __r0z : __r0y) - __n;
+      static constexpr uintmax_t __q0
+      = __q0x - ((__r0y < __n) ? ((__r0z >= __d)
+				  && (__r0z < __n)) ? 2 : 1 : 0);
+
+    public:
+      static constexpr uintmax_t __quot = __q1 * __c + __q0;
+      static constexpr uintmax_t __rem = __r0;
+
+    private:
+      typedef __big_mul<__quot, __d> _Prod;
+      typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum;
+      static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
+		    "Internal library error");
+  };
+
+  template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
+    struct __big_div
+    {
+    private:
+      static_assert(__d != 0, "Internal library error");
+      static_assert(sizeof (uintmax_t) == sizeof (unsigned long long),
+		    "This library calls __builtin_clzll on uintmax_t, which "
+		    "is unsafe on your platform. Please complain to "
+		    "http://gcc.gnu.org/bugzilla/");
+      static constexpr int __shift = __builtin_clzll(__d);
+      static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift;
+      static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0;
+      static constexpr uintmax_t __c1 = uintmax_t(1) << __shift;
+      static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift;
+      static constexpr uintmax_t __new_d = __d * __c1;
+      static constexpr uintmax_t __new_n0 = __n0 * __c1;
+      static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1;
+      static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0;
+      static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top;
+      typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res;
+
+    public:
+      static constexpr uintmax_t __quot_hi = __n1 / __d;
+      static constexpr uintmax_t __quot_lo = _Res::__quot;
+      static constexpr uintmax_t __rem = _Res::__rem / __c1;
+
+    private:
+      typedef __big_mul<__quot_lo, __d> _P0;
+      typedef __big_mul<__quot_hi, __d> _P1;
+      typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum;
+      // No overflow.
+      static_assert(_P1::__hi == 0, "Internal library error");
+      static_assert(_Sum::__hi >= _P0::__hi, "Internal library error");
+      // Matches the input data.
+      static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
+		    "Internal library error");
+      static_assert(__rem < __d, "Internal library error");
+    };
+
+  /**
+   *  @brief Provides compile-time rational arithmetic.
+   *
+   *  This class template represents any finite rational number with a
+   *  numerator and denominator representable by compile-time constants of
+   *  type intmax_t. The ratio is simplified when instantiated.
+   *
+   *  For example:
+   *  @code
+   *    std::ratio<7,-21>::num == -1;
+   *    std::ratio<7,-21>::den == 3;
+   *  @endcode
+   *  
+  */
+  template<intmax_t _Num, intmax_t _Den = 1>
+    struct ratio
+    {
+      static_assert(_Den != 0, "denominator cannot be zero");
+      static_assert(_Num >= -__INTMAX_MAX__ && _Den >= -__INTMAX_MAX__,
+		    "out of range");
+
+      // Note: sign(N) * abs(N) == N
+      static constexpr intmax_t num =
+        _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;
+
+      static constexpr intmax_t den =
+        __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;
+
+      typedef ratio<num, den> type;
+    };
+
+  template<intmax_t _Num, intmax_t _Den>
+    constexpr intmax_t ratio<_Num, _Den>::num;
+
+  template<intmax_t _Num, intmax_t _Den>
+    constexpr intmax_t ratio<_Num, _Den>::den;
+
+  template<typename _R1, typename _R2>
+    struct __ratio_multiply
+    {
+    private:
+      static const intmax_t __gcd1 =
+        __static_gcd<_R1::num, _R2::den>::value;
+      static const intmax_t __gcd2 =
+        __static_gcd<_R2::num, _R1::den>::value;
+
+    public:
+      typedef ratio<
+        __safe_multiply<(_R1::num / __gcd1),
+                        (_R2::num / __gcd2)>::value,
+        __safe_multiply<(_R1::den / __gcd2),
+                        (_R2::den / __gcd1)>::value> type;
+
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_multiply<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_multiply<_R1, _R2>::den;
+
+  /// ratio_multiply
+  template<typename _R1, typename _R2>
+    using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;
+
+  template<typename _R1, typename _R2>
+    struct __ratio_divide
+    {
+      static_assert(_R2::num != 0, "division by 0");
+
+      typedef typename __ratio_multiply<
+        _R1,
+        ratio<_R2::den, _R2::num>>::type type;
+
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_divide<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_divide<_R1, _R2>::den;
+
+  /// ratio_divide
+  template<typename _R1, typename _R2>
+    using ratio_divide = typename __ratio_divide<_R1, _R2>::type;
+
+  /// ratio_equal
+  template<typename _R1, typename _R2>
+    struct ratio_equal
+    : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>
+    { };
+  
+  /// ratio_not_equal
+  template<typename _R1, typename _R2>
+    struct ratio_not_equal
+    : integral_constant<bool, !ratio_equal<_R1, _R2>::value>
+    { };
+
+  // Both numbers are positive.
+  template<typename _R1, typename _R2,
+           typename _Left = __big_mul<_R1::num,_R2::den>,
+           typename _Right = __big_mul<_R2::num,_R1::den> >
+    struct __ratio_less_impl_1
+    : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,
+           _Right::__hi, _Right::__lo>::value>
+    { }; 
+
+  template<typename _R1, typename _R2,
+	   bool = (_R1::num == 0 || _R2::num == 0
+		   || (__static_sign<_R1::num>::value
+		       != __static_sign<_R2::num>::value)),
+	   bool = (__static_sign<_R1::num>::value == -1
+		   && __static_sign<_R2::num>::value == -1)>
+    struct __ratio_less_impl
+    : __ratio_less_impl_1<_R1, _R2>::type
+    { };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_less_impl<_R1, _R2, true, false>
+    : integral_constant<bool, _R1::num < _R2::num>
+    { };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_less_impl<_R1, _R2, false, true>
+    : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>,
+           ratio<-_R1::num, _R1::den> >::type
+    { };
+
+  /// ratio_less
+  template<typename _R1, typename _R2>
+    struct ratio_less
+    : __ratio_less_impl<_R1, _R2>::type
+    { };
+    
+  /// ratio_less_equal
+  template<typename _R1, typename _R2>
+    struct ratio_less_equal
+    : integral_constant<bool, !ratio_less<_R2, _R1>::value>
+    { };
+  
+  /// ratio_greater
+  template<typename _R1, typename _R2>
+    struct ratio_greater
+    : integral_constant<bool, ratio_less<_R2, _R1>::value>
+    { };
+
+  /// ratio_greater_equal
+  template<typename _R1, typename _R2>
+    struct ratio_greater_equal
+    : integral_constant<bool, !ratio_less<_R1, _R2>::value>
+    { };
+
+  template<typename _R1, typename _R2,
+      bool = (_R1::num >= 0),
+      bool = (_R2::num >= 0),
+      bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>,
+        ratio<__static_abs<_R2::num>::value, _R2::den> >::value>
+    struct __ratio_add_impl
+    {
+    private:
+      typedef typename __ratio_add_impl<
+        ratio<-_R1::num, _R1::den>,
+        ratio<-_R2::num, _R2::den> >::type __t;
+    public:
+      typedef ratio<-__t::num, __t::den> type;
+    };
+
+  // True addition of nonnegative numbers.
+  template<typename _R1, typename _R2, bool __b>
+    struct __ratio_add_impl<_R1, _R2, true, true, __b>
+    {
+    private:
+      static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
+      static constexpr uintmax_t __d2 = _R2::den / __g;
+      typedef __big_mul<_R1::den, __d2> __d;
+      typedef __big_mul<_R1::num, _R2::den / __g> __x;
+      typedef __big_mul<_R2::num, _R1::den / __g> __y;
+      typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
+      static_assert(__n::__hi >= __x::__hi, "Internal library error");
+      typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
+      static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
+      typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
+      static_assert(__n_final::__rem == 0, "Internal library error");
+      static_assert(__n_final::__quot_hi == 0 &&
+        __n_final::__quot_lo <= __INTMAX_MAX__, "overflow in addition");
+      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
+      static_assert(__d_final::__hi == 0 &&
+        __d_final::__lo <= __INTMAX_MAX__, "overflow in addition");
+    public:
+      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
+    };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_add_impl<_R1, _R2, false, true, true>
+    : __ratio_add_impl<_R2, _R1>
+    { };
+
+  // True subtraction of nonnegative numbers yielding a nonnegative result.
+  template<typename _R1, typename _R2>
+    struct __ratio_add_impl<_R1, _R2, true, false, false>
+    {
+    private:
+      static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
+      static constexpr uintmax_t __d2 = _R2::den / __g;
+      typedef __big_mul<_R1::den, __d2> __d;
+      typedef __big_mul<_R1::num, _R2::den / __g> __x;
+      typedef __big_mul<-_R2::num, _R1::den / __g> __y;
+      typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
+      typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
+      static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
+      typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
+      static_assert(__n_final::__rem == 0, "Internal library error");
+      static_assert(__n_final::__quot_hi == 0 &&
+        __n_final::__quot_lo <= __INTMAX_MAX__, "overflow in addition");
+      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
+      static_assert(__d_final::__hi == 0 &&
+        __d_final::__lo <= __INTMAX_MAX__, "overflow in addition");
+    public:
+      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
+    };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_add
+    {
+      typedef typename __ratio_add_impl<_R1, _R2>::type type;
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_add<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_add<_R1, _R2>::den;
+
+  /// ratio_add
+  template<typename _R1, typename _R2>
+    using ratio_add = typename __ratio_add<_R1, _R2>::type;
+
+  template<typename _R1, typename _R2>
+    struct __ratio_subtract
+    {
+      typedef typename __ratio_add<
+        _R1,
+        ratio<-_R2::num, _R2::den>>::type type;
+
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_subtract<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_subtract<_R1, _R2>::den;
+
+  /// ratio_subtract
+  template<typename _R1, typename _R2>
+    using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;
+
+
+  typedef ratio<1,       1000000000000000000> atto;
+  typedef ratio<1,          1000000000000000> femto;
+  typedef ratio<1,             1000000000000> pico;
+  typedef ratio<1,                1000000000> nano;
+  typedef ratio<1,                   1000000> micro;
+  typedef ratio<1,                      1000> milli;
+  typedef ratio<1,                       100> centi;
+  typedef ratio<1,                        10> deci;
+  typedef ratio<                       10, 1> deca;
+  typedef ratio<                      100, 1> hecto;
+  typedef ratio<                     1000, 1> kilo;
+  typedef ratio<                  1000000, 1> mega;
+  typedef ratio<               1000000000, 1> giga;
+  typedef ratio<            1000000000000, 1> tera;
+  typedef ratio<         1000000000000000, 1> peta;
+  typedef ratio<      1000000000000000000, 1> exa;
+
+  // @} group ratio
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif //_GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif //_GLIBCXX_RATIO
diff --git a/gcc-4.9/libstdc++-v3/include/std/regex b/gcc-4.9/libstdc++-v3/include/std/regex
new file mode 100644
index 0000000..9161f48
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/regex
@@ -0,0 +1,65 @@
+// <regex> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/regex
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_REGEX
+#define _GLIBCXX_REGEX 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <algorithm>
+#include <bitset>
+#include <functional>
+#ifdef _GLIBCXX_DEBUG
+# include <iosfwd>
+#endif
+#include <iterator>
+#include <locale>
+#include <memory>
+#include <sstream>
+#include <stack>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+#include <cstring>
+
+#include <bits/regex_constants.h>
+#include <bits/regex_error.h>
+#include <bits/regex_automaton.h>
+#include <bits/regex.h>
+#include <bits/regex_scanner.h>
+#include <bits/regex_compiler.h>
+#include <bits/regex_executor.h>
+
+#endif // C++11
+
+#endif // _GLIBCXX_REGEX
diff --git a/gcc-4.9/libstdc++-v3/include/std/scoped_allocator b/gcc-4.9/libstdc++-v3/include/std/scoped_allocator
new file mode 100644
index 0000000..33d8779
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/scoped_allocator
@@ -0,0 +1,463 @@
+// <scoped_allocator> -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/scoped_allocator
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _SCOPED_ALLOCATOR
+#define _SCOPED_ALLOCATOR 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <utility>
+#include <tuple>
+#include <bits/alloc_traits.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<template<typename> class _Pred, typename... _Allocs>
+    struct __any_of;
+
+  template<template<typename> class _Pred, typename _Alloc, typename... _Allocs>
+    struct __any_of<_Pred, _Alloc, _Allocs...>
+    : __or_<_Pred<_Alloc>, __any_of<_Pred, _Allocs...>>
+    { };
+
+  template<template<typename> class _Pred, typename _Alloc>
+    struct __any_of<_Pred, _Alloc>
+    : _Pred<_Alloc>
+    { };
+
+  /**
+   * @addtogroup allocators
+   * @{
+   */
+
+  template<typename _Alloc>
+    struct __propagate_on_copy
+    : allocator_traits<_Alloc>::propagate_on_container_copy_assignment
+    { };
+  template<typename _Alloc>
+    struct __propagate_on_move
+    : allocator_traits<_Alloc>::propagate_on_container_move_assignment
+    { };
+  template<typename _Alloc>
+    struct __propagate_on_swap
+    : allocator_traits<_Alloc>::propagate_on_container_swap
+    { };
+
+
+  template<typename _Alloc>
+    inline auto
+    __do_outermost(_Alloc& __a, _Alloc*) -> decltype(__a.outer_allocator())
+    { return __a.outer_allocator(); }
+
+  template<typename _Alloc>
+    inline _Alloc&
+    __do_outermost(_Alloc& __a, ...)
+    { return __a; }
+
+  // TODO: make recursive (see note in 20.12.4/1)
+  template<typename _Alloc>
+    inline auto
+    __outermost(_Alloc& __a) -> decltype(__do_outermost(__a, &__a))
+    { return __do_outermost(__a, &__a); }
+
+  template<typename _OuterAlloc, typename... _InnerAllocs>
+    class scoped_allocator_adaptor;
+
+  template<typename...> 
+    struct __inner_type_impl;
+
+  template<typename _Outer>
+    struct __inner_type_impl<_Outer>
+    {
+      typedef scoped_allocator_adaptor<_Outer> __type;
+
+      __inner_type_impl() = default;
+      __inner_type_impl(const __inner_type_impl&) = default;
+      __inner_type_impl(__inner_type_impl&&) = default;
+      
+      template<typename _Alloc>
+      __inner_type_impl(const __inner_type_impl<_Alloc>& __other)
+      { }
+      
+      template<typename _Alloc>
+      __inner_type_impl(__inner_type_impl<_Alloc>&& __other)
+      { }
+      
+      __type& 
+      _M_get(__type* __p) noexcept { return *__p; }
+
+      const __type& 
+      _M_get(const __type* __p) const noexcept { return *__p; }
+      
+      tuple<> 
+      _M_tie() const noexcept { return tuple<>(); }
+      
+      bool 
+      operator==(const __inner_type_impl&) const noexcept
+      { return true; }
+    };
+
+  template<typename _Outer, typename _InnerHead, typename... _InnerTail>
+    struct __inner_type_impl<_Outer, _InnerHead, _InnerTail...>
+    {
+      typedef scoped_allocator_adaptor<_InnerHead, _InnerTail...> __type;
+      
+      __inner_type_impl() = default;
+      __inner_type_impl(const __inner_type_impl&) = default;
+      __inner_type_impl(__inner_type_impl&&) = default;
+      
+      template<typename... _Allocs>
+      __inner_type_impl(const __inner_type_impl<_Allocs...>& __other)
+      : _M_inner(__other._M_inner) { }
+      
+      template<typename... _Allocs>
+      __inner_type_impl(__inner_type_impl<_Allocs...>&& __other)
+      : _M_inner(std::move(__other._M_inner)) { }
+
+    template<typename... _Args>
+      explicit
+      __inner_type_impl(_Args&&... __args)
+      : _M_inner(std::forward<_Args>(__args)...) { }
+
+      __type& 
+      _M_get(void*) noexcept { return _M_inner; }
+      
+      const __type& 
+      _M_get(const void*) const noexcept { return _M_inner; }
+      
+      tuple<const _InnerHead&, const _InnerTail&...> 
+      _M_tie() const noexcept
+      { return _M_inner._M_tie(); }
+      
+      bool 
+      operator==(const __inner_type_impl& __other) const noexcept
+      { return _M_inner == __other._M_inner; }
+      
+    private:
+      template<typename...> friend class __inner_type_impl;
+      template<typename, typename...> friend class scoped_allocator_adaptor;
+      
+      __type _M_inner;
+    };
+
+  /// Primary class template.
+  template<typename _OuterAlloc, typename... _InnerAllocs>
+    class scoped_allocator_adaptor
+    : public _OuterAlloc
+    {
+      typedef allocator_traits<_OuterAlloc> __traits;
+
+      typedef __inner_type_impl<_OuterAlloc, _InnerAllocs...> __inner_type;
+      __inner_type _M_inner;
+
+      template<typename _Outer, typename... _Inner>
+        friend class scoped_allocator_adaptor;
+
+      template<typename...>
+        friend class __inner_type_impl;
+
+      tuple<const _OuterAlloc&, const _InnerAllocs&...>
+      _M_tie() const noexcept
+      { return std::tuple_cat(std::tie(outer_allocator()), _M_inner._M_tie()); }
+
+      template<typename _Alloc>
+	using __outermost_type = typename
+	  std::decay<decltype(__outermost(std::declval<_Alloc&>()))>::type;
+
+      template<typename _Alloc>
+	using __outermost_alloc_traits
+	  = allocator_traits<__outermost_type<_Alloc>>;
+      
+      template<typename _Tp, typename... _Args>
+        void 
+        _M_construct(__uses_alloc0, _Tp* __p, _Args&&... __args)
+        {
+	  typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
+	  _O_traits::construct(__outermost(*this), __p,
+			       std::forward<_Args>(__args)...);
+        }
+
+      typedef __uses_alloc1<typename __inner_type::__type> __uses_alloc1_;
+      typedef __uses_alloc2<typename __inner_type::__type> __uses_alloc2_;
+
+      template<typename _Tp, typename... _Args>
+        void 
+        _M_construct(__uses_alloc1_, _Tp* __p, _Args&&... __args)
+        {
+	  typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
+	  _O_traits::construct(__outermost(*this), __p,
+			       allocator_arg, inner_allocator(),
+			       std::forward<_Args>(__args)...);
+        }
+
+      template<typename _Tp, typename... _Args>
+        void 
+        _M_construct(__uses_alloc2_, _Tp* __p, _Args&&... __args)
+        {
+	  typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
+	  _O_traits::construct(__outermost(*this), __p,
+			       std::forward<_Args>(__args)...,
+			       inner_allocator());
+        }
+
+      template<typename _Alloc>
+        static _Alloc
+        _S_select_on_copy(const _Alloc& __a)
+        {
+          typedef allocator_traits<_Alloc> __a_traits;
+          return __a_traits::select_on_container_copy_construction(__a);
+        }
+
+      template<std::size_t... _Indices>
+        scoped_allocator_adaptor(tuple<const _OuterAlloc&,
+                                       const _InnerAllocs&...> __refs,
+                                 _Index_tuple<_Indices...>)
+        : _OuterAlloc(_S_select_on_copy(std::get<0>(__refs))),
+          _M_inner(_S_select_on_copy(std::get<_Indices+1>(__refs))...)
+        { }
+
+    public:
+      typedef _OuterAlloc                       outer_allocator_type;
+      typedef typename __inner_type::__type     inner_allocator_type;
+
+      typedef typename __traits::value_type             value_type;
+      typedef typename __traits::size_type              size_type;
+      typedef typename __traits::difference_type        difference_type;
+      typedef typename __traits::pointer                pointer;
+      typedef typename __traits::const_pointer          const_pointer;
+      typedef typename __traits::void_pointer           void_pointer;
+      typedef typename __traits::const_void_pointer     const_void_pointer;
+
+      typedef typename conditional<
+        __any_of<__propagate_on_copy, _OuterAlloc, _InnerAllocs...>::value,
+        true_type, false_type>::type propagate_on_container_copy_assignment;
+      typedef typename conditional<
+        __any_of<__propagate_on_move, _OuterAlloc, _InnerAllocs...>::value,
+        true_type, false_type>::type propagate_on_container_move_assignment;
+      typedef typename conditional<
+        __any_of<__propagate_on_swap, _OuterAlloc, _InnerAllocs...>::value,
+        true_type, false_type>::type propagate_on_container_swap;
+
+      template <class _Tp>
+        struct rebind
+        {
+          typedef scoped_allocator_adaptor<
+            typename __traits::template rebind_alloc<_Tp>,
+            _InnerAllocs...> other;
+        };
+
+      scoped_allocator_adaptor() : _OuterAlloc(), _M_inner() { }
+
+      template<typename _Outer2>
+        scoped_allocator_adaptor(_Outer2&& __outer,
+                                 const _InnerAllocs&... __inner)
+        : _OuterAlloc(std::forward<_Outer2>(__outer)),
+          _M_inner(__inner...)
+        { }
+
+      scoped_allocator_adaptor(const scoped_allocator_adaptor& __other)
+      : _OuterAlloc(__other.outer_allocator()),
+	_M_inner(__other._M_inner)
+      { }
+
+      scoped_allocator_adaptor(scoped_allocator_adaptor&& __other)
+      : _OuterAlloc(std::move(__other.outer_allocator())),
+	_M_inner(std::move(__other._M_inner))
+      { }
+
+      template<typename _Outer2>
+        scoped_allocator_adaptor(
+            const scoped_allocator_adaptor<_Outer2, _InnerAllocs...>& __other)
+        : _OuterAlloc(__other.outer_allocator()),
+          _M_inner(__other._M_inner)
+        { }
+
+      template<typename _Outer2>
+        scoped_allocator_adaptor(
+            scoped_allocator_adaptor<_Outer2, _InnerAllocs...>&& __other)
+        : _OuterAlloc(std::move(__other.outer_allocator())),
+          _M_inner(std::move(__other._M_inner))
+        { }
+
+      inner_allocator_type& inner_allocator() noexcept
+      { return _M_inner._M_get(this); }
+
+      const inner_allocator_type& inner_allocator() const noexcept
+      { return _M_inner._M_get(this); }
+
+      outer_allocator_type& outer_allocator() noexcept
+      { return static_cast<_OuterAlloc&>(*this); }
+
+      const outer_allocator_type& outer_allocator() const noexcept
+      { return static_cast<const _OuterAlloc&>(*this); }
+
+      pointer allocate(size_type __n)
+      { return __traits::allocate(outer_allocator(), __n); }
+
+      pointer allocate(size_type __n, const_void_pointer __hint)
+      { return __traits::allocate(outer_allocator(), __n, __hint); }
+
+      void deallocate(pointer __p, size_type __n)
+      { return __traits::deallocate(outer_allocator(), __p, __n); }
+
+      size_type max_size() const
+      { return __traits::max_size(outer_allocator()); }
+
+      template<typename _Tp, typename... _Args>
+        void construct(_Tp* __p, _Args&&... __args)
+        {
+          auto& __inner = inner_allocator();
+          auto __use_tag
+            = __use_alloc<_Tp, inner_allocator_type, _Args...>(__inner);
+          _M_construct(__use_tag, __p, std::forward<_Args>(__args)...);
+        }
+
+      template<typename _T1, typename _T2, typename... _Args1,
+	       typename... _Args2>
+	void
+	construct(pair<_T1, _T2>* __p, piecewise_construct_t,
+		  tuple<_Args1...> __x, tuple<_Args2...> __y)
+	{
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 2203.  wrong argument types for piecewise construction
+	  auto& __inner = inner_allocator();
+	  auto __x_use_tag
+	    = __use_alloc<_T1, inner_allocator_type, _Args1...>(__inner);
+	  auto __y_use_tag
+	    = __use_alloc<_T2, inner_allocator_type, _Args2...>(__inner);
+	  typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
+	  _O_traits::construct(__outermost(*this), __p, piecewise_construct,
+			       _M_construct_p(__x_use_tag, __x),
+			       _M_construct_p(__y_use_tag, __y));
+	}
+
+      template<typename _T1, typename _T2>
+	void
+	construct(pair<_T1, _T2>* __p)
+	{ construct(__p, piecewise_construct, tuple<>(), tuple<>()); }
+
+      template<typename _T1, typename _T2, typename _Up, typename _Vp>
+	void
+	construct(pair<_T1, _T2>* __p, _Up&& __u, _Vp&& __v)
+	{
+	  construct(__p, piecewise_construct,
+		    std::forward_as_tuple(std::forward<_Up>(__u)),
+		    std::forward_as_tuple(std::forward<_Vp>(__v)));
+	}
+
+      template<typename _T1, typename _T2, typename _Up, typename _Vp>
+	void
+	construct(pair<_T1, _T2>* __p, const pair<_Up, _Vp>& __x)
+	{
+	  construct(__p, piecewise_construct,
+		    std::forward_as_tuple(__x.first),
+		    std::forward_as_tuple(__x.second));
+	}
+
+      template<typename _T1, typename _T2, typename _Up, typename _Vp>
+	void
+	construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x)
+	{
+	  construct(__p, piecewise_construct,
+		    std::forward_as_tuple(std::forward<_Up>(__x.first)),
+		    std::forward_as_tuple(std::forward<_Vp>(__x.second)));
+	}
+
+      template<typename _Tp>
+        void destroy(_Tp* __p)
+        {
+	  typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
+	  _O_traits::destroy(__outermost(*this), __p);
+	}
+
+      scoped_allocator_adaptor
+      select_on_container_copy_construction() const
+      {
+        typedef typename _Build_index_tuple<sizeof...(_InnerAllocs)>::__type
+	    _Indices;
+        return scoped_allocator_adaptor(_M_tie(), _Indices());
+      }
+
+      template <typename _OutA1, typename _OutA2, typename... _InA>
+      friend bool
+      operator==(const scoped_allocator_adaptor<_OutA1, _InA...>& __a,
+                 const scoped_allocator_adaptor<_OutA2, _InA...>& __b) noexcept;
+
+    private:
+      template<typename _Tuple>
+	_Tuple&&
+	_M_construct_p(__uses_alloc0, _Tuple& __t)
+	{ return std::move(__t); }
+
+      template<typename... _Args>
+	std::tuple<allocator_arg_t, inner_allocator_type&, _Args...>
+	_M_construct_p(__uses_alloc1_, std::tuple<_Args...>& __t)
+	{
+	  typedef std::tuple<allocator_arg_t, inner_allocator_type&> _Tuple;
+	  return std::tuple_cat(_Tuple(allocator_arg, inner_allocator()),
+				std::move(__t));
+	}
+
+      template<typename... _Args>
+	std::tuple<_Args..., inner_allocator_type&>
+	_M_construct_p(__uses_alloc2_, std::tuple<_Args...>& __t)
+	{
+	  typedef std::tuple<inner_allocator_type&> _Tuple;
+	  return std::tuple_cat(std::move(__t), _Tuple(inner_allocator()));
+	}
+    };
+
+  template <typename _OutA1, typename _OutA2, typename... _InA>
+    inline bool
+    operator==(const scoped_allocator_adaptor<_OutA1, _InA...>& __a,
+               const scoped_allocator_adaptor<_OutA2, _InA...>& __b) noexcept
+    {
+      return __a.outer_allocator() == __b.outer_allocator()
+          && __a._M_inner == __b._M_inner;
+    }
+
+  template <typename _OutA1, typename _OutA2, typename... _InA>
+    inline bool
+    operator!=(const scoped_allocator_adaptor<_OutA1, _InA...>& __a,
+               const scoped_allocator_adaptor<_OutA2, _InA...>& __b) noexcept
+    { return !(__a == __b); }
+
+  /// @}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // C++11
+
+#endif // _SCOPED_ALLOCATOR
diff --git a/gcc-4.9/libstdc++-v3/include/std/set b/gcc-4.9/libstdc++-v3/include/std/set
new file mode 100644
index 0000000..cbb17f3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/set
@@ -0,0 +1,73 @@
+// <set> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/set
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_SET
+#define _GLIBCXX_SET 1
+
+#pragma GCC system_header
+
+#include <bits/stl_tree.h>
+#include <bits/stl_set.h>
+#include <bits/stl_multiset.h>
+#include <bits/range_access.h>
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/set>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/set>
+#endif
+
+#endif /* _GLIBCXX_SET */
diff --git a/gcc-4.9/libstdc++-v3/include/std/shared_mutex b/gcc-4.9/libstdc++-v3/include/std/shared_mutex
new file mode 100644
index 0000000..53b39f8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/shared_mutex
@@ -0,0 +1,399 @@
+// <shared_mutex> -*- C++ -*-
+
+// Copyright (C) 2013-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/shared_mutex
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_SHARED_MUTEX
+#define _GLIBCXX_SHARED_MUTEX 1
+
+#pragma GCC system_header
+
+#if __cplusplus <= 201103L
+# include <bits/c++14_warning.h>
+#else
+
+#include <bits/c++config.h>
+#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
+# include <mutex>
+# include <condition_variable>
+#endif
+#include <bits/functexcept.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @ingroup mutexes
+   * @{
+   */
+
+#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
+  /// shared_timed_mutex
+  class shared_timed_mutex
+  {
+#if _GTHREAD_USE_MUTEX_TIMEDLOCK
+    struct _Mutex : mutex, __timed_mutex_impl<_Mutex>
+    {
+      template<typename _Rep, typename _Period>
+	bool
+	try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
+	{ return _M_try_lock_for(__rtime); }
+
+      template<typename _Clock, typename _Duration>
+	bool
+	try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
+	{ return _M_try_lock_until(__atime); }
+    };
+#else
+    typedef mutex _Mutex;
+#endif
+
+    // Based on Howard Hinnant's reference implementation from N2406
+
+    _Mutex		_M_mut;
+    condition_variable	_M_gate1;
+    condition_variable	_M_gate2;
+    unsigned		_M_state;
+
+    static constexpr unsigned _S_write_entered
+      = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1);
+    static constexpr unsigned _M_n_readers = ~_S_write_entered;
+
+  public:
+    shared_timed_mutex() : _M_state(0) {}
+
+    ~shared_timed_mutex()
+    {
+      _GLIBCXX_DEBUG_ASSERT( _M_state == 0 );
+    }
+
+    shared_timed_mutex(const shared_timed_mutex&) = delete;
+    shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
+
+    // Exclusive ownership
+
+    void
+    lock()
+    {
+      unique_lock<mutex> __lk(_M_mut);
+      while (_M_state & _S_write_entered)
+	_M_gate1.wait(__lk);
+      _M_state |= _S_write_entered;
+      while (_M_state & _M_n_readers)
+	_M_gate2.wait(__lk);
+    }
+
+    bool
+    try_lock()
+    {
+      unique_lock<mutex> __lk(_M_mut, try_to_lock);
+      if (__lk.owns_lock() && _M_state == 0)
+	{
+	  _M_state = _S_write_entered;
+	  return true;
+	}
+      return false;
+    }
+
+#if _GTHREAD_USE_MUTEX_TIMEDLOCK
+    template<typename _Rep, typename _Period>
+      bool
+      try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
+      {
+	unique_lock<_Mutex> __lk(_M_mut, __rel_time);
+	if (__lk.owns_lock() && _M_state == 0)
+	  {
+	    _M_state = _S_write_entered;
+	    return true;
+	  }
+	return false;
+      }
+
+    template<typename _Clock, typename _Duration>
+      bool
+      try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
+      {
+	unique_lock<_Mutex> __lk(_M_mut, __abs_time);
+	if (__lk.owns_lock() && _M_state == 0)
+	  {
+	    _M_state = _S_write_entered;
+	    return true;
+	  }
+	return false;
+      }
+#endif
+
+    void
+    unlock()
+    {
+      {
+	lock_guard<_Mutex> __lk(_M_mut);
+	_M_state = 0;
+      }
+      _M_gate1.notify_all();
+    }
+
+    // Shared ownership
+
+    void
+    lock_shared()
+    {
+      unique_lock<mutex> __lk(_M_mut);
+      while ((_M_state & _S_write_entered)
+	  || (_M_state & _M_n_readers) == _M_n_readers)
+	{
+	  _M_gate1.wait(__lk);
+	}
+      unsigned __num_readers = (_M_state & _M_n_readers) + 1;
+      _M_state &= ~_M_n_readers;
+      _M_state |= __num_readers;
+    }
+
+    bool
+    try_lock_shared()
+    {
+      unique_lock<_Mutex> __lk(_M_mut, try_to_lock);
+      unsigned __num_readers = _M_state & _M_n_readers;
+      if (__lk.owns_lock() && !(_M_state & _S_write_entered)
+	  && __num_readers != _M_n_readers)
+	{
+	  ++__num_readers;
+	  _M_state &= ~_M_n_readers;
+	  _M_state |= __num_readers;
+	  return true;
+	}
+      return false;
+    }
+
+#if _GTHREAD_USE_MUTEX_TIMEDLOCK
+    template<typename _Rep, typename _Period>
+      bool
+      try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
+      {
+	unique_lock<_Mutex> __lk(_M_mut, __rel_time);
+	if (__lk.owns_lock())
+	  {
+	    unsigned __num_readers = _M_state & _M_n_readers;
+	    if (!(_M_state & _S_write_entered)
+		&& __num_readers != _M_n_readers)
+	      {
+		++__num_readers;
+		_M_state &= ~_M_n_readers;
+		_M_state |= __num_readers;
+		return true;
+	      }
+	  }
+	return false;
+      }
+
+    template <typename _Clock, typename _Duration>
+      bool
+      try_lock_shared_until(const chrono::time_point<_Clock,
+						     _Duration>& __abs_time)
+      {
+	unique_lock<_Mutex> __lk(_M_mut, __abs_time);
+	if (__lk.owns_lock())
+	  {
+	    unsigned __num_readers = _M_state & _M_n_readers;
+	    if (!(_M_state & _S_write_entered)
+		&& __num_readers != _M_n_readers)
+	      {
+		++__num_readers;
+		_M_state &= ~_M_n_readers;
+		_M_state |= __num_readers;
+		return true;
+	      }
+	  }
+	return false;
+      }
+#endif
+
+    void
+    unlock_shared()
+    {
+      lock_guard<_Mutex> __lk(_M_mut);
+      unsigned __num_readers = (_M_state & _M_n_readers) - 1;
+      _M_state &= ~_M_n_readers;
+      _M_state |= __num_readers;
+      if (_M_state & _S_write_entered)
+	{
+	  if (__num_readers == 0)
+	    _M_gate2.notify_one();
+	}
+      else
+	{
+	  if (__num_readers == _M_n_readers - 1)
+	    _M_gate1.notify_one();
+	}
+    }
+  };
+#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
+
+  /// shared_lock
+  template<typename _Mutex>
+    class shared_lock
+    {
+    public:
+      typedef _Mutex mutex_type;
+
+      // Shared locking
+
+      shared_lock() noexcept : _M_pm(nullptr), _M_owns(false) { }
+
+      explicit
+      shared_lock(mutex_type& __m) : _M_pm(&__m), _M_owns(true)
+      { __m.lock_shared(); }
+
+      shared_lock(mutex_type& __m, defer_lock_t) noexcept
+      : _M_pm(&__m), _M_owns(false) { }
+
+      shared_lock(mutex_type& __m, try_to_lock_t)
+      : _M_pm(&__m), _M_owns(__m.try_lock_shared()) { }
+
+      shared_lock(mutex_type& __m, adopt_lock_t)
+      : _M_pm(&__m), _M_owns(true) { }
+
+      template<typename _Clock, typename _Duration>
+	shared_lock(mutex_type& __m,
+		    const chrono::time_point<_Clock, _Duration>& __abs_time)
+      : _M_pm(&__m), _M_owns(__m.try_lock_shared_until(__abs_time)) { }
+
+      template<typename _Rep, typename _Period>
+	shared_lock(mutex_type& __m,
+		    const chrono::duration<_Rep, _Period>& __rel_time)
+      : _M_pm(&__m), _M_owns(__m.try_lock_shared_for(__rel_time)) { }
+
+      ~shared_lock()
+      {
+	if (_M_owns)
+	  _M_pm->unlock_shared();
+      }
+
+      shared_lock(shared_lock const&) = delete;
+      shared_lock& operator=(shared_lock const&) = delete;
+
+      shared_lock(shared_lock&& __sl) noexcept : shared_lock()
+      { swap(__sl); }
+
+      shared_lock&
+      operator=(shared_lock&& __sl) noexcept
+      {
+	shared_lock(std::move(__sl)).swap(*this);
+	return *this;
+      }
+
+      void
+      lock()
+      {
+	_M_lockable();
+	_M_pm->lock_shared();
+	_M_owns = true;
+      }
+
+      bool
+      try_lock()
+      {
+	_M_lockable();
+	return _M_owns = _M_pm->try_lock_shared();
+      }
+
+      template<typename _Rep, typename _Period>
+	bool
+	try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
+	{
+	  _M_lockable();
+	  return _M_owns = _M_pm->try_lock_shared_for(__rel_time);
+	}
+
+      template<typename _Clock, typename _Duration>
+	bool
+	try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
+	{
+	  _M_lockable();
+	  return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
+	}
+
+      void
+      unlock()
+      {
+	if (!_M_owns)
+	  __throw_system_error(int(errc::resource_deadlock_would_occur));
+	_M_pm->unlock_shared();
+	_M_owns = false;
+      }
+
+      // Setters
+
+      void
+      swap(shared_lock& __u) noexcept
+      {
+	std::swap(_M_pm, __u._M_pm);
+	std::swap(_M_owns, __u._M_owns);
+      }
+
+      mutex_type*
+      release() noexcept
+      {
+	_M_owns = false;
+	return std::exchange(_M_pm, nullptr);
+      }
+
+      // Getters
+
+      bool owns_lock() const noexcept { return _M_owns; }
+
+      explicit operator bool() const noexcept { return _M_owns; }
+
+      mutex_type* mutex() const noexcept { return _M_pm; }
+
+    private:
+      void
+      _M_lockable() const
+      {
+	if (_M_pm == nullptr)
+	  __throw_system_error(int(errc::operation_not_permitted));
+	if (_M_owns)
+	  __throw_system_error(int(errc::resource_deadlock_would_occur));
+      }
+
+      mutex_type*	_M_pm;
+      bool		_M_owns;
+    };
+
+  /// Swap specialization for shared_lock
+  template<typename _Mutex>
+    void
+    swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
+    { __x.swap(__y); }
+
+  // @} group mutexes
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // C++14
+
+#endif // _GLIBCXX_SHARED_MUTEX
diff --git a/gcc-4.9/libstdc++-v3/include/std/sstream b/gcc-4.9/libstdc++-v3/include/std/sstream
new file mode 100644
index 0000000..74ce16c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/sstream
@@ -0,0 +1,602 @@
+// String based streams -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/sstream
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.7  String-based streams
+//
+
+#ifndef _GLIBCXX_SSTREAM
+#define _GLIBCXX_SSTREAM 1
+
+#pragma GCC system_header
+
+#include <istream>
+#include <ostream>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // [27.7.1] template class basic_stringbuf
+  /**
+   *  @brief  The actual work of input and output (for std::string).
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
+   *
+   *  This class associates either or both of its input and output sequences
+   *  with a sequence of characters, which can be initialized from, or made
+   *  available as, a @c std::basic_string.  (Paraphrased from [27.7.1]/1.)
+   *
+   *  For this class, open modes (of type @c ios_base::openmode) have
+   *  @c in set if the input sequence can be read, and @c out set if the
+   *  output sequence can be written.
+  */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 251. basic_stringbuf missing allocator_type
+      typedef _Alloc				       	allocator_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      typedef basic_streambuf<char_type, traits_type>  	__streambuf_type;
+      typedef basic_string<char_type, _Traits, _Alloc> 	__string_type;
+      typedef typename __string_type::size_type		__size_type;
+
+    protected:
+      /// Place to stash in || out || in | out settings for current stringbuf.
+      ios_base::openmode 	_M_mode;
+
+      // Data Members:
+      __string_type 		_M_string;
+
+    public:
+      // Constructors:
+      /**
+       *  @brief  Starts with an empty string buffer.
+       *  @param  __mode  Whether the buffer can read, or write, or both.
+       *
+       *  The default constructor initializes the parent class using its
+       *  own default ctor.
+      */
+      explicit
+      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(__mode), _M_string()
+      { }
+
+      /**
+       *  @brief  Starts with an existing string buffer.
+       *  @param  __str  A string to copy as a starting buffer.
+       *  @param  __mode  Whether the buffer can read, or write, or both.
+       *
+       *  This constructor initializes the parent class using its
+       *  own default ctor.
+      */
+      explicit
+      basic_stringbuf(const __string_type& __str,
+		      ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
+      { _M_stringbuf_init(__mode); }
+
+      // Get and set:
+      /**
+       *  @brief  Copying out the string buffer.
+       *  @return  A copy of one of the underlying sequences.
+       *
+       *  <em>If the buffer is only created in input mode, the underlying
+       *  character sequence is equal to the input sequence; otherwise, it
+       *  is equal to the output sequence.</em> [27.7.1.2]/1
+      */
+      __string_type
+      str() const
+      {
+	__string_type __ret;
+	if (this->pptr())
+	  {
+	    // The current egptr() may not be the actual string end.
+	    if (this->pptr() > this->egptr())
+	      __ret = __string_type(this->pbase(), this->pptr());
+	    else
+ 	      __ret = __string_type(this->pbase(), this->egptr());
+	  }
+	else
+	  __ret = _M_string;
+	return __ret;
+      }
+
+      /**
+       *  @brief  Setting a new buffer.
+       *  @param  __s  The string to use as a new sequence.
+       *
+       *  Deallocates any previous stored sequence, then copies @a s to
+       *  use as a new one.
+      */
+      void
+      str(const __string_type& __s)
+      {
+	// Cannot use _M_string = __s, since v3 strings are COW.
+	_M_string.assign(__s.data(), __s.size());
+	_M_stringbuf_init(_M_mode);
+      }
+
+    protected:
+      // Common initialization code goes here.
+      void
+      _M_stringbuf_init(ios_base::openmode __mode)
+      {
+	_M_mode = __mode;
+	__size_type __len = 0;
+	if (_M_mode & (ios_base::ate | ios_base::app))
+	  __len = _M_string.size();
+	_M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
+      }
+
+      virtual streamsize
+      showmanyc()
+      { 
+	streamsize __ret = -1;
+	if (_M_mode & ios_base::in)
+	  {
+	    _M_update_egptr();
+	    __ret = this->egptr() - this->gptr();
+	  }
+	return __ret;
+      }
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof());
+
+      virtual int_type
+      overflow(int_type __c = traits_type::eof());
+
+      /**
+       *  @brief  Manipulates the buffer.
+       *  @param  __s  Pointer to a buffer area.
+       *  @param  __n  Size of @a __s.
+       *  @return  @c this
+       *
+       *  If no buffer has already been created, and both @a __s and @a __n are
+       *  non-zero, then @c __s is used as a buffer; see
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
+       *  for more.
+      */
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n)
+      {
+	if (__s && __n >= 0)
+	  {
+	    // This is implementation-defined behavior, and assumes
+	    // that an external char_type array of length __n exists
+	    // and has been pre-allocated. If this is not the case,
+	    // things will quickly blow up.
+	    
+	    // Step 1: Destroy the current internal array.
+	    _M_string.clear();
+	    
+	    // Step 2: Use the external array.
+	    _M_sync(__s, __n, 0);
+	  }
+	return this;
+      }
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+	      ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __sp,
+	      ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      // Internal function for correctly updating the internal buffer
+      // for a particular _M_string, due to initialization or re-sizing
+      // of an existing _M_string.
+      void
+      _M_sync(char_type* __base, __size_type __i, __size_type __o);
+
+      // Internal function for correctly updating egptr() to the actual
+      // string end.
+      void
+      _M_update_egptr()
+      {
+	const bool __testin = _M_mode & ios_base::in;
+	if (this->pptr() && this->pptr() > this->egptr())
+	  {
+	    if (__testin)
+	      this->setg(this->eback(), this->gptr(), this->pptr());
+	    else
+	      this->setg(this->pptr(), this->pptr(), this->pptr());
+	  }
+      }
+
+      // Works around the issue with pbump, part of the protected
+      // interface of basic_streambuf, taking just an int.
+      void
+      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
+    };
+
+
+  // [27.7.2] Template class basic_istringstream
+  /**
+   *  @brief  Controlling input for std::string.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
+   *
+   *  This class supports reading from objects of type std::basic_string,
+   *  using the inherited functions from std::basic_istream.  To control
+   *  the associated sequence, an instance of std::basic_stringbuf is used,
+   *  which this page refers to as @c sb.
+  */
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_istringstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 251. basic_stringbuf missing allocator_type
+      typedef _Alloc				       	allocator_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      // Non-standard types:
+      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> 	__stringbuf_type;
+      typedef basic_istream<char_type, traits_type>	__istream_type;
+
+    private:
+      __stringbuf_type	_M_stringbuf;
+
+    public:
+      // Constructors:
+      /**
+       *  @brief  Default constructor starts with an empty string buffer.
+       *  @param  __mode  Whether the buffer can read, or write, or both.
+       *
+       *  @c ios_base::in is automatically included in @a __mode.
+       *
+       *  Initializes @c sb using @c __mode|in, and passes @c &sb to the base
+       *  class initializer.  Does not allocate any buffer.
+       *
+       *  That's a lie.  We initialize the base class with NULL, because the
+       *  string class does its own memory management.
+      */
+      explicit
+      basic_istringstream(ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+
+      /**
+       *  @brief  Starts with an existing string buffer.
+       *  @param  __str  A string to copy as a starting buffer.
+       *  @param  __mode  Whether the buffer can read, or write, or both.
+       *
+       *  @c ios_base::in is automatically included in @a mode.
+       *
+       *  Initializes @c sb using @a str and @c mode|in, and passes @c &sb
+       *  to the base class initializer.
+       *
+       *  That's a lie.  We initialize the base class with NULL, because the
+       *  string class does its own memory management.
+      */
+      explicit
+      basic_istringstream(const __string_type& __str,
+			  ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+
+      /**
+       *  @brief  The destructor does nothing.
+       *
+       *  The buffer is deallocated by the stringbuf object, not the
+       *  formatting stream.
+      */
+      ~basic_istringstream()
+      { }
+
+      // Members:
+      /**
+       *  @brief  Accessing the underlying buffer.
+       *  @return  The current basic_stringbuf buffer.
+       *
+       *  This hides both signatures of std::basic_ios::rdbuf().
+      */
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+      /**
+       *  @brief  Copying out the string buffer.
+       *  @return  @c rdbuf()->str()
+      */
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+      /**
+       *  @brief  Setting a new buffer.
+       *  @param  __s  The string to use as a new sequence.
+       *
+       *  Calls @c rdbuf()->str(s).
+      */
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+
+
+  // [27.7.3] Template class basic_ostringstream
+  /**
+   *  @brief  Controlling output for std::string.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
+   *
+   *  This class supports writing to objects of type std::basic_string,
+   *  using the inherited functions from std::basic_ostream.  To control
+   *  the associated sequence, an instance of std::basic_stringbuf is used,
+   *  which this page refers to as @c sb.
+  */
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 251. basic_stringbuf missing allocator_type
+      typedef _Alloc				       	allocator_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      // Non-standard types:
+      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> 	__stringbuf_type;
+      typedef basic_ostream<char_type, traits_type>	__ostream_type;
+
+    private:
+      __stringbuf_type	_M_stringbuf;
+
+    public:
+      // Constructors/destructor:
+      /**
+       *  @brief  Default constructor starts with an empty string buffer.
+       *  @param  __mode  Whether the buffer can read, or write, or both.
+       *
+       *  @c ios_base::out is automatically included in @a mode.
+       *
+       *  Initializes @c sb using @c mode|out, and passes @c &sb to the base
+       *  class initializer.  Does not allocate any buffer.
+       *
+       *  That's a lie.  We initialize the base class with NULL, because the
+       *  string class does its own memory management.
+      */
+      explicit
+      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+
+      /**
+       *  @brief  Starts with an existing string buffer.
+       *  @param  __str  A string to copy as a starting buffer.
+       *  @param  __mode  Whether the buffer can read, or write, or both.
+       *
+       *  @c ios_base::out is automatically included in @a mode.
+       *
+       *  Initializes @c sb using @a str and @c mode|out, and passes @c &sb
+       *  to the base class initializer.
+       *
+       *  That's a lie.  We initialize the base class with NULL, because the
+       *  string class does its own memory management.
+      */
+      explicit
+      basic_ostringstream(const __string_type& __str,
+			  ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+
+      /**
+       *  @brief  The destructor does nothing.
+       *
+       *  The buffer is deallocated by the stringbuf object, not the
+       *  formatting stream.
+      */
+      ~basic_ostringstream()
+      { }
+
+      // Members:
+      /**
+       *  @brief  Accessing the underlying buffer.
+       *  @return  The current basic_stringbuf buffer.
+       *
+       *  This hides both signatures of std::basic_ios::rdbuf().
+      */
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+      /**
+       *  @brief  Copying out the string buffer.
+       *  @return  @c rdbuf()->str()
+      */
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+      /**
+       *  @brief  Setting a new buffer.
+       *  @param  __s  The string to use as a new sequence.
+       *
+       *  Calls @c rdbuf()->str(s).
+      */
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+
+
+  // [27.7.4] Template class basic_stringstream
+  /**
+   *  @brief  Controlling input and output for std::string.
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
+   *
+   *  This class supports reading from and writing to objects of type
+   *  std::basic_string, using the inherited functions from
+   *  std::basic_iostream.  To control the associated sequence, an instance
+   *  of std::basic_stringbuf is used, which this page refers to as @c sb.
+  */
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+      // Types:
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 251. basic_stringbuf missing allocator_type
+      typedef _Alloc				       	allocator_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+
+      // Non-standard Types:
+      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> 	__stringbuf_type;
+      typedef basic_iostream<char_type, traits_type>	__iostream_type;
+
+    private:
+      __stringbuf_type	_M_stringbuf;
+
+    public:
+      // Constructors/destructors
+      /**
+       *  @brief  Default constructor starts with an empty string buffer.
+       *  @param  __m  Whether the buffer can read, or write, or both.
+       *
+       *  Initializes @c sb using the mode from @c __m, and passes @c
+       *  &sb to the base class initializer.  Does not allocate any
+       *  buffer.
+       *
+       *  That's a lie.  We initialize the base class with NULL, because the
+       *  string class does its own memory management.
+      */
+      explicit
+      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__m)
+      { this->init(&_M_stringbuf); }
+
+      /**
+       *  @brief  Starts with an existing string buffer.
+       *  @param  __str  A string to copy as a starting buffer.
+       *  @param  __m  Whether the buffer can read, or write, or both.
+       *
+       *  Initializes @c sb using @a __str and @c __m, and passes @c &sb
+       *  to the base class initializer.
+       *
+       *  That's a lie.  We initialize the base class with NULL, because the
+       *  string class does its own memory management.
+      */
+      explicit
+      basic_stringstream(const __string_type& __str,
+			 ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__str, __m)
+      { this->init(&_M_stringbuf); }
+
+      /**
+       *  @brief  The destructor does nothing.
+       *
+       *  The buffer is deallocated by the stringbuf object, not the
+       *  formatting stream.
+      */
+      ~basic_stringstream()
+      { }
+
+      // Members:
+      /**
+       *  @brief  Accessing the underlying buffer.
+       *  @return  The current basic_stringbuf buffer.
+       *
+       *  This hides both signatures of std::basic_ios::rdbuf().
+      */
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+      /**
+       *  @brief  Copying out the string buffer.
+       *  @return  @c rdbuf()->str()
+      */
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+      /**
+       *  @brief  Setting a new buffer.
+       *  @param  __s  The string to use as a new sequence.
+       *
+       *  Calls @c rdbuf()->str(s).
+      */
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/sstream.tcc>
+
+#endif /* _GLIBCXX_SSTREAM */
diff --git a/gcc-4.9/libstdc++-v3/include/std/stack b/gcc-4.9/libstdc++-v3/include/std/stack
new file mode 100644
index 0000000..07ced5c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/stack
@@ -0,0 +1,63 @@
+// <stack> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/stack
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_STACK
+#define _GLIBCXX_STACK 1
+
+#pragma GCC system_header
+
+#include <deque>
+#include <bits/stl_stack.h>
+
+#endif /* _GLIBCXX_STACK */
diff --git a/gcc-4.9/libstdc++-v3/include/std/stdexcept b/gcc-4.9/libstdc++-v3/include/std/stdexcept
new file mode 100644
index 0000000..ff18405
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/stdexcept
@@ -0,0 +1,158 @@
+// Standard exception classes  -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/stdexcept
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 19.1  Exception classes
+//
+
+#ifndef _GLIBCXX_STDEXCEPT
+#define _GLIBCXX_STDEXCEPT 1
+
+#pragma GCC system_header
+
+#include <exception>
+#include <string>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup exceptions
+   * @{
+   */
+
+  /** Logic errors represent problems in the internal logic of a program;
+   *  in theory, these are preventable, and even detectable before the
+   *  program runs (e.g., violations of class invariants).
+   *  @brief One of two subclasses of exception.
+   */
+  class logic_error : public exception 
+  {
+    string _M_msg;
+
+  public:
+    /** Takes a character string describing the error.  */
+    explicit 
+    logic_error(const string& __arg);
+
+    virtual ~logic_error() _GLIBCXX_USE_NOEXCEPT;
+
+    /** Returns a C-style character string describing the general cause of
+     *  the current error (the same string passed to the ctor).  */
+    virtual const char* 
+    what() const _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** Thrown by the library, or by you, to report domain errors (domain in
+   *  the mathematical sense).  */
+  class domain_error : public logic_error 
+  {
+  public:
+    explicit domain_error(const string& __arg);
+    virtual ~domain_error() _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** Thrown to report invalid arguments to functions.  */
+  class invalid_argument : public logic_error 
+  {
+  public:
+    explicit invalid_argument(const string& __arg);
+    virtual ~invalid_argument() _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** Thrown when an object is constructed that would exceed its maximum
+   *  permitted size (e.g., a basic_string instance).  */
+  class length_error : public logic_error 
+  {
+  public:
+    explicit length_error(const string& __arg);
+    virtual ~length_error() _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** This represents an argument whose value is not within the expected
+   *  range (e.g., boundary checks in basic_string).  */
+  class out_of_range : public logic_error 
+  {
+  public:
+    explicit out_of_range(const string& __arg);
+    virtual ~out_of_range() _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** Runtime errors represent problems outside the scope of a program;
+   *  they cannot be easily predicted and can generally only be caught as
+   *  the program executes.
+   *  @brief One of two subclasses of exception.
+   */
+  class runtime_error : public exception 
+  {
+    string _M_msg;
+
+  public:
+    /** Takes a character string describing the error.  */
+    explicit 
+    runtime_error(const string& __arg);
+
+    virtual ~runtime_error() _GLIBCXX_USE_NOEXCEPT;
+
+    /** Returns a C-style character string describing the general cause of
+     *  the current error (the same string passed to the ctor).  */
+    virtual const char* 
+    what() const _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** Thrown to indicate range errors in internal computations.  */
+  class range_error : public runtime_error 
+  {
+  public:
+    explicit range_error(const string& __arg);
+    virtual ~range_error() _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** Thrown to indicate arithmetic overflow.  */
+  class overflow_error : public runtime_error 
+  {
+  public:
+    explicit overflow_error(const string& __arg);
+    virtual ~overflow_error() _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  /** Thrown to indicate arithmetic underflow.  */
+  class underflow_error : public runtime_error 
+  {
+  public:
+    explicit underflow_error(const string& __arg);
+    virtual ~underflow_error() _GLIBCXX_USE_NOEXCEPT;
+  };
+
+  // @} group exceptions
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GLIBCXX_STDEXCEPT */
diff --git a/gcc-4.9/libstdc++-v3/include/std/streambuf b/gcc-4.9/libstdc++-v3/include/std/streambuf
new file mode 100644
index 0000000..865f26b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/streambuf
@@ -0,0 +1,830 @@
+// Stream buffer classes -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/streambuf
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.5  Stream buffers
+//
+
+#ifndef _GLIBXX_STREAMBUF
+#define _GLIBXX_STREAMBUF 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <iosfwd>
+#include <bits/localefwd.h>
+#include <bits/ios_base.h>
+#include <bits/cpp_type_traits.h>
+#include <ext/type_traits.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+			  basic_streambuf<_CharT, _Traits>*, bool&);
+
+  /**
+   *  @brief  The actual work of input and output (interface).
+   *  @ingroup io
+   *
+   *  @tparam _CharT  Type of character stream.
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  This is a base class.  Derived stream buffers each control a
+   *  pair of character sequences:  one for input, and one for output.
+   *
+   *  Section [27.5.1] of the standard describes the requirements and
+   *  behavior of stream buffer classes.  That section (three paragraphs)
+   *  is reproduced here, for simplicity and accuracy.
+   *
+   *  -# Stream buffers can impose various constraints on the sequences
+   *     they control.  Some constraints are:
+   *     - The controlled input sequence can be not readable.
+   *     - The controlled output sequence can be not writable.
+   *     - The controlled sequences can be associated with the contents of
+   *       other representations for character sequences, such as external
+   *       files.
+   *     - The controlled sequences can support operations @e directly to or
+   *       from associated sequences.
+   *     - The controlled sequences can impose limitations on how the
+   *       program can read characters from a sequence, write characters to
+   *       a sequence, put characters back into an input sequence, or alter
+   *       the stream position.
+   *     .
+   *  -# Each sequence is characterized by three pointers which, if non-null,
+   *     all point into the same @c charT array object.  The array object
+   *     represents, at any moment, a (sub)sequence of characters from the
+   *     sequence.  Operations performed on a sequence alter the values
+   *     stored in these pointers, perform reads and writes directly to or
+   *     from associated sequences, and alter <em>the stream position</em> and
+   *     conversion state as needed to maintain this subsequence relationship.
+   *     The three pointers are:
+   *     - the <em>beginning pointer</em>, or lowest element address in the
+   *       array (called @e xbeg here);
+   *     - the <em>next pointer</em>, or next element address that is a
+   *       current candidate for reading or writing (called @e xnext here);
+   *     - the <em>end pointer</em>, or first element address beyond the
+   *       end of the array (called @e xend here).
+   *     .
+   *  -# The following semantic constraints shall always apply for any set
+   *     of three pointers for a sequence, using the pointer names given
+   *     immediately above:
+   *     - If @e xnext is not a null pointer, then @e xbeg and @e xend shall
+   *       also be non-null pointers into the same @c charT array, as
+   *       described above; otherwise, @e xbeg and @e xend shall also be null.
+   *     - If @e xnext is not a null pointer and @e xnext < @e xend for an
+   *       output sequence, then a <em>write position</em> is available.
+   *       In this case, @e *xnext shall be assignable as the next element
+   *       to write (to put, or to store a character value, into the sequence).
+   *     - If @e xnext is not a null pointer and @e xbeg < @e xnext for an
+   *       input sequence, then a <em>putback position</em> is available.
+   *       In this case, @e xnext[-1] shall have a defined value and is the
+   *       next (preceding) element to store a character that is put back
+   *       into the input sequence.
+   *     - If @e xnext is not a null pointer and @e xnext< @e xend for an
+   *       input sequence, then a <em>read position</em> is available.
+   *       In this case, @e *xnext shall have a defined value and is the
+   *       next element to read (to get, or to obtain a character value,
+   *       from the sequence).
+  */
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf 
+    {
+    public:
+      //@{
+      /**
+       *  These are standard types.  They permit a standardized way of
+       *  referring to names of (or names dependent on) the template
+       *  parameters, which are specific to the implementation.
+      */
+      typedef _CharT 					char_type;
+      typedef _Traits 					traits_type;
+      typedef typename traits_type::int_type 		int_type;
+      typedef typename traits_type::pos_type 		pos_type;
+      typedef typename traits_type::off_type 		off_type;
+      //@}
+
+      //@{
+      /// This is a non-standard type.
+      typedef basic_streambuf<char_type, traits_type>  	__streambuf_type;
+      //@}
+      
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+
+      friend streamsize
+      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
+
+      template<bool _IsMove, typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, 
+					       _CharT2*>::__type
+        __copy_move_a2(istreambuf_iterator<_CharT2>,
+		       istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+				  istreambuf_iterator<_CharT2> >::__type
+        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+	     const _CharT2&);
+
+      template<typename _CharT2, typename _Traits2>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&,
+		   basic_string<_CharT2, _Traits2, _Alloc>&);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        getline(basic_istream<_CharT2, _Traits2>&,
+		basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
+
+    protected:
+      /*
+       *  This is based on _IO_FILE, just reordered to be more consistent,
+       *  and is intended to be the most minimal abstraction for an
+       *  internal buffer.
+       *  -  get == input == read
+       *  -  put == output == write
+      */
+      char_type* 		_M_in_beg;     ///< Start of get area.
+      char_type* 		_M_in_cur;     ///< Current read area.
+      char_type* 		_M_in_end;     ///< End of get area.
+      char_type* 		_M_out_beg;    ///< Start of put area.
+      char_type* 		_M_out_cur;    ///< Current put area.
+      char_type* 		_M_out_end;    ///< End of put area.
+
+      /// Current locale setting.
+      locale 			_M_buf_locale;	
+
+  public:
+      /// Destructor deallocates no buffer space.
+      virtual 
+      ~basic_streambuf() 
+      { }
+
+      // [27.5.2.2.1] locales
+      /**
+       *  @brief  Entry point for imbue().
+       *  @param  __loc  The new locale.
+       *  @return  The previous locale.
+       *
+       *  Calls the derived imbue(__loc).
+      */
+      locale 
+      pubimbue(const locale& __loc)
+      {
+	locale __tmp(this->getloc());
+	this->imbue(__loc);
+	_M_buf_locale = __loc;
+	return __tmp;
+      }
+
+      /**
+       *  @brief  Locale access.
+       *  @return  The current locale in effect.
+       *
+       *  If pubimbue(loc) has been called, then the most recent @c loc
+       *  is returned.  Otherwise the global locale in effect at the time
+       *  of construction is returned.
+      */
+      locale   
+      getloc() const
+      { return _M_buf_locale; } 
+
+      // [27.5.2.2.2] buffer management and positioning
+      //@{
+      /**
+       *  @brief  Entry points for derived buffer functions.
+       *
+       *  The public versions of @c pubfoo dispatch to the protected
+       *  derived @c foo member functions, passing the arguments (if any)
+       *  and returning the result unchanged.
+      */
+      basic_streambuf*
+      pubsetbuf(char_type* __s, streamsize __n) 
+      { return this->setbuf(__s, __n); }
+
+      /**
+       *  @brief  Alters the stream position.
+       *  @param  __off  Offset.
+       *  @param  __way  Value for ios_base::seekdir.
+       *  @param  __mode Value for ios_base::openmode.
+       *
+       *  Calls virtual seekoff function.
+      */
+      pos_type 
+      pubseekoff(off_type __off, ios_base::seekdir __way, 
+		 ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+
+      /**
+       *  @brief  Alters the stream position.
+       *  @param  __sp  Position
+       *  @param  __mode Value for ios_base::openmode.
+       *
+       *  Calls virtual seekpos function.
+      */
+      pos_type 
+      pubseekpos(pos_type __sp,
+		 ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+
+      /**
+       *  @brief  Calls virtual sync function.
+      */
+      int 
+      pubsync() { return this->sync(); }
+      //@}
+
+      // [27.5.2.2.3] get area
+      /**
+       *  @brief  Looking ahead into the stream.
+       *  @return  The number of characters available.
+       *
+       *  If a read position is available, returns the number of characters
+       *  available for reading before the buffer must be refilled.
+       *  Otherwise returns the derived @c showmanyc().
+      */
+      streamsize 
+      in_avail() 
+      { 
+	const streamsize __ret = this->egptr() - this->gptr();
+	return __ret ? __ret : this->showmanyc();
+      }
+
+      /**
+       *  @brief  Getting the next character.
+       *  @return  The next character, or eof.
+       *
+       *  Calls @c sbumpc(), and if that function returns
+       *  @c traits::eof(), so does this function.  Otherwise, @c sgetc().
+      */
+      int_type 
+      snextc()
+      {
+	int_type __ret = traits_type::eof();
+	if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), 
+						       __ret), true))
+	  __ret = this->sgetc();
+	return __ret;
+      }
+
+      /**
+       *  @brief  Getting the next character.
+       *  @return  The next character, or eof.
+       *
+       *  If the input read position is available, returns that character
+       *  and increments the read pointer, otherwise calls and returns
+       *  @c uflow().
+      */
+      int_type 
+      sbumpc()
+      {
+	int_type __ret;
+	if (__builtin_expect(this->gptr() < this->egptr(), true))
+	  {
+	    __ret = traits_type::to_int_type(*this->gptr());
+	    this->gbump(1);
+	  }
+	else 
+	  __ret = this->uflow();
+	return __ret;
+      }
+
+      /**
+       *  @brief  Getting the next character.
+       *  @return  The next character, or eof.
+       *
+       *  If the input read position is available, returns that character,
+       *  otherwise calls and returns @c underflow().  Does not move the 
+       *  read position after fetching the character.
+      */
+      int_type 
+      sgetc()
+      {
+	int_type __ret;
+	if (__builtin_expect(this->gptr() < this->egptr(), true))
+	  __ret = traits_type::to_int_type(*this->gptr());
+	else 
+	  __ret = this->underflow();
+	return __ret;
+      }
+
+      /**
+       *  @brief  Entry point for xsgetn.
+       *  @param  __s  A buffer area.
+       *  @param  __n  A count.
+       *
+       *  Returns xsgetn(__s,__n).  The effect is to fill @a __s[0] through
+       *  @a __s[__n-1] with characters from the input sequence, if possible.
+      */
+      streamsize 
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+
+      // [27.5.2.2.4] putback
+      /**
+       *  @brief  Pushing characters back into the input stream.
+       *  @param  __c  The character to push back.
+       *  @return  The previous character, if possible.
+       *
+       *  Similar to sungetc(), but @a __c is pushed onto the stream
+       *  instead of <em>the previous character.</em> If successful,
+       *  the next character fetched from the input stream will be @a
+       *  __c.
+      */
+      int_type 
+      sputbackc(char_type __c)
+      {
+	int_type __ret;
+	const bool __testpos = this->eback() < this->gptr();
+	if (__builtin_expect(!__testpos || 
+			     !traits_type::eq(__c, this->gptr()[-1]), false))
+	  __ret = this->pbackfail(traits_type::to_int_type(__c));
+	else 
+	  {
+	    this->gbump(-1);
+	    __ret = traits_type::to_int_type(*this->gptr());
+	  }
+	return __ret;
+      }
+
+      /**
+       *  @brief  Moving backwards in the input stream.
+       *  @return  The previous character, if possible.
+       *
+       *  If a putback position is available, this function decrements
+       *  the input pointer and returns that character.  Otherwise,
+       *  calls and returns pbackfail().  The effect is to @a unget
+       *  the last character @a gotten.
+      */
+      int_type 
+      sungetc()
+      {
+	int_type __ret;
+	if (__builtin_expect(this->eback() < this->gptr(), true))
+	  {
+	    this->gbump(-1);
+	    __ret = traits_type::to_int_type(*this->gptr());
+	  }
+	else 
+	  __ret = this->pbackfail();
+	return __ret;
+      }
+
+      // [27.5.2.2.5] put area
+      /**
+       *  @brief  Entry point for all single-character output functions.
+       *  @param  __c  A character to output.
+       *  @return  @a __c, if possible.
+       *
+       *  One of two public output functions.
+       *
+       *  If a write position is available for the output sequence (i.e.,
+       *  the buffer is not full), stores @a __c in that position, increments
+       *  the position, and returns @c traits::to_int_type(__c).  If a write
+       *  position is not available, returns @c overflow(__c).
+      */
+      int_type 
+      sputc(char_type __c)
+      {
+	int_type __ret;
+	if (__builtin_expect(this->pptr() < this->epptr(), true))
+	  {
+	    *this->pptr() = __c;
+	    this->pbump(1);
+	    __ret = traits_type::to_int_type(__c);
+	  }
+	else
+	  __ret = this->overflow(traits_type::to_int_type(__c));
+	return __ret;
+      }
+
+      /**
+       *  @brief  Entry point for all single-character output functions.
+       *  @param  __s  A buffer read area.
+       *  @param  __n  A count.
+       *
+       *  One of two public output functions.
+       *
+       *
+       *  Returns xsputn(__s,__n).  The effect is to write @a __s[0] through
+       *  @a __s[__n-1] to the output sequence, if possible.
+      */
+      streamsize 
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+
+    protected:
+      /**
+       *  @brief  Base constructor.
+       *
+       *  Only called from derived constructors, and sets up all the
+       *  buffer data to zero, including the pointers described in the
+       *  basic_streambuf class description.  Note that, as a result,
+       *  - the class starts with no read nor write positions available,
+       *  - this is not an error
+      */
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), 
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale()) 
+      { }
+
+      // [27.5.2.3.1] get area access
+      //@{
+      /**
+       *  @brief  Access to the get area.
+       *
+       *  These functions are only available to other protected functions,
+       *  including derived classes.
+       *
+       *  - eback() returns the beginning pointer for the input sequence
+       *  - gptr() returns the next pointer for the input sequence
+       *  - egptr() returns the end pointer for the input sequence
+      */
+      char_type* 
+      eback() const { return _M_in_beg; }
+
+      char_type* 
+      gptr()  const { return _M_in_cur;  }
+
+      char_type* 
+      egptr() const { return _M_in_end; }
+      //@}
+
+      /**
+       *  @brief  Moving the read position.
+       *  @param  __n  The delta by which to move.
+       *
+       *  This just advances the read position without returning any data.
+      */
+      void 
+      gbump(int __n) { _M_in_cur += __n; }
+
+      /**
+       *  @brief  Setting the three read area pointers.
+       *  @param  __gbeg  A pointer.
+       *  @param  __gnext  A pointer.
+       *  @param  __gend  A pointer.
+       *  @post  @a __gbeg == @c eback(), @a __gnext == @c gptr(), and
+       *         @a __gend == @c egptr()
+      */
+      void 
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+	_M_in_beg = __gbeg;
+	_M_in_cur = __gnext;
+	_M_in_end = __gend;
+      }
+
+      // [27.5.2.3.2] put area access
+      //@{
+      /**
+       *  @brief  Access to the put area.
+       *
+       *  These functions are only available to other protected functions,
+       *  including derived classes.
+       *
+       *  - pbase() returns the beginning pointer for the output sequence
+       *  - pptr() returns the next pointer for the output sequence
+       *  - epptr() returns the end pointer for the output sequence
+      */
+      char_type* 
+      pbase() const { return _M_out_beg; }
+
+      char_type* 
+      pptr() const { return _M_out_cur; }
+
+      char_type* 
+      epptr() const { return _M_out_end; }
+      //@}
+
+      /**
+       *  @brief  Moving the write position.
+       *  @param  __n  The delta by which to move.
+       *
+       *  This just advances the write position without returning any data.
+      */
+      void 
+      pbump(int __n) { _M_out_cur += __n; }
+
+      /**
+       *  @brief  Setting the three write area pointers.
+       *  @param  __pbeg  A pointer.
+       *  @param  __pend  A pointer.
+       *  @post  @a __pbeg == @c pbase(), @a __pbeg == @c pptr(), and
+       *         @a __pend == @c epptr()
+      */
+      void 
+      setp(char_type* __pbeg, char_type* __pend)
+      { 
+	_M_out_beg = _M_out_cur = __pbeg; 
+	_M_out_end = __pend;
+      }
+
+      // [27.5.2.4] virtual functions
+      // [27.5.2.4.1] locales
+      /**
+       *  @brief  Changes translations.
+       *  @param  __loc  A new locale.
+       *
+       *  Translations done during I/O which depend on the current
+       *  locale are changed by this call.  The standard adds,
+       *  <em>Between invocations of this function a class derived
+       *  from streambuf can safely cache results of calls to locale
+       *  functions and to members of facets so obtained.</em>
+       *
+       *  @note  Base class version does nothing.
+      */
+      virtual void 
+      imbue(const locale& __loc) 
+      { }
+
+      // [27.5.2.4.2] buffer management and positioning
+      /**
+       *  @brief  Manipulates the buffer.
+       *
+       *  Each derived class provides its own appropriate behavior.  See
+       *  the next-to-last paragraph of 
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
+       *  for more on this function.
+       *
+       *  @note  Base class version does nothing, returns @c this.
+      */
+      virtual basic_streambuf<char_type,_Traits>* 
+      setbuf(char_type*, streamsize)
+      {	return this; }
+      
+      /**
+       *  @brief  Alters the stream positions.
+       *
+       *  Each derived class provides its own appropriate behavior.
+       *  @note  Base class version does nothing, returns a @c pos_type
+       *         that represents an invalid stream position.
+      */
+      virtual pos_type 
+      seekoff(off_type, ios_base::seekdir,
+	      ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); } 
+
+      /**
+       *  @brief  Alters the stream positions.
+       *
+       *  Each derived class provides its own appropriate behavior.
+       *  @note  Base class version does nothing, returns a @c pos_type
+       *         that represents an invalid stream position.
+      */
+      virtual pos_type 
+      seekpos(pos_type, 
+	      ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); } 
+
+      /**
+       *  @brief  Synchronizes the buffer arrays with the controlled sequences.
+       *  @return  -1 on failure.
+       *
+       *  Each derived class provides its own appropriate behavior,
+       *  including the definition of @a failure.
+       *  @note  Base class version does nothing, returns zero.
+      */
+      virtual int 
+      sync() { return 0; }
+
+      // [27.5.2.4.3] get area
+      /**
+       *  @brief  Investigating the data available.
+       *  @return  An estimate of the number of characters available in the
+       *           input sequence, or -1.
+       *
+       *  <em>If it returns a positive value, then successive calls to
+       *  @c underflow() will not return @c traits::eof() until at
+       *  least that number of characters have been supplied.  If @c
+       *  showmanyc() returns -1, then calls to @c underflow() or @c
+       *  uflow() will fail.</em> [27.5.2.4.3]/1
+       *
+       *  @note  Base class version does nothing, returns zero.
+       *  @note  The standard adds that <em>the intention is not only that the
+       *         calls [to underflow or uflow] will not return @c eof() but
+       *         that they will return immediately.</em>
+       *  @note  The standard adds that <em>the morphemes of @c showmanyc are
+       *         @b es-how-many-see, not @b show-manic.</em>
+      */
+      virtual streamsize 
+      showmanyc() { return 0; }
+
+      /**
+       *  @brief  Multiple character extraction.
+       *  @param  __s  A buffer area.
+       *  @param  __n  Maximum number of characters to assign.
+       *  @return  The number of characters assigned.
+       *
+       *  Fills @a __s[0] through @a __s[__n-1] with characters from the input
+       *  sequence, as if by @c sbumpc().  Stops when either @a __n characters
+       *  have been copied, or when @c traits::eof() would be copied.
+       *
+       *  It is expected that derived classes provide a more efficient
+       *  implementation by overriding this definition.
+      */
+      virtual streamsize 
+      xsgetn(char_type* __s, streamsize __n);
+
+      /**
+       *  @brief  Fetches more data from the controlled sequence.
+       *  @return  The first character from the <em>pending sequence</em>.
+       *
+       *  Informally, this function is called when the input buffer is
+       *  exhausted (or does not exist, as buffering need not actually be
+       *  done).  If a buffer exists, it is @a refilled.  In either case, the
+       *  next available character is returned, or @c traits::eof() to
+       *  indicate a null pending sequence.
+       *
+       *  For a formal definition of the pending sequence, see a good text
+       *  such as Langer & Kreft, or [27.5.2.4.3]/7-14.
+       *
+       *  A functioning input streambuf can be created by overriding only
+       *  this function (no buffer area will be used).  For an example, see
+       *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25.html
+       *
+       *  @note  Base class version does nothing, returns eof().
+      */
+      virtual int_type 
+      underflow()
+      { return traits_type::eof(); }
+
+      /**
+       *  @brief  Fetches more data from the controlled sequence.
+       *  @return  The first character from the <em>pending sequence</em>.
+       *
+       *  Informally, this function does the same thing as @c underflow(),
+       *  and in fact is required to call that function.  It also returns
+       *  the new character, like @c underflow() does.  However, this
+       *  function also moves the read position forward by one.
+      */
+      virtual int_type 
+      uflow() 
+      {
+	int_type __ret = traits_type::eof();
+	const bool __testeof = traits_type::eq_int_type(this->underflow(), 
+							__ret);
+	if (!__testeof)
+	  {
+	    __ret = traits_type::to_int_type(*this->gptr());
+	    this->gbump(1);
+	  }
+	return __ret;    
+      }
+
+      // [27.5.2.4.4] putback
+      /**
+       *  @brief  Tries to back up the input sequence.
+       *  @param  __c  The character to be inserted back into the sequence.
+       *  @return  eof() on failure, <em>some other value</em> on success
+       *  @post  The constraints of @c gptr(), @c eback(), and @c pptr()
+       *         are the same as for @c underflow().
+       *
+       *  @note  Base class version does nothing, returns eof().
+      */
+      virtual int_type 
+      pbackfail(int_type __c  = traits_type::eof())
+      { return traits_type::eof(); }
+
+      // Put area:
+      /**
+       *  @brief  Multiple character insertion.
+       *  @param  __s  A buffer area.
+       *  @param  __n  Maximum number of characters to write.
+       *  @return  The number of characters written.
+       *
+       *  Writes @a __s[0] through @a __s[__n-1] to the output sequence, as if
+       *  by @c sputc().  Stops when either @a n characters have been
+       *  copied, or when @c sputc() would return @c traits::eof().
+       *
+       *  It is expected that derived classes provide a more efficient
+       *  implementation by overriding this definition.
+      */
+      virtual streamsize 
+      xsputn(const char_type* __s, streamsize __n);
+
+      /**
+       *  @brief  Consumes data from the buffer; writes to the
+       *          controlled sequence.
+       *  @param  __c  An additional character to consume.
+       *  @return  eof() to indicate failure, something else (usually
+       *           @a __c, or not_eof())
+       *
+       *  Informally, this function is called when the output buffer
+       *  is full (or does not exist, as buffering need not actually
+       *  be done).  If a buffer exists, it is @a consumed, with
+       *  <em>some effect</em> on the controlled sequence.
+       *  (Typically, the buffer is written out to the sequence
+       *  verbatim.)  In either case, the character @a c is also
+       *  written out, if @a __c is not @c eof().
+       *
+       *  For a formal definition of this function, see a good text
+       *  such as Langer & Kreft, or [27.5.2.4.5]/3-7.
+       *
+       *  A functioning output streambuf can be created by overriding only
+       *  this function (no buffer area will be used).
+       *
+       *  @note  Base class version does nothing, returns eof().
+      */
+      virtual int_type 
+      overflow(int_type __c  = traits_type::eof())
+      { return traits_type::eof(); }
+
+#if _GLIBCXX_USE_DEPRECATED
+    // Annex D.6
+    public:
+      /**
+       *  @brief  Tosses a character.
+       *
+       *  Advances the read pointer, ignoring the character that would have
+       *  been read.
+       *
+       *  See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html
+       */
+      void 
+      stossc() 
+      {
+	if (this->gptr() < this->egptr()) 
+	  this->gbump(1);
+	else 
+	  this->uflow();
+      }
+#endif
+
+      // Also used by specializations for char and wchar_t in src.
+      void 
+      __safe_gbump(streamsize __n) { _M_in_cur += __n; }
+
+      void
+      __safe_pbump(streamsize __n) { _M_out_cur += __n; }
+
+    private:
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // Side effect of DR 50. 
+      basic_streambuf(const basic_streambuf& __sb)
+      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur), 
+      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg), 
+      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
+      _M_buf_locale(__sb._M_buf_locale) 
+      { }
+
+      basic_streambuf&
+      operator=(const basic_streambuf&) { return *this; };
+    };
+
+  // Explicit specialization declarations, defined in src/streambuf.cc.
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
+			  basic_streambuf<char>* __sbout, bool& __ineof);
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
+			  basic_streambuf<wchar_t>* __sbout, bool& __ineof);
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/streambuf.tcc>
+
+#endif /* _GLIBCXX_STREAMBUF */
diff --git a/gcc-4.9/libstdc++-v3/include/std/string b/gcc-4.9/libstdc++-v3/include/std/string
new file mode 100644
index 0000000..08d2e26
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/string
@@ -0,0 +1,55 @@
+// Components for manipulating sequences of characters -*- C++ -*-
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/string
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 21  Strings library
+//
+
+#ifndef _GLIBCXX_STRING
+#define _GLIBCXX_STRING	1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stringfwd.h>
+#include <bits/char_traits.h>  // NB: In turn includes stl_algobase.h
+#include <bits/allocator.h>
+#include <bits/cpp_type_traits.h>
+#include <bits/localefwd.h>    // For operators >>, <<, and getline.
+#include <bits/ostream_insert.h>
+#include <bits/stl_iterator_base_types.h>
+#include <bits/stl_iterator_base_funcs.h>
+#include <bits/stl_iterator.h>
+#include <bits/stl_function.h> // For less
+#include <ext/numeric_traits.h> 
+#include <bits/stl_algobase.h> 
+#include <bits/range_access.h>
+#include <bits/basic_string.h>
+#include <bits/basic_string.tcc> 
+
+#endif /* _GLIBCXX_STRING */
diff --git a/gcc-4.9/libstdc++-v3/include/std/system_error b/gcc-4.9/libstdc++-v3/include/std/system_error
new file mode 100644
index 0000000..4ec83d7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/system_error
@@ -0,0 +1,381 @@
+// <system_error> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/system_error
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_SYSTEM_ERROR
+#define _GLIBCXX_SYSTEM_ERROR 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <bits/c++config.h>
+#include <bits/error_constants.h>
+#include <iosfwd>
+#include <stdexcept>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  class error_code;
+  class error_condition;
+  class error_category;
+  class system_error;
+
+  /// is_error_code_enum
+  template<typename _Tp>
+    struct is_error_code_enum : public false_type { };
+
+  /// is_error_condition_enum
+  template<typename _Tp>
+    struct is_error_condition_enum : public false_type { };
+
+  template<> 
+    struct is_error_condition_enum<errc>
+    : public true_type { };
+
+
+  /// error_category
+  class error_category
+  {
+  public:
+#ifdef _GLIBCXX_COMPATIBILITY_CXX0X
+    error_category() noexcept;
+#else
+    constexpr error_category() noexcept = default;
+#endif
+
+    virtual ~error_category();
+
+    error_category(const error_category&) = delete;
+    error_category& operator=(const error_category&) = delete;
+
+    virtual const char* 
+    name() const noexcept = 0;
+
+    virtual string 
+    message(int) const = 0;
+
+    virtual error_condition
+    default_error_condition(int __i) const noexcept;
+
+    virtual bool 
+    equivalent(int __i, const error_condition& __cond) const noexcept;
+
+    virtual bool 
+    equivalent(const error_code& __code, int __i) const noexcept;
+
+    bool 
+    operator<(const error_category& __other) const noexcept
+    { return less<const error_category*>()(this, &__other); }
+
+    bool 
+    operator==(const error_category& __other) const noexcept
+    { return this == &__other; }
+
+    bool 
+    operator!=(const error_category& __other) const noexcept
+    { return this != &__other; }
+  };
+
+  // DR 890.
+  _GLIBCXX_CONST const error_category& system_category() noexcept;
+  _GLIBCXX_CONST const error_category& generic_category() noexcept;
+
+  error_code make_error_code(errc) noexcept;
+
+  template<typename _Tp>
+    struct hash;
+
+  /// error_code
+  // Implementation-specific error identification
+  struct error_code
+  {
+    error_code() noexcept
+    : _M_value(0), _M_cat(&system_category()) { }
+
+    error_code(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorCodeEnum, typename = typename
+	     enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
+      error_code(_ErrorCodeEnum __e) noexcept
+      { *this = make_error_code(__e); }
+
+    void 
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat; 
+    }
+
+    void 
+    clear() noexcept
+    { assign(0, system_category()); }
+
+    // DR 804.
+    template<typename _ErrorCodeEnum>
+      typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
+			 error_code&>::type
+      operator=(_ErrorCodeEnum __e) noexcept
+      { return *this = make_error_code(__e); }
+
+    int
+    value() const noexcept { return _M_value; }
+      
+    const error_category&  
+    category() const noexcept { return *_M_cat; }
+
+    error_condition 
+    default_error_condition() const noexcept;
+
+    string 
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0 ? true : false; }
+
+    // DR 804.
+  private:
+    friend class hash<error_code>;
+
+    int            		_M_value;
+    const error_category* 	_M_cat;
+  };
+
+  // 19.4.2.6 non-member functions
+  inline error_code
+  make_error_code(errc __e) noexcept
+  { return error_code(static_cast<int>(__e), generic_category()); }
+
+  inline bool
+  operator<(const error_code& __lhs, const error_code& __rhs) noexcept
+  { 
+    return (__lhs.category() < __rhs.category()
+	    || (__lhs.category() == __rhs.category()
+		&& __lhs.value() < __rhs.value()));
+  }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
+    { return (__os << __e.category().name() << ':' << __e.value()); }
+
+  error_condition make_error_condition(errc) noexcept;
+
+  /// error_condition
+  // Portable error identification
+  struct error_condition 
+  {
+    error_condition() noexcept
+    : _M_value(0), _M_cat(&generic_category()) { }
+
+    error_condition(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorConditionEnum, typename = typename
+	 enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
+      error_condition(_ErrorConditionEnum __e) noexcept
+      { *this = make_error_condition(__e); }
+
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+
+    // DR 804.
+    template<typename _ErrorConditionEnum>
+      typename enable_if<is_error_condition_enum
+			 <_ErrorConditionEnum>::value, error_condition&>::type
+      operator=(_ErrorConditionEnum __e) noexcept
+      { return *this = make_error_condition(__e); }
+
+    void 
+    clear() noexcept
+    { assign(0, generic_category()); }
+
+    // 19.4.3.4 observers
+    int
+    value() const noexcept { return _M_value; }
+
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+
+    string 
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0 ? true : false; }
+
+    // DR 804.
+  private:
+    int 			_M_value;
+    const error_category* 	_M_cat;
+  };
+
+  // 19.4.3.6 non-member functions
+  inline error_condition
+  make_error_condition(errc __e) noexcept
+  { return error_condition(static_cast<int>(__e), generic_category()); }
+
+  inline bool 
+  operator<(const error_condition& __lhs,
+	    const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+	    || (__lhs.category() == __rhs.category()
+		&& __lhs.value() < __rhs.value()));
+  }
+
+  // 19.4.4 Comparison operators
+  inline bool
+  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return (__lhs.category() == __rhs.category()
+	    && __lhs.value() == __rhs.value()); }
+
+  inline bool
+  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category().equivalent(__lhs.value(), __rhs)
+	    || __rhs.category().equivalent(__lhs, __rhs.value()));
+  }
+
+  inline bool
+  operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__rhs.category().equivalent(__rhs.value(), __lhs)
+	    || __lhs.category().equivalent(__rhs, __lhs.value()));
+  }
+
+  inline bool
+  operator==(const error_condition& __lhs,
+	     const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() == __rhs.category()
+	    && __lhs.value() == __rhs.value());
+  }
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_condition& __lhs,
+	     const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+
+  /** 
+   *  @brief Thrown to indicate error code of underlying system.
+   *
+   *  @ingroup exceptions
+   */
+  class system_error : public std::runtime_error
+  {
+  private:
+    error_code 	_M_code;
+
+  public:
+    system_error(error_code __ec = error_code())
+    : runtime_error(__ec.message()), _M_code(__ec) { }
+
+    system_error(error_code __ec, const string& __what)
+    : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
+
+    /*
+     * TODO: Add const char* ctors to all exceptions.
+     *
+     * system_error(error_code __ec, const char* __what)
+     * : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
+     *
+     * system_error(int __v, const error_category& __ecat, const char* __what)
+     * : runtime_error(__what + (": " + __ec.message())),
+     *   _M_code(error_code(__v, __ecat)) { }
+     */
+
+    system_error(int __v, const error_category& __ecat)
+    : runtime_error(error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+    system_error(int __v, const error_category& __ecat, const string& __what)
+    : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+    virtual ~system_error() noexcept;
+
+    const error_code& 
+    code() const noexcept { return _M_code; }
+  };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#ifndef _GLIBCXX_COMPATIBILITY_CXX0X
+
+#include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // DR 1182.
+  /// std::hash specialization for error_code.
+  template<>
+    struct hash<error_code>
+    : public __hash_base<size_t, error_code>
+    {
+      size_t
+      operator()(const error_code& __e) const noexcept
+      {
+	const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
+	return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
+      }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _GLIBCXX_COMPATIBILITY_CXX0X
+
+#endif // C++11
+
+#endif // _GLIBCXX_SYSTEM_ERROR
diff --git a/gcc-4.9/libstdc++-v3/include/std/thread b/gcc-4.9/libstdc++-v3/include/std/thread
new file mode 100644
index 0000000..efcb101
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/thread
@@ -0,0 +1,302 @@
+// <thread> -*- C++ -*-
+
+// Copyright (C) 2008-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/thread
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_THREAD
+#define _GLIBCXX_THREAD 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <bits/functexcept.h>
+#include <bits/functional_hash.h>
+#include <bits/gthr.h>
+
+#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup threads Threads
+   * @ingroup concurrency
+   *
+   * Classes for thread support.
+   * @{
+   */
+
+  /// thread
+  class thread
+  {
+  public:
+    typedef __gthread_t			native_handle_type;
+    struct _Impl_base;
+    typedef shared_ptr<_Impl_base>	__shared_base_type;
+
+    /// thread::id
+    class id
+    {
+      native_handle_type	_M_thread;
+
+    public:
+      id() noexcept : _M_thread() { }
+
+      explicit
+      id(native_handle_type __id) : _M_thread(__id) { }
+
+    private:
+      friend class thread;
+      friend class hash<thread::id>;
+
+      friend bool
+      operator==(thread::id __x, thread::id __y) noexcept
+      { return __gthread_equal(__x._M_thread, __y._M_thread); }
+
+      friend bool
+      operator<(thread::id __x, thread::id __y) noexcept
+      { return __x._M_thread < __y._M_thread; }
+
+      template<class _CharT, class _Traits>
+	friend basic_ostream<_CharT, _Traits>&
+	operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
+    };
+
+    // Simple base type that the templatized, derived class containing
+    // an arbitrary functor can be converted to and called.
+    struct _Impl_base
+    {
+      __shared_base_type	_M_this_ptr;
+
+      inline virtual ~_Impl_base();
+
+      virtual void _M_run() = 0;
+    };
+
+    template<typename _Callable>
+      struct _Impl : public _Impl_base
+      {
+	_Callable		_M_func;
+
+	_Impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
+	{ }
+
+	void
+	_M_run() { _M_func(); }
+      };
+
+  private:
+    id				_M_id;
+
+  public:
+    thread() noexcept = default;
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 2097.  packaged_task constructors should be constrained
+    thread(thread&) = delete;
+    thread(const thread&) = delete;
+
+    thread(thread&& __t) noexcept
+    { swap(__t); }
+
+    template<typename _Callable, typename... _Args>
+      explicit 
+      thread(_Callable&& __f, _Args&&... __args)
+      {
+        _M_start_thread(_M_make_routine(std::__bind_simple(
+                std::forward<_Callable>(__f),
+                std::forward<_Args>(__args)...)));
+      }
+
+    ~thread()
+    {
+      if (joinable())
+	std::terminate();
+    }
+
+    thread& operator=(const thread&) = delete;
+
+    thread& operator=(thread&& __t) noexcept
+    {
+      if (joinable())
+	std::terminate();
+      swap(__t);
+      return *this;
+    }
+
+    void
+    swap(thread& __t) noexcept
+    { std::swap(_M_id, __t._M_id); }
+
+    bool
+    joinable() const noexcept
+    { return !(_M_id == id()); }
+
+    void
+    join();
+
+    void
+    detach();
+
+    thread::id
+    get_id() const noexcept
+    { return _M_id; }
+
+    /** @pre thread is joinable
+     */
+    native_handle_type
+    native_handle()
+    { return _M_id._M_thread; }
+
+    // Returns a value that hints at the number of hardware thread contexts.
+    static unsigned int
+    hardware_concurrency() noexcept;
+
+  private:
+    void
+    _M_start_thread(__shared_base_type);
+
+    template<typename _Callable>
+      shared_ptr<_Impl<_Callable>>
+      _M_make_routine(_Callable&& __f)
+      {
+	// Create and allocate full data structure, not base.
+	return std::make_shared<_Impl<_Callable>>(std::forward<_Callable>(__f));
+      }
+  };
+
+  inline thread::_Impl_base::~_Impl_base() = default;
+
+  inline void
+  swap(thread& __x, thread& __y) noexcept
+  { __x.swap(__y); }
+
+  inline bool
+  operator!=(thread::id __x, thread::id __y) noexcept
+  { return !(__x == __y); }
+
+  inline bool
+  operator<=(thread::id __x, thread::id __y) noexcept
+  { return !(__y < __x); }
+
+  inline bool
+  operator>(thread::id __x, thread::id __y) noexcept
+  { return __y < __x; }
+
+  inline bool
+  operator>=(thread::id __x, thread::id __y) noexcept
+  { return !(__x < __y); }
+
+  // DR 889.
+  /// std::hash specialization for thread::id.
+  template<>
+    struct hash<thread::id>
+    : public __hash_base<size_t, thread::id>
+    {
+      size_t
+      operator()(const thread::id& __id) const noexcept
+      { return std::_Hash_impl::hash(__id._M_thread); }
+    };
+
+  template<class _CharT, class _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
+    {
+      if (__id == thread::id())
+	return __out << "thread::id of a non-executing thread";
+      else
+	return __out << __id._M_thread;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+  /** @namespace std::this_thread
+   *  @brief ISO C++ 2011 entities sub-namespace for thread.
+   *  30.3.2 Namespace this_thread.
+   */
+  namespace this_thread
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /// get_id
+    inline thread::id
+    get_id() noexcept { return thread::id(__gthread_self()); }
+
+    /// yield
+    inline void
+    yield() noexcept
+    {
+#ifdef _GLIBCXX_USE_SCHED_YIELD
+      __gthread_yield();
+#endif
+    }
+
+    void
+    __sleep_for(chrono::seconds, chrono::nanoseconds);
+
+    /// sleep_for
+    template<typename _Rep, typename _Period>
+      inline void
+      sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
+      {
+	auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
+	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);
+#ifdef _GLIBCXX_USE_NANOSLEEP
+	__gthread_time_t __ts =
+	  {
+	    static_cast<std::time_t>(__s.count()),
+	    static_cast<long>(__ns.count())
+	  };
+	::nanosleep(&__ts, 0);
+#else
+	__sleep_for(__s, __ns);
+#endif
+      }
+
+    /// sleep_until
+    template<typename _Clock, typename _Duration>
+      inline void
+      sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
+      { sleep_for(__atime - _Clock::now()); }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  }
+
+  // @} group threads
+
+} // namespace
+
+#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // C++11
+
+#endif // _GLIBCXX_THREAD
diff --git a/gcc-4.9/libstdc++-v3/include/std/tuple b/gcc-4.9/libstdc++-v3/include/std/tuple
new file mode 100644
index 0000000..92ecdb9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/tuple
@@ -0,0 +1,1104 @@
+// <tuple> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/tuple
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TUPLE
+#define _GLIBCXX_TUPLE 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <utility>
+#include <array>
+#include <bits/uses_allocator.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @addtogroup utilities
+   *  @{
+   */
+
+  // Adds a const reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_c_ref
+    { typedef const _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_c_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  // Adds a reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_ref
+    { typedef _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  // Adds an rvalue reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_r_ref
+    { typedef _Tp&& type; };
+
+  template<typename _Tp>
+    struct __add_r_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
+    struct _Head_base;
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, true>
+    : public _Head
+    {
+      constexpr _Head_base()
+      : _Head() { }
+
+      constexpr _Head_base(const _Head& __h)
+      : _Head(__h) { }
+
+      template<typename _UHead, typename = typename
+	       enable_if<!is_convertible<_UHead,
+	                                 __uses_alloc_base>::value>::type>
+        constexpr _Head_base(_UHead&& __h)
+	: _Head(std::forward<_UHead>(__h)) { }
+
+      _Head_base(__uses_alloc0)
+      : _Head() { }
+
+      template<typename _Alloc>
+	_Head_base(__uses_alloc1<_Alloc> __a)
+	: _Head(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+	_Head_base(__uses_alloc2<_Alloc> __a)
+	: _Head(*__a._M_a) { }
+
+      template<typename _UHead>
+	_Head_base(__uses_alloc0, _UHead&& __uhead)
+	: _Head(std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+	_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+	: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+	_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+	: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
+
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b; }
+
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b; }
+    };
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, false>
+    {
+      constexpr _Head_base()
+      : _M_head_impl() { }
+
+      constexpr _Head_base(const _Head& __h)
+      : _M_head_impl(__h) { }
+
+      template<typename _UHead, typename = typename
+	       enable_if<!is_convertible<_UHead,
+	                                 __uses_alloc_base>::value>::type>
+        constexpr _Head_base(_UHead&& __h)
+	: _M_head_impl(std::forward<_UHead>(__h)) { }
+
+      _Head_base(__uses_alloc0)
+      : _M_head_impl() { }
+
+      template<typename _Alloc>
+	_Head_base(__uses_alloc1<_Alloc> __a)
+	: _M_head_impl(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+	_Head_base(__uses_alloc2<_Alloc> __a)
+	: _M_head_impl(*__a._M_a) { }
+
+      template<typename _UHead>
+	_Head_base(__uses_alloc0, _UHead&& __uhead)
+	: _M_head_impl(std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+	_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+	: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
+	{ }
+
+      template<typename _Alloc, typename _UHead>
+	_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+	: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
+
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
+
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
+
+      _Head _M_head_impl;
+    };
+
+  /**
+   * Contains the actual implementation of the @c tuple template, stored
+   * as a recursive inheritance hierarchy from the first element (most
+   * derived class) to the last (least derived class). The @c Idx
+   * parameter gives the 0-based index of the element stored at this
+   * point in the hierarchy; we use it to implement a constant-time
+   * get() operation.
+   */
+  template<std::size_t _Idx, typename... _Elements>
+    struct _Tuple_impl; 
+
+  /**
+   * Zero-element tuple implementation. This is the basis case for the 
+   * inheritance recursion.
+   */
+  template<std::size_t _Idx>
+    struct _Tuple_impl<_Idx>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      _Tuple_impl() = default;
+
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t, const _Alloc&) { }
+
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { }
+
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { }
+
+    protected:
+      void _M_swap(_Tuple_impl&) noexcept { /* no-op */ }
+    };
+
+  template<typename _Tp>
+    struct __is_empty_non_tuple : is_empty<_Tp> { };
+
+  // Using EBO for elements that are tuples causes ambiguous base errors.
+  template<typename _El0, typename... _El>
+    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
+
+  // Use the Empty Base-class Optimization for empty, non-final types.
+  template<typename _Tp>
+    using __empty_not_final
+    = typename conditional<__is_final(_Tp), false_type,
+			   __is_empty_non_tuple<_Tp>>::type;
+
+  /**
+   * Recursive tuple implementation. Here we store the @c Head element
+   * and derive from a @c Tuple_impl containing the remaining elements
+   * (which contains the @c Tail).
+   */
+  template<std::size_t _Idx, typename _Head, typename... _Tail>
+    struct _Tuple_impl<_Idx, _Head, _Tail...>
+    : public _Tuple_impl<_Idx + 1, _Tail...>,
+      private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
+
+      static constexpr _Head&  
+      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr const _Head&
+      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr _Inherited&
+      _M_tail(_Tuple_impl& __t) noexcept { return __t; }
+
+      static constexpr const _Inherited&
+      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
+
+      constexpr _Tuple_impl()
+      : _Inherited(), _Base() { }
+
+      explicit 
+      constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
+      : _Inherited(__tail...), _Base(__head) { }
+
+      template<typename _UHead, typename... _UTail, typename = typename
+               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> 
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
+	: _Inherited(std::forward<_UTail>(__tail)...),
+	  _Base(std::forward<_UHead>(__head)) { }
+
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(__and_<is_nothrow_move_constructible<_Head>,
+	              is_nothrow_move_constructible<_Inherited>>::value)
+      : _Inherited(std::move(_M_tail(__in))), 
+	_Base(std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename... _UElements>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+	: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
+	  _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+
+      template<typename _UHead, typename... _UTails>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+	: _Inherited(std::move
+		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+	  _Base(std::forward<_UHead>
+		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+
+      template<typename _Alloc>
+	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+	: _Inherited(__tag, __a),
+          _Base(__use_alloc<_Head>(__a)) { }
+
+      template<typename _Alloc>
+	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+		    const _Head& __head, const _Tail&... __tail)
+	: _Inherited(__tag, __a, __tail...),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+
+      template<typename _Alloc, typename _UHead, typename... _UTail,
+               typename = typename enable_if<sizeof...(_Tail)
+					     == sizeof...(_UTail)>::type>
+	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+	            _UHead&& __head, _UTail&&... __tail)
+	: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
+          _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+	        std::forward<_UHead>(__head)) { }
+
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+	            const _Tuple_impl& __in)
+	: _Inherited(__tag, __a, _M_tail(__in)), 
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+
+      template<typename _Alloc>
+	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+	            _Tuple_impl&& __in)
+	: _Inherited(__tag, __a, std::move(_M_tail(__in))), 
+	  _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+	        std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _Alloc, typename... _UElements>
+	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+	            const _Tuple_impl<_Idx, _UElements...>& __in)
+	: _Inherited(__tag, __a,
+		     _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
+	  _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+		_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+
+      template<typename _Alloc, typename _UHead, typename... _UTails>
+	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+	            _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+	: _Inherited(__tag, __a, std::move
+		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+	  _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>
+		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+	_M_head(*this) = _M_head(__in);
+	_M_tail(*this) = _M_tail(__in);
+	return *this;
+      }
+
+      _Tuple_impl&
+      operator=(_Tuple_impl&& __in)
+      noexcept(__and_<is_nothrow_move_assignable<_Head>,
+	              is_nothrow_move_assignable<_Inherited>>::value)
+      {
+	_M_head(*this) = std::forward<_Head>(_M_head(__in));
+	_M_tail(*this) = std::move(_M_tail(__in));
+	return *this;
+      }
+
+      template<typename... _UElements>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+	  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+	  _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
+	  return *this;
+	}
+
+      template<typename _UHead, typename... _UTails>
+        _Tuple_impl&
+        operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+        {
+	  _M_head(*this) = std::forward<_UHead>
+	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+	  _M_tail(*this) = std::move
+	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
+	  return *this;
+	}
+
+    protected:
+      void
+      _M_swap(_Tuple_impl& __in)
+      noexcept(noexcept(swap(std::declval<_Head&>(),
+			     std::declval<_Head&>()))
+	       && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
+      {
+	using std::swap;
+	swap(_M_head(*this), _M_head(__in));
+	_Inherited::_M_swap(_M_tail(__in));
+      }
+    };
+
+  /// Primary class template, tuple
+  template<typename... _Elements> 
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+    public:
+      constexpr tuple()
+      : _Inherited() { }
+
+      explicit
+      constexpr tuple(const _Elements&... __elements)
+      : _Inherited(__elements...) { }
+
+      template<typename... _UElements, typename = typename
+        enable_if<__and_<is_convertible<_UElements,
+					_Elements>...>::value>::type>
+	explicit
+        constexpr tuple(_UElements&&... __elements)
+	: _Inherited(std::forward<_UElements>(__elements)...) {	}
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default; 
+
+      template<typename... _UElements, typename = typename
+        enable_if<__and_<is_convertible<const _UElements&,
+					_Elements>...>::value>::type>
+        constexpr tuple(const tuple<_UElements...>& __in)
+        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+        { }
+
+      template<typename... _UElements, typename = typename
+        enable_if<__and_<is_convertible<_UElements,
+					_Elements>...>::value>::type>
+        constexpr tuple(tuple<_UElements...>&& __in)
+        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+
+      // Allocator-extended constructors.
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a)
+	: _Inherited(__tag, __a) { }
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a,
+	      const _Elements&... __elements)
+	: _Inherited(__tag, __a, __elements...) { }
+
+      template<typename _Alloc, typename... _UElements, typename = typename
+	       enable_if<sizeof...(_UElements)
+			 == sizeof...(_Elements)>::type>
+	tuple(allocator_arg_t __tag, const _Alloc& __a,
+	      _UElements&&... __elements)
+	: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+       	{ }
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+	: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+	: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+
+      template<typename _Alloc, typename... _UElements, typename = typename
+	       enable_if<sizeof...(_UElements)
+			 == sizeof...(_Elements)>::type>
+	tuple(allocator_arg_t __tag, const _Alloc& __a,
+	      const tuple<_UElements...>& __in)
+	: _Inherited(__tag, __a,
+	             static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+	{ }
+
+      template<typename _Alloc, typename... _UElements, typename = typename
+	       enable_if<sizeof...(_UElements)
+			 == sizeof...(_Elements)>::type>
+	tuple(allocator_arg_t __tag, const _Alloc& __a,
+	      tuple<_UElements...>&& __in)
+	: _Inherited(__tag, __a,
+	             static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+	{ }
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+
+      tuple&
+      operator=(tuple&& __in)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
+      {
+	static_cast<_Inherited&>(*this) = std::move(__in);
+	return *this;
+      }
+
+      template<typename... _UElements, typename = typename
+	       enable_if<sizeof...(_UElements)
+			 == sizeof...(_Elements)>::type>
+        tuple&
+        operator=(const tuple<_UElements...>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      template<typename... _UElements, typename = typename
+	       enable_if<sizeof...(_UElements)
+			 == sizeof...(_Elements)>::type>
+        tuple&
+        operator=(tuple<_UElements...>&& __in)
+        {
+	  static_cast<_Inherited&>(*this) = std::move(__in);
+	  return *this;
+	}
+
+      void
+      swap(tuple& __in)
+      noexcept(noexcept(__in._M_swap(__in)))
+      { _Inherited::_M_swap(__in); }
+    };
+
+  // Explicit specialization, zero-element tuple.
+  template<>  
+    class tuple<>
+    {
+    public:
+      void swap(tuple&) noexcept { /* no-op */ }
+    };
+
+  /// Partial specialization, 2-element tuple.
+  /// Includes construction and assignment from a pair.
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+    public:
+      constexpr tuple()
+      : _Inherited() { }
+
+      explicit
+      constexpr tuple(const _T1& __a1, const _T2& __a2)
+      : _Inherited(__a1, __a2) { }
+
+      template<typename _U1, typename _U2, typename = typename
+	       enable_if<__and_<is_convertible<_U1, _T1>,
+				is_convertible<_U2, _T2>>::value>::type>
+        explicit
+        constexpr tuple(_U1&& __a1, _U2&& __a2)
+	: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default;
+
+      template<typename _U1, typename _U2, typename = typename
+	enable_if<__and_<is_convertible<const _U1&, _T1>,
+			 is_convertible<const _U2&, _T2>>::value>::type>
+        constexpr tuple(const tuple<_U1, _U2>& __in)
+	: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+
+      template<typename _U1, typename _U2, typename = typename
+	       enable_if<__and_<is_convertible<_U1, _T1>,
+				is_convertible<_U2, _T2>>::value>::type>
+        constexpr tuple(tuple<_U1, _U2>&& __in)
+	: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+
+      template<typename _U1, typename _U2, typename = typename
+	enable_if<__and_<is_convertible<const _U1&, _T1>,
+			 is_convertible<const _U2&, _T2>>::value>::type>
+        constexpr tuple(const pair<_U1, _U2>& __in)
+	: _Inherited(__in.first, __in.second) { }
+
+      template<typename _U1, typename _U2, typename = typename
+	       enable_if<__and_<is_convertible<_U1, _T1>,
+				is_convertible<_U2, _T2>>::value>::type>
+        constexpr tuple(pair<_U1, _U2>&& __in)
+	: _Inherited(std::forward<_U1>(__in.first),
+		     std::forward<_U2>(__in.second)) { }
+
+      // Allocator-extended constructors.
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a)
+	: _Inherited(__tag, __a) { }
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a,
+	      const _T1& __a1, const _T2& __a2)
+	: _Inherited(__tag, __a, __a1, __a2) { }
+
+      template<typename _Alloc, typename _U1, typename _U2>
+	tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
+	: _Inherited(__tag, __a, std::forward<_U1>(__a1),
+	             std::forward<_U2>(__a2)) { }
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+	: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+
+      template<typename _Alloc>
+	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+	: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2>
+	tuple(allocator_arg_t __tag, const _Alloc& __a,
+	      const tuple<_U1, _U2>& __in)
+	: _Inherited(__tag, __a,
+	             static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+	{ }
+
+      template<typename _Alloc, typename _U1, typename _U2>
+	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
+	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+	{ }
+
+      template<typename _Alloc, typename _U1, typename _U2>
+        tuple(allocator_arg_t __tag, const _Alloc& __a,
+	      const pair<_U1, _U2>& __in)
+	: _Inherited(__tag, __a, __in.first, __in.second) { }
+
+      template<typename _Alloc, typename _U1, typename _U2>
+        tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
+	: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
+		     std::forward<_U2>(__in.second)) { }
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+
+      tuple&
+      operator=(tuple&& __in)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
+      {
+	static_cast<_Inherited&>(*this) = std::move(__in);
+	return *this;
+      }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const tuple<_U1, _U2>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(tuple<_U1, _U2>&& __in)
+        {
+	  static_cast<_Inherited&>(*this) = std::move(__in);
+	  return *this;
+	}
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const pair<_U1, _U2>& __in)
+        {
+	  this->_M_head(*this) = __in.first;
+	  this->_M_tail(*this)._M_head(*this) = __in.second;
+	  return *this;
+	}
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(pair<_U1, _U2>&& __in)
+        {
+	  this->_M_head(*this) = std::forward<_U1>(__in.first);
+	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
+	  return *this;
+	}
+
+      void
+      swap(tuple& __in)
+      noexcept(noexcept(__in._M_swap(__in)))
+      { _Inherited::_M_swap(__in); }
+    };
+
+
+  /// Gives the type of the ith element of a given tuple type.
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element;
+
+  /**
+   * Recursive case for tuple_element: strip off the first element in
+   * the tuple and retrieve the (i-1)th element of the remaining tuple.
+   */
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    struct tuple_element<__i, tuple<_Head, _Tail...> >
+    : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+  /**
+   * Basis case for tuple_element: The first element is the one we're seeking.
+   */
+  template<typename _Head, typename... _Tail>
+    struct tuple_element<0, tuple<_Head, _Tail...> >
+    {
+      typedef _Head type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const _Tp>
+    {
+      typedef typename
+      add_const<typename tuple_element<__i, _Tp>::type>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, volatile _Tp>
+    {
+      typedef typename
+      add_volatile<typename tuple_element<__i, _Tp>::type>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const volatile _Tp>
+    {
+      typedef typename
+      add_cv<typename tuple_element<__i, _Tp>::type>::type type;
+    };
+
+  /// Finds the size of a given tuple type.
+  template<typename _Tp>
+    struct tuple_size;
+
+  template<typename _Tp>
+    struct tuple_size<const _Tp>
+    : public integral_constant<
+             typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
+             tuple_size<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct tuple_size<volatile _Tp>
+    : public integral_constant<
+             typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
+             tuple_size<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct tuple_size<const volatile _Tp>
+    : public integral_constant<
+             typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
+             tuple_size<_Tp>::value> { };
+
+  /// class tuple_size
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...>>
+    : public integral_constant<std::size_t, sizeof...(_Elements)> { };
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr typename __add_ref<_Head>::type
+    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr typename __add_c_ref<_Head>::type
+    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  // Return a reference (const reference, rvalue reference) to the ith element
+  // of a tuple.  Any const or non-const ref elements are returned with their
+  // original type.
+  template<std::size_t __i, typename... _Elements>
+    constexpr typename __add_ref<
+                      typename tuple_element<__i, tuple<_Elements...>>::type
+                    >::type
+    get(tuple<_Elements...>& __t) noexcept
+    { return __get_helper<__i>(__t); }
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr typename __add_c_ref<
+                      typename tuple_element<__i, tuple<_Elements...>>::type
+                    >::type
+    get(const tuple<_Elements...>& __t) noexcept
+    { return __get_helper<__i>(__t); }
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr typename __add_r_ref<
+                      typename tuple_element<__i, tuple<_Elements...>>::type
+                    >::type
+    get(tuple<_Elements...>&& __t) noexcept
+    { return std::forward<typename tuple_element<__i,
+	tuple<_Elements...>>::type&&>(get<__i>(__t)); }
+
+#if __cplusplus > 201103L
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr typename __add_ref<_Head>::type
+    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr typename __add_c_ref<_Head>::type
+    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&
+    get(tuple<_Types...>& __t) noexcept
+    { return __get_helper2<_Tp>(__t); }
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&&
+    get(tuple<_Types...>&& __t) noexcept
+    { return std::move(__get_helper2<_Tp>(__t)); }
+
+  template <typename _Tp, typename... _Types>
+    constexpr const _Tp&
+    get(const tuple<_Types...>& __t) noexcept
+    { return __get_helper2<_Tp>(__t); }
+#endif
+
+  // This class helps construct the various comparison operations on tuples
+  template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
+	   typename _Tp, typename _Up>
+    struct __tuple_compare;
+
+  template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __j, _Tp, _Up>
+    {
+      static constexpr bool 
+      __eq(const _Tp& __t, const _Up& __u)
+      {
+	return (get<__i>(__t) == get<__i>(__u) &&
+		__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u));
+      }
+     
+      static constexpr bool 
+      __less(const _Tp& __t, const _Up& __u)
+      {
+	return ((get<__i>(__t) < get<__i>(__u))
+		|| !(get<__i>(__u) < get<__i>(__t)) &&
+		__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u));
+      }
+    };
+
+  template<std::size_t __i, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __i, _Tp, _Up>
+    {
+      static constexpr bool 
+      __eq(const _Tp&, const _Up&) { return true; }
+     
+      static constexpr bool 
+      __less(const _Tp&, const _Up&) { return false; }
+    };
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator==(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return bool(__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return bool(__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator!=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    { return __u < __t; }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t < __u); }
+
+  // NB: DR 705.
+  template<typename... _Elements>
+    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
+    make_tuple(_Elements&&... __args)
+    {
+      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
+	__result_type;
+      return __result_type(std::forward<_Elements>(__args)...);
+    }
+
+  template<typename... _Elements>
+    tuple<_Elements&&...>
+    forward_as_tuple(_Elements&&... __args) noexcept
+    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
+
+  template<typename>
+    struct __is_tuple_like_impl : false_type
+    { };
+
+  template<typename... _Tps>
+    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
+    { };
+
+  template<typename _T1, typename _T2>
+    struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
+    { };
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
+    { };
+
+  // Internal type trait that allows us to sfinae-protect tuple_cat.
+  template<typename _Tp>
+    struct __is_tuple_like
+    : public __is_tuple_like_impl<typename std::remove_cv
+            <typename std::remove_reference<_Tp>::type>::type>::type
+    { };
+
+  template<std::size_t, typename, typename, std::size_t>
+    struct __make_tuple_impl;
+
+  template<std::size_t _Idx, typename _Tuple, typename... _Tp,
+           std::size_t _Nm>
+    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
+    {
+      typedef typename __make_tuple_impl<_Idx + 1, tuple<_Tp...,
+	typename std::tuple_element<_Idx, _Tuple>::type>, _Tuple, _Nm>::__type
+      __type;
+    };
+
+  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
+    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
+    {
+      typedef tuple<_Tp...> __type;
+    };
+
+  template<typename _Tuple>
+    struct __do_make_tuple
+    : public __make_tuple_impl<0, tuple<>, _Tuple,
+                               std::tuple_size<_Tuple>::value>
+    { };
+
+  // Returns the std::tuple equivalent of a tuple-like type.
+  template<typename _Tuple>
+    struct __make_tuple
+    : public __do_make_tuple<typename std::remove_cv
+            <typename std::remove_reference<_Tuple>::type>::type>
+    { };
+
+  // Combines several std::tuple's into a single one.
+  template<typename...>
+    struct __combine_tuples;
+
+  template<>
+    struct __combine_tuples<>
+    {
+      typedef tuple<> __type;
+    };
+
+  template<typename... _Ts>
+    struct __combine_tuples<tuple<_Ts...>>
+    {
+      typedef tuple<_Ts...> __type;
+    };
+
+  template<typename... _T1s, typename... _T2s, typename... _Rem>
+    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
+    {
+      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
+					_Rem...>::__type __type;
+    };
+
+  // Computes the result type of tuple_cat given a set of tuple-like types.
+  template<typename... _Tpls>
+    struct __tuple_cat_result
+    {
+      typedef typename __combine_tuples
+        <typename __make_tuple<_Tpls>::__type...>::__type __type;
+    };
+
+  // Helper to determine the index set for the first tuple-like
+  // type of a given set.
+  template<typename...>
+    struct __make_1st_indices;
+
+  template<>
+    struct __make_1st_indices<>
+    {
+      typedef std::_Index_tuple<> __type;
+    };
+
+  template<typename _Tp, typename... _Tpls>
+    struct __make_1st_indices<_Tp, _Tpls...>
+    {
+      typedef typename std::_Build_index_tuple<std::tuple_size<
+	typename std::remove_reference<_Tp>::type>::value>::__type __type;
+    };
+
+  // Performs the actual concatenation by step-wise expanding tuple-like
+  // objects into the elements,  which are finally forwarded into the
+  // result tuple.
+  template<typename _Ret, typename _Indices, typename... _Tpls>
+    struct __tuple_concater;
+
+  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
+    struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
+    {
+      template<typename... _Us>
+        static constexpr _Ret
+        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
+        {
+	  typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+	  typedef __tuple_concater<_Ret, __idx, _Tpls...>      __next;
+	  return __next::_S_do(std::forward<_Tpls>(__tps)...,
+			       std::forward<_Us>(__us)...,
+			       std::get<_Is>(std::forward<_Tp>(__tp))...);
+	}
+    };
+
+  template<typename _Ret>
+    struct __tuple_concater<_Ret, std::_Index_tuple<>>
+    {
+      template<typename... _Us>
+	static constexpr _Ret
+	_S_do(_Us&&... __us)
+        {
+	  return _Ret(std::forward<_Us>(__us)...);
+	}
+    };
+
+  /// tuple_cat
+  template<typename... _Tpls, typename = typename
+           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
+    constexpr auto
+    tuple_cat(_Tpls&&... __tpls)
+    -> typename __tuple_cat_result<_Tpls...>::__type
+    {
+      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
+      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
+      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
+    }
+
+  /// tie
+  template<typename... _Elements>
+    inline tuple<_Elements&...>
+    tie(_Elements&... __args) noexcept
+    { return tuple<_Elements&...>(__args...); }
+
+  /// swap
+  template<typename... _Elements>
+    inline void 
+    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  // A class (and instance) which can be used in 'tie' when an element
+  // of a tuple is not required
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      const _Swallow_assign&
+      operator=(const _Tp&) const
+      { return *this; }
+  };
+
+  const _Swallow_assign ignore{};
+
+  /// Partial specialization for tuples
+  template<typename... _Types, typename _Alloc>
+    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
+
+  // See stl_pair.h...
+  template<class _T1, class _T2>
+    template<typename... _Args1, typename... _Args2>
+      inline
+      pair<_T1, _T2>::
+      pair(piecewise_construct_t,
+	   tuple<_Args1...> __first, tuple<_Args2...> __second)
+      : pair(__first, __second,
+	     typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
+	     typename _Build_index_tuple<sizeof...(_Args2)>::__type())
+      { }
+
+  template<class _T1, class _T2>
+    template<typename... _Args1, std::size_t... _Indexes1,
+             typename... _Args2, std::size_t... _Indexes2>
+      inline
+      pair<_T1, _T2>::
+      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
+	   _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
+      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
+        second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
+      { }
+
+  /// @}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_TUPLE
diff --git a/gcc-4.9/libstdc++-v3/include/std/type_traits b/gcc-4.9/libstdc++-v3/include/std/type_traits
new file mode 100644
index 0000000..4b434a6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/type_traits
@@ -0,0 +1,2236 @@
+// C++11 <type_traits> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/type_traits
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TYPE_TRAITS
+#define _GLIBCXX_TYPE_TRAITS 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <bits/c++config.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup metaprogramming Metaprogramming
+   * @ingroup utilities
+   *
+   * Template utilities for compile-time introspection and modification,
+   * including type classification traits, type property inspection traits
+   * and type transformation traits.
+   *
+   * @{
+   */
+
+  /// integral_constant
+  template<typename _Tp, _Tp __v>
+    struct integral_constant
+    {
+      static constexpr _Tp                  value = __v;
+      typedef _Tp                           value_type;
+      typedef integral_constant<_Tp, __v>   type;
+      constexpr operator value_type() const { return value; }
+#if __cplusplus > 201103L
+      constexpr value_type operator()() const { return value; }
+#endif
+    };
+  
+  template<typename _Tp, _Tp __v>
+    constexpr _Tp integral_constant<_Tp, __v>::value;
+
+  /// The type used as a compile-time boolean with true value.
+  typedef integral_constant<bool, true>     true_type;
+
+  /// The type used as a compile-time boolean with false value.
+  typedef integral_constant<bool, false>    false_type;
+
+  // Meta programming helper types.
+
+  template<bool, typename, typename>
+    struct conditional;
+
+  template<typename...>
+    struct __or_;
+
+  template<>
+    struct __or_<>
+    : public false_type
+    { };
+
+  template<typename _B1>
+    struct __or_<_B1>
+    : public _B1
+    { };
+
+  template<typename _B1, typename _B2>
+    struct __or_<_B1, _B2>
+    : public conditional<_B1::value, _B1, _B2>::type
+    { };
+
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __or_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
+    { };
+
+  template<typename...>
+    struct __and_;
+
+  template<>
+    struct __and_<>
+    : public true_type
+    { };
+
+  template<typename _B1>
+    struct __and_<_B1>
+    : public _B1
+    { };
+
+  template<typename _B1, typename _B2>
+    struct __and_<_B1, _B2>
+    : public conditional<_B1::value, _B2, _B1>::type
+    { };
+
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __and_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
+    { };
+
+  template<typename _Pp>
+    struct __not_
+    : public integral_constant<bool, !_Pp::value>
+    { };
+
+  // For several sfinae-friendly trait implementations we transport both the
+  // result information (as the member type) and the failure information (no
+  // member type). This is very similar to std::enable_if, but we cannot use
+  // them, because we need to derive from them as an implementation detail.
+
+  template<typename _Tp>
+    struct __success_type
+    { typedef _Tp type; };
+
+  struct __failure_type
+  { };
+
+  // Primary type categories.
+
+  template<typename>
+    struct remove_cv;
+
+  template<typename>
+    struct __is_void_helper
+    : public false_type { };
+
+  template<>
+    struct __is_void_helper<void>
+    : public true_type { };
+
+  /// is_void
+  template<typename _Tp>
+    struct is_void
+    : public __is_void_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  template<typename>
+    struct __is_integral_helper
+    : public false_type { };
+
+  template<>
+    struct __is_integral_helper<bool>
+    : public true_type { };
+  
+  template<>
+    struct __is_integral_helper<char>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<signed char>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned char>
+    : public true_type { };
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    struct __is_integral_helper<wchar_t>
+    : public true_type { };
+#endif
+
+  template<>
+    struct __is_integral_helper<char16_t>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<char32_t>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<short>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned short>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<int>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned int>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<long long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned long long>
+    : public true_type { };
+
+#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
+  template<>
+    struct __is_integral_helper<__int128>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned __int128>
+    : public true_type { };
+#endif
+
+  /// is_integral
+  template<typename _Tp>
+    struct is_integral
+    : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  template<typename>
+    struct __is_floating_point_helper
+    : public false_type { };
+
+  template<>
+    struct __is_floating_point_helper<float>
+    : public true_type { };
+
+  template<>
+    struct __is_floating_point_helper<double>
+    : public true_type { };
+
+  template<>
+    struct __is_floating_point_helper<long double>
+    : public true_type { };
+
+#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128)
+  template<>
+    struct __is_floating_point_helper<__float128>
+    : public true_type { };
+#endif
+
+  /// is_floating_point
+  template<typename _Tp>
+    struct is_floating_point
+    : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  /// is_array
+  template<typename>
+    struct is_array
+    : public false_type { };
+
+  template<typename _Tp, std::size_t _Size>
+    struct is_array<_Tp[_Size]>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_array<_Tp[]>
+    : public true_type { };
+
+  template<typename>
+    struct __is_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_pointer_helper<_Tp*>
+    : public true_type { };
+
+  /// is_pointer
+  template<typename _Tp>
+    struct is_pointer
+    : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  /// is_lvalue_reference
+  template<typename>
+    struct is_lvalue_reference
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_lvalue_reference<_Tp&>
+    : public true_type { };
+
+  /// is_rvalue_reference
+  template<typename>
+    struct is_rvalue_reference
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_rvalue_reference<_Tp&&>
+    : public true_type { };
+
+  template<typename>
+    struct is_function;
+
+  template<typename>
+    struct __is_member_object_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_object_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, !is_function<_Tp>::value> { };
+
+  /// is_member_object_pointer
+  template<typename _Tp>
+    struct is_member_object_pointer
+    : public __is_member_object_pointer_helper<
+				typename remove_cv<_Tp>::type>::type
+    { };
+
+  template<typename>
+    struct __is_member_function_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_function_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, is_function<_Tp>::value> { };
+
+  /// is_member_function_pointer
+  template<typename _Tp>
+    struct is_member_function_pointer
+    : public __is_member_function_pointer_helper<
+				typename remove_cv<_Tp>::type>::type
+    { };
+
+  /// is_enum
+  template<typename _Tp>
+    struct is_enum
+    : public integral_constant<bool, __is_enum(_Tp)>
+    { };
+
+  /// is_union
+  template<typename _Tp>
+    struct is_union
+    : public integral_constant<bool, __is_union(_Tp)>
+    { };
+
+  /// is_class
+  template<typename _Tp>
+    struct is_class
+    : public integral_constant<bool, __is_class(_Tp)>
+    { };
+
+  /// is_function
+  template<typename>
+    struct is_function
+    : public false_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...)>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......)>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) volatile &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) volatile &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const volatile &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const volatile &&>
+    : public true_type { };
+
+  template<typename>
+    struct __is_null_pointer_helper
+    : public false_type { };
+
+  template<>
+    struct __is_null_pointer_helper<std::nullptr_t>
+    : public true_type { };
+
+  /// is_null_pointer (LWG 2247).
+  template<typename _Tp>
+    struct is_null_pointer
+    : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  /// __is_nullptr_t (extension).
+  template<typename _Tp>
+    struct __is_nullptr_t
+    : public is_null_pointer<_Tp>
+    { };
+
+  // Composite type categories.
+
+  /// is_reference
+  template<typename _Tp>
+    struct is_reference
+    : public __or_<is_lvalue_reference<_Tp>,
+                   is_rvalue_reference<_Tp>>::type
+    { };
+
+  /// is_arithmetic
+  template<typename _Tp>
+    struct is_arithmetic
+    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
+    { };
+
+  /// is_fundamental
+  template<typename _Tp>
+    struct is_fundamental
+    : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
+		   is_null_pointer<_Tp>>::type
+    { };
+
+  /// is_object
+  template<typename _Tp>
+    struct is_object
+    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
+                          is_void<_Tp>>>::type
+    { };
+
+  template<typename>
+    struct is_member_pointer;
+
+  /// is_scalar
+  template<typename _Tp>
+    struct is_scalar
+    : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
+                   is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
+    { };
+
+  /// is_compound
+  template<typename _Tp>
+    struct is_compound
+    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct __is_member_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_pointer_helper<_Tp _Cp::*>
+    : public true_type { };
+
+  /// is_member_pointer
+  template<typename _Tp>
+    struct is_member_pointer
+    : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  // Utility to detect referenceable types ([defns.referenceable]).
+
+  template<typename _Tp>
+    struct __is_referenceable
+    : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
+    { };
+
+  template<typename _Res, typename... _Args>
+    struct __is_referenceable<_Res(_Args...)>
+    : public true_type
+    { };
+
+  template<typename _Res, typename... _Args>
+    struct __is_referenceable<_Res(_Args......)>
+    : public true_type
+    { };
+
+  // Type properties.
+
+  /// is_const
+  template<typename>
+    struct is_const
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_const<_Tp const>
+    : public true_type { };
+  
+  /// is_volatile
+  template<typename>
+    struct is_volatile
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_volatile<_Tp volatile>
+    : public true_type { };
+
+  /// is_trivial
+  template<typename _Tp>
+    struct is_trivial
+    : public integral_constant<bool, __is_trivial(_Tp)>
+    { };
+
+  // is_trivially_copyable (still unimplemented)
+
+  /// is_standard_layout
+  template<typename _Tp>
+    struct is_standard_layout
+    : public integral_constant<bool, __is_standard_layout(_Tp)>
+    { };
+
+  /// is_pod
+  // Could use is_standard_layout && is_trivial instead of the builtin.
+  template<typename _Tp>
+    struct is_pod
+    : public integral_constant<bool, __is_pod(_Tp)>
+    { };
+
+  /// is_literal_type
+  template<typename _Tp>
+    struct is_literal_type
+    : public integral_constant<bool, __is_literal_type(_Tp)>
+    { };
+
+  /// is_empty
+  template<typename _Tp>
+    struct is_empty
+    : public integral_constant<bool, __is_empty(_Tp)>
+    { };
+
+  /// is_polymorphic
+  template<typename _Tp>
+    struct is_polymorphic
+    : public integral_constant<bool, __is_polymorphic(_Tp)>
+    { };
+
+  /// is_abstract
+  template<typename _Tp>
+    struct is_abstract
+    : public integral_constant<bool, __is_abstract(_Tp)>
+    { };
+
+  template<typename _Tp,
+	   bool = is_arithmetic<_Tp>::value>
+    struct __is_signed_helper
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_signed_helper<_Tp, true>
+    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
+    { };
+
+  /// is_signed
+  template<typename _Tp>
+    struct is_signed
+    : public __is_signed_helper<_Tp>::type
+    { };
+
+  /// is_unsigned
+  template<typename _Tp>
+    struct is_unsigned
+    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
+    { };
+
+
+  // Destructible and constructible type properties.
+
+  template<typename>
+    struct add_rvalue_reference;
+
+  /**
+   *  @brief  Utility to simplify expressions used in unevaluated operands
+   *  @ingroup utilities
+   */
+  template<typename _Tp>
+    typename add_rvalue_reference<_Tp>::type declval() noexcept;
+
+  template<typename, unsigned = 0>
+    struct extent;
+
+  template<typename>
+    struct remove_all_extents;
+
+  template<typename _Tp>
+    struct __is_array_known_bounds
+    : public integral_constant<bool, (extent<_Tp>::value > 0)>
+    { };
+
+  template<typename _Tp>
+    struct __is_array_unknown_bounds
+    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
+    { };
+    
+  // In N3290 is_destructible does not say anything about function
+  // types and abstract types, see LWG 2049. This implementation
+  // describes function types as non-destructible and all complete
+  // object types as destructible, iff the explicit destructor
+  // call expression is wellformed.
+  struct __do_is_destructible_impl
+  {
+    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
+      static true_type __test(int);
+
+    template<typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_destructible_impl
+    : public __do_is_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_destructible_safe;
+
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, false, false>
+    : public __is_destructible_impl<typename
+               remove_all_extents<_Tp>::type>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, true, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, false, true>
+    : public true_type { };
+
+  /// is_destructible
+  template<typename _Tp>
+    struct is_destructible
+    : public __is_destructible_safe<_Tp>::type
+    { };
+
+  // is_nothrow_destructible requires that is_destructible is
+  // satisfied as well.  We realize that by mimicing the
+  // implementation of is_destructible but refer to noexcept(expr)
+  // instead of decltype(expr).
+  struct __do_is_nt_destructible_impl
+  {
+    template<typename _Tp>
+      static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
+        __test(int);
+
+    template<typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_impl
+    : public __do_is_nt_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_nt_destructible_safe;
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, false>
+    : public __is_nt_destructible_impl<typename
+               remove_all_extents<_Tp>::type>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, true, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, true>
+    : public true_type { };
+
+  /// is_nothrow_destructible
+  template<typename _Tp>
+    struct is_nothrow_destructible
+    : public __is_nt_destructible_safe<_Tp>::type
+    { };
+
+  struct __do_is_default_constructible_impl
+  {
+    template<typename _Tp, typename = decltype(_Tp())>
+      static true_type __test(int);
+
+    template<typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_default_constructible_impl
+    : public __do_is_default_constructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp>
+    struct __is_default_constructible_atom
+    : public __and_<__not_<is_void<_Tp>>,
+                    __is_default_constructible_impl<_Tp>>::type
+    { };
+
+  template<typename _Tp, bool = is_array<_Tp>::value>
+    struct __is_default_constructible_safe;
+
+  // The following technique is a workaround for a current core language
+  // restriction, which does not allow for array types to occur in 
+  // functional casts of the form T().  Complete arrays can be default-
+  // constructed, if the element type is default-constructible, but 
+  // arrays with unknown bounds are not.
+  template<typename _Tp>
+    struct __is_default_constructible_safe<_Tp, true>
+    : public __and_<__is_array_known_bounds<_Tp>,
+		    __is_default_constructible_atom<typename
+                      remove_all_extents<_Tp>::type>>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_default_constructible_safe<_Tp, false>
+    : public __is_default_constructible_atom<_Tp>::type
+    { };
+
+  /// is_default_constructible
+  template<typename _Tp>
+    struct is_default_constructible
+    : public __is_default_constructible_safe<_Tp>::type
+    { };
+
+
+  // Implementation of is_constructible.
+
+  // The hardest part of this trait is the binary direct-initialization
+  // case, because we hit into a functional cast of the form T(arg).
+  // This implementation uses different strategies depending on the
+  // target type to reduce the test overhead as much as possible:
+  //
+  // a) For a reference target type, we use a static_cast expression 
+  //    modulo its extra cases.
+  //
+  // b) For a non-reference target type we use a ::new expression.
+  struct __do_is_static_castable_impl
+  {
+    template<typename _From, typename _To, typename
+             = decltype(static_cast<_To>(declval<_From>()))>
+      static true_type __test(int);
+
+    template<typename, typename>
+      static false_type __test(...);
+  };
+
+  template<typename _From, typename _To>
+    struct __is_static_castable_impl
+    : public __do_is_static_castable_impl
+    {
+      typedef decltype(__test<_From, _To>(0)) type;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_static_castable_safe
+    : public __is_static_castable_impl<_From, _To>::type
+    { };
+
+  // __is_static_castable
+  template<typename _From, typename _To>
+    struct __is_static_castable
+    : public integral_constant<bool, (__is_static_castable_safe<
+				      _From, _To>::value)>
+    { };
+
+  // Implementation for non-reference types. To meet the proper
+  // variable definition semantics, we also need to test for
+  // is_destructible in this case.
+  // This form should be simplified by a single expression:
+  // ::delete ::new _Tp(declval<_Arg>()), see c++/51222.
+  struct __do_is_direct_constructible_impl
+  {
+    template<typename _Tp, typename _Arg, typename
+	     = decltype(::new _Tp(declval<_Arg>()))>
+      static true_type __test(int);
+
+    template<typename, typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_impl
+    : public __do_is_direct_constructible_impl
+    {
+      typedef decltype(__test<_Tp, _Arg>(0)) type;
+    };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_new_safe
+    : public __and_<is_destructible<_Tp>,
+                    __is_direct_constructible_impl<_Tp, _Arg>>::type
+    { };
+
+  template<typename, typename>
+    struct is_same;
+
+  template<typename, typename>
+    struct is_base_of;
+
+  template<typename>
+    struct remove_reference;
+
+  template<typename _From, typename _To, bool
+           = __not_<__or_<is_void<_From>, 
+                          is_function<_From>>>::value>
+    struct __is_base_to_derived_ref;
+
+  // Detect whether we have a downcast situation during
+  // reference binding.
+  template<typename _From, typename _To>
+    struct __is_base_to_derived_ref<_From, _To, true>
+    {
+      typedef typename remove_cv<typename remove_reference<_From
+        >::type>::type __src_t;
+      typedef typename remove_cv<typename remove_reference<_To
+        >::type>::type __dst_t;
+      typedef __and_<__not_<is_same<__src_t, __dst_t>>,
+		     is_base_of<__src_t, __dst_t>> type;
+      static constexpr bool value = type::value;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_base_to_derived_ref<_From, _To, false>
+    : public false_type
+    { };
+
+  template<typename _From, typename _To, bool
+           = __and_<is_lvalue_reference<_From>,
+                    is_rvalue_reference<_To>>::value>
+    struct __is_lvalue_to_rvalue_ref;
+
+  // Detect whether we have an lvalue of non-function type
+  // bound to a reference-compatible rvalue-reference.
+  template<typename _From, typename _To>
+    struct __is_lvalue_to_rvalue_ref<_From, _To, true>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _From>::type>::type __src_t;
+      typedef typename remove_cv<typename remove_reference<
+        _To>::type>::type __dst_t;
+      typedef __and_<__not_<is_function<__src_t>>, 
+        __or_<is_same<__src_t, __dst_t>,
+		    is_base_of<__dst_t, __src_t>>> type;
+      static constexpr bool value = type::value;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_lvalue_to_rvalue_ref<_From, _To, false>
+    : public false_type
+    { };
+
+  // Here we handle direct-initialization to a reference type as 
+  // equivalent to a static_cast modulo overshooting conversions.
+  // These are restricted to the following conversions:
+  //    a) A base class value to a derived class reference
+  //    b) An lvalue to an rvalue-reference of reference-compatible 
+  //       types that are not functions
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_ref_cast
+    : public __and_<__is_static_castable<_Arg, _Tp>,
+                    __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
+                                 __is_lvalue_to_rvalue_ref<_Arg, _Tp>
+                   >>>::type
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_new
+    : public conditional<is_reference<_Tp>::value,
+			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
+			 __is_direct_constructible_new_safe<_Tp, _Arg>
+			 >::type
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible
+    : public __is_direct_constructible_new<_Tp, _Arg>::type
+    { };
+
+  // Since default-construction and binary direct-initialization have
+  // been handled separately, the implementation of the remaining
+  // n-ary construction cases is rather straightforward. We can use
+  // here a functional cast, because array types are excluded anyway
+  // and this form is never interpreted as a C cast.
+  struct __do_is_nary_constructible_impl
+  {
+    template<typename _Tp, typename... _Args, typename
+             = decltype(_Tp(declval<_Args>()...))>
+      static true_type __test(int);
+
+    template<typename, typename...>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nary_constructible_impl
+    : public __do_is_nary_constructible_impl
+    {
+      typedef decltype(__test<_Tp, _Args...>(0)) type;
+    };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nary_constructible
+    : public __is_nary_constructible_impl<_Tp, _Args...>::type
+    {
+      static_assert(sizeof...(_Args) > 1,
+                    "Only useful for > 1 arguments");
+    };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_constructible_impl
+    : public __is_nary_constructible<_Tp, _Args...>
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_constructible_impl<_Tp, _Arg>
+    : public __is_direct_constructible<_Tp, _Arg>
+    { };
+
+  template<typename _Tp>
+    struct __is_constructible_impl<_Tp>
+    : public is_default_constructible<_Tp>
+    { };
+
+  /// is_constructible
+  template<typename _Tp, typename... _Args>
+    struct is_constructible
+    : public __is_constructible_impl<_Tp, _Args...>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, true>
+    : public is_constructible<_Tp, const _Tp&>
+    { };
+
+  /// is_copy_constructible
+  template<typename _Tp>
+    struct is_copy_constructible
+    : public __is_copy_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, true>
+    : public is_constructible<_Tp, _Tp&&>
+    { };
+
+  /// is_move_constructible
+  template<typename _Tp>
+    struct is_move_constructible
+    : public __is_move_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_default_constructible_atom
+    : public integral_constant<bool, noexcept(_Tp())>
+    { };
+
+  template<typename _Tp, bool = is_array<_Tp>::value>
+    struct __is_nt_default_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nt_default_constructible_impl<_Tp, true>
+    : public __and_<__is_array_known_bounds<_Tp>,
+		    __is_nt_default_constructible_atom<typename
+                      remove_all_extents<_Tp>::type>>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_default_constructible_impl<_Tp, false>
+    : public __is_nt_default_constructible_atom<_Tp>
+    { };
+
+  /// is_nothrow_default_constructible
+  template<typename _Tp>
+    struct is_nothrow_default_constructible
+    : public __and_<is_default_constructible<_Tp>,
+                    __is_nt_default_constructible_impl<_Tp>>::type
+    { };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl
+    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_nt_constructible_impl<_Tp, _Arg>
+    : public integral_constant<bool,
+                               noexcept(static_cast<_Tp>(declval<_Arg>()))>
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_constructible_impl<_Tp>
+    : public is_nothrow_default_constructible<_Tp>
+    { };
+
+  /// is_nothrow_constructible
+  template<typename _Tp, typename... _Args>
+    struct is_nothrow_constructible
+    : public __and_<is_constructible<_Tp, _Args...>,
+		    __is_nt_constructible_impl<_Tp, _Args...>>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nothrow_copy_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, true>
+    : public is_nothrow_constructible<_Tp, const _Tp&>
+    { };
+
+  /// is_nothrow_copy_constructible
+  template<typename _Tp>
+    struct is_nothrow_copy_constructible
+    : public __is_nothrow_copy_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nothrow_move_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, true>
+    : public is_nothrow_constructible<_Tp, _Tp&&>
+    { };
+
+  /// is_nothrow_move_constructible
+  template<typename _Tp>
+    struct is_nothrow_move_constructible
+    : public __is_nothrow_move_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp, typename _Up>
+    class __is_assignable_helper
+    {
+      template<typename _Tp1, typename _Up1,
+	       typename = decltype(declval<_Tp1>() = declval<_Up1>())>
+	static true_type
+	__test(int);
+
+      template<typename, typename>
+	static false_type
+	__test(...);
+
+    public:
+      typedef decltype(__test<_Tp, _Up>(0)) type;
+    };
+
+  /// is_assignable
+  template<typename _Tp, typename _Up>
+    struct is_assignable
+      : public __is_assignable_helper<_Tp, _Up>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, true>
+    : public is_assignable<_Tp&, const _Tp&>
+    { };
+
+  /// is_copy_assignable
+  template<typename _Tp>
+    struct is_copy_assignable
+    : public __is_copy_assignable_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, true>
+    : public is_assignable<_Tp&, _Tp&&>
+    { };
+
+  /// is_move_assignable
+  template<typename _Tp>
+    struct is_move_assignable
+    : public __is_move_assignable_impl<_Tp>
+    { };
+
+  template<typename _Tp, typename _Up>
+    struct __is_nt_assignable_impl
+    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
+    { };
+
+  /// is_nothrow_assignable
+  template<typename _Tp, typename _Up>
+    struct is_nothrow_assignable
+    : public __and_<is_assignable<_Tp, _Up>,
+		    __is_nt_assignable_impl<_Tp, _Up>>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nt_copy_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, true>
+    : public is_nothrow_assignable<_Tp&, const _Tp&>
+    { };
+
+  /// is_nothrow_copy_assignable
+  template<typename _Tp>
+    struct is_nothrow_copy_assignable
+    : public __is_nt_copy_assignable_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nt_move_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, true>
+    : public is_nothrow_assignable<_Tp&, _Tp&&>
+    { };
+
+  /// is_nothrow_move_assignable
+  template<typename _Tp>
+    struct is_nothrow_move_assignable
+    : public __is_nt_move_assignable_impl<_Tp>
+    { };
+
+  /// is_trivially_constructible (still unimplemented)
+  
+  /// is_trivially_default_constructible (still unimplemented)
+
+  /// is_trivially_copy_constructible (still unimplemented)
+
+  /// is_trivially_move_constructible (still unimplemented)
+
+  /// is_trivially_assignable (still unimplemented)
+
+  /// is_trivially_copy_assignable (still unimplemented)
+
+  /// is_trivially_move_assignable (still unimplemented)
+
+  /// is_trivially_destructible
+  template<typename _Tp>
+    struct is_trivially_destructible
+    : public __and_<is_destructible<_Tp>, integral_constant<bool,
+			      __has_trivial_destructor(_Tp)>>::type
+    { };
+
+  /// has_trivial_default_constructor (temporary legacy)
+  template<typename _Tp>
+    struct has_trivial_default_constructor
+    : public integral_constant<bool, __has_trivial_constructor(_Tp)>
+    { };
+
+  /// has_trivial_copy_constructor (temporary legacy)
+  template<typename _Tp>
+    struct has_trivial_copy_constructor
+    : public integral_constant<bool, __has_trivial_copy(_Tp)>
+    { };
+
+  /// has_trivial_copy_assign (temporary legacy)
+  template<typename _Tp>
+    struct has_trivial_copy_assign
+    : public integral_constant<bool, __has_trivial_assign(_Tp)>
+    { };
+
+  /// has_virtual_destructor
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    { };
+
+  
+  // type property queries.
+
+  /// alignment_of
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
+  
+  /// rank
+  template<typename>
+    struct rank
+    : public integral_constant<std::size_t, 0> { };
+   
+  template<typename _Tp, std::size_t _Size>
+    struct rank<_Tp[_Size]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct rank<_Tp[]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  /// extent
+  template<typename, unsigned _Uint>
+    struct extent
+    : public integral_constant<std::size_t, 0> { };
+  
+  template<typename _Tp, unsigned _Uint, std::size_t _Size>
+    struct extent<_Tp[_Size], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? _Size : extent<_Tp,
+							   _Uint - 1>::value>
+    { };
+
+  template<typename _Tp, unsigned _Uint>
+    struct extent<_Tp[], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? 0 : extent<_Tp,
+						       _Uint - 1>::value>
+    { };
+
+
+  // Type relations.
+
+  /// is_same
+  template<typename, typename>
+    struct is_same
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_same<_Tp, _Tp>
+    : public true_type { };
+
+  /// is_base_of
+  template<typename _Base, typename _Derived>
+    struct is_base_of
+    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
+    { };
+
+  template<typename _From, typename _To,
+           bool = __or_<is_void<_From>, is_function<_To>,
+                        is_array<_To>>::value>
+    struct __is_convertible_helper
+    { typedef typename is_void<_To>::type type; };
+
+  template<typename _From, typename _To>
+    class __is_convertible_helper<_From, _To, false>
+    {
+       template<typename _To1>
+	static void __test_aux(_To1);
+
+      template<typename _From1, typename _To1,
+	       typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
+	static true_type
+	__test(int);
+
+      template<typename, typename>
+	static false_type
+	__test(...);
+
+    public:
+      typedef decltype(__test<_From, _To>(0)) type;
+    };
+
+
+  /// is_convertible
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public __is_convertible_helper<_From, _To>::type
+    { };
+
+
+  // Const-volatile modifications.
+
+  /// remove_const
+  template<typename _Tp>
+    struct remove_const
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_const<_Tp const>
+    { typedef _Tp     type; };
+  
+  /// remove_volatile
+  template<typename _Tp>
+    struct remove_volatile
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_volatile<_Tp volatile>
+    { typedef _Tp     type; };
+  
+  /// remove_cv
+  template<typename _Tp>
+    struct remove_cv
+    {
+      typedef typename
+      remove_const<typename remove_volatile<_Tp>::type>::type     type;
+    };
+  
+  /// add_const
+  template<typename _Tp>
+    struct add_const
+    { typedef _Tp const     type; };
+   
+  /// add_volatile
+  template<typename _Tp>
+    struct add_volatile
+    { typedef _Tp volatile     type; };
+  
+  /// add_cv
+  template<typename _Tp>
+    struct add_cv
+    {
+      typedef typename
+      add_const<typename add_volatile<_Tp>::type>::type     type;
+    };
+
+#if __cplusplus > 201103L
+  /// Alias template for remove_const
+  template<typename _Tp>
+    using remove_const_t = typename remove_const<_Tp>::type;
+
+  /// Alias template for remove_volatile
+  template<typename _Tp>
+    using remove_volatile_t = typename remove_volatile<_Tp>::type;
+
+  /// Alias template for remove_cv
+  template<typename _Tp>
+    using remove_cv_t = typename remove_cv<_Tp>::type;
+
+  /// Alias template for add_const
+  template<typename _Tp>
+    using add_const_t = typename add_const<_Tp>::type;
+
+  /// Alias template for add_volatile
+  template<typename _Tp>
+    using add_volatile_t = typename add_volatile<_Tp>::type;
+
+  /// Alias template for add_cv
+  template<typename _Tp>
+    using add_cv_t = typename add_cv<_Tp>::type;
+#endif
+
+  // Reference transformations.
+
+  /// remove_reference
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&&>
+    { typedef _Tp   type; };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __add_lvalue_reference_helper
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct __add_lvalue_reference_helper<_Tp, true>
+    { typedef _Tp&   type; };
+
+  /// add_lvalue_reference
+  template<typename _Tp>
+    struct add_lvalue_reference
+    : public __add_lvalue_reference_helper<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __add_rvalue_reference_helper
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct __add_rvalue_reference_helper<_Tp, true>
+    { typedef _Tp&&   type; };
+
+  /// add_rvalue_reference
+  template<typename _Tp>
+    struct add_rvalue_reference
+    : public __add_rvalue_reference_helper<_Tp>
+    { };
+
+#if __cplusplus > 201103L
+  /// Alias template for remove_reference
+  template<typename _Tp>
+    using remove_reference_t = typename remove_reference<_Tp>::type;
+
+  /// Alias template for add_lvalue_reference
+  template<typename _Tp>
+    using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
+
+  /// Alias template for add_rvalue_reference
+  template<typename _Tp>
+    using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
+#endif
+
+  // Sign modifications.
+
+  // Utility for constructing identically cv-qualified types.
+  template<typename _Unqualified, bool _IsConst, bool _IsVol>
+    struct __cv_selector;
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, false, false>
+    { typedef _Unqualified __type; };
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, false, true>
+    { typedef volatile _Unqualified __type; };
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, true, false>
+    { typedef const _Unqualified __type; };
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, true, true>
+    { typedef const volatile _Unqualified __type; };
+
+  template<typename _Qualified, typename _Unqualified,
+	   bool _IsConst = is_const<_Qualified>::value,
+	   bool _IsVol = is_volatile<_Qualified>::value>
+    class __match_cv_qualifiers
+    {
+      typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
+
+    public:
+      typedef typename __match::__type __type; 
+    };
+
+  // Utility for finding the unsigned versions of signed integral types.
+  template<typename _Tp>
+    struct __make_unsigned
+    { typedef _Tp __type; };
+
+  template<>
+    struct __make_unsigned<char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __make_unsigned<signed char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __make_unsigned<short>
+    { typedef unsigned short __type; };
+
+  template<>
+    struct __make_unsigned<int>
+    { typedef unsigned int __type; };
+
+  template<>
+    struct __make_unsigned<long>
+    { typedef unsigned long __type; };
+
+  template<>
+    struct __make_unsigned<long long>
+    { typedef unsigned long long __type; };
+
+#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
+  template<>
+    struct __make_unsigned<__int128>
+    { typedef unsigned __int128 __type; };
+#endif
+
+  // Select between integral and enum: not possible to be both.
+  template<typename _Tp, 
+	   bool _IsInt = is_integral<_Tp>::value,
+	   bool _IsEnum = is_enum<_Tp>::value>
+    class __make_unsigned_selector;
+
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, true, false>
+    {
+      typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
+      typedef typename __unsignedt::__type __unsigned_type;
+      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
+
+    public:
+      typedef typename __cv_unsigned::__type __type;
+    };
+
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, false, true>
+    {
+      // With -fshort-enums, an enum may be as small as a char.
+      typedef unsigned char __smallest;
+      static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
+      static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
+      static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
+      typedef conditional<__b2, unsigned int, unsigned long> __cond2;
+      typedef typename __cond2::type __cond2_type;
+      typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
+      typedef typename __cond1::type __cond1_type;
+
+    public:
+      typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
+    };
+
+  // Given an integral/enum type, return the corresponding unsigned
+  // integer type.
+  // Primary template.
+  /// make_unsigned
+  template<typename _Tp>
+    struct make_unsigned 
+    { typedef typename __make_unsigned_selector<_Tp>::__type type; };
+
+  // Integral, but don't define.
+  template<>
+    struct make_unsigned<bool>;
+
+
+  // Utility for finding the signed versions of unsigned integral types.
+  template<typename _Tp>
+    struct __make_signed
+    { typedef _Tp __type; };
+
+  template<>
+    struct __make_signed<char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __make_signed<unsigned char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __make_signed<unsigned short>
+    { typedef signed short __type; };
+
+  template<>
+    struct __make_signed<unsigned int>
+    { typedef signed int __type; };
+
+  template<>
+    struct __make_signed<unsigned long>
+    { typedef signed long __type; };
+
+  template<>
+    struct __make_signed<unsigned long long>
+    { typedef signed long long __type; };
+
+#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
+  template<>
+    struct __make_signed<unsigned __int128>
+    { typedef __int128 __type; };
+#endif
+
+  // Select between integral and enum: not possible to be both.
+  template<typename _Tp, 
+	   bool _IsInt = is_integral<_Tp>::value,
+	   bool _IsEnum = is_enum<_Tp>::value>
+    class __make_signed_selector;
+
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, true, false>
+    {
+      typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
+      typedef typename __signedt::__type __signed_type;
+      typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
+
+    public:
+      typedef typename __cv_signed::__type __type;
+    };
+
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, false, true>
+    {
+      // With -fshort-enums, an enum may be as small as a char.
+      typedef signed char __smallest;
+      static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
+      static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
+      static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
+      typedef conditional<__b2, signed int, signed long> __cond2;
+      typedef typename __cond2::type __cond2_type;
+      typedef conditional<__b1, signed short, __cond2_type> __cond1;
+      typedef typename __cond1::type __cond1_type;
+
+    public:
+      typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
+    };
+
+  // Given an integral/enum type, return the corresponding signed
+  // integer type.
+  // Primary template.
+  /// make_signed
+  template<typename _Tp>
+    struct make_signed 
+    { typedef typename __make_signed_selector<_Tp>::__type type; };
+
+  // Integral, but don't define.
+  template<>
+    struct make_signed<bool>;
+
+#if __cplusplus > 201103L
+  /// Alias template for make_signed
+  template<typename _Tp>
+    using make_signed_t = typename make_signed<_Tp>::type;
+
+  /// Alias template for make_unsigned
+  template<typename _Tp>
+    using make_unsigned_t = typename make_unsigned<_Tp>::type;
+#endif
+
+  // Array modifications.
+
+  /// remove_extent
+  template<typename _Tp>
+    struct remove_extent
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_extent<_Tp[_Size]>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_extent<_Tp[]>
+    { typedef _Tp     type; };
+
+  /// remove_all_extents
+  template<typename _Tp>
+    struct remove_all_extents
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_all_extents<_Tp[_Size]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+  template<typename _Tp>
+    struct remove_all_extents<_Tp[]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+#if __cplusplus > 201103L
+  /// Alias template for remove_extent
+  template<typename _Tp>
+    using remove_extent_t = typename remove_extent<_Tp>::type;
+
+  /// Alias template for remove_all_extents
+  template<typename _Tp>
+    using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
+#endif
+
+  // Pointer modifications.
+
+  template<typename _Tp, typename>
+    struct __remove_pointer_helper
+    { typedef _Tp     type; };
+
+  template<typename _Tp, typename _Up>
+    struct __remove_pointer_helper<_Tp, _Up*>
+    { typedef _Up     type; };
+
+  /// remove_pointer
+  template<typename _Tp>
+    struct remove_pointer
+    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
+    { };
+
+  /// add_pointer
+  template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
+				      is_void<_Tp>>::value>
+    struct __add_pointer_helper
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct __add_pointer_helper<_Tp, true>
+    { typedef typename remove_reference<_Tp>::type*     type; };
+
+  template<typename _Tp>
+    struct add_pointer 
+    : public __add_pointer_helper<_Tp>
+    { };
+
+#if __cplusplus > 201103L
+  /// Alias template for remove_pointer
+  template<typename _Tp>
+    using remove_pointer_t = typename remove_pointer<_Tp>::type;
+
+  /// Alias template for add_pointer
+  template<typename _Tp>
+    using add_pointer_t = typename add_pointer<_Tp>::type;
+#endif
+
+  template<std::size_t _Len>
+    struct __aligned_storage_msa
+    { 
+      union __type
+      {
+	unsigned char __data[_Len];
+	struct __attribute__((__aligned__)) { } __align; 
+      };
+    };
+
+  /**
+   *  @brief Alignment type.
+   *
+   *  The value of _Align is a default-alignment which shall be the
+   *  most stringent alignment requirement for any C++ object type
+   *  whose size is no greater than _Len (3.9). The member typedef
+   *  type shall be a POD type suitable for use as uninitialized
+   *  storage for any object whose size is at most _Len and whose
+   *  alignment is a divisor of _Align.
+  */
+  template<std::size_t _Len, std::size_t _Align =
+	   __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    struct aligned_storage
+    { 
+      union type
+      {
+	unsigned char __data[_Len];
+	struct __attribute__((__aligned__((_Align)))) { } __align; 
+      };
+    };
+
+
+  // Decay trait for arrays and functions, used for perfect forwarding
+  // in make_pair, make_tuple, etc.
+  template<typename _Up, 
+	   bool _IsArray = is_array<_Up>::value,
+	   bool _IsFunction = is_function<_Up>::value> 
+    struct __decay_selector;
+
+  // NB: DR 705.
+  template<typename _Up> 
+    struct __decay_selector<_Up, false, false>
+    { typedef typename remove_cv<_Up>::type __type; };
+
+  template<typename _Up> 
+    struct __decay_selector<_Up, true, false>
+    { typedef typename remove_extent<_Up>::type* __type; };
+
+  template<typename _Up> 
+    struct __decay_selector<_Up, false, true>
+    { typedef typename add_pointer<_Up>::type __type; };
+
+  /// decay
+  template<typename _Tp> 
+    class decay 
+    { 
+      typedef typename remove_reference<_Tp>::type __remove_type;
+
+    public:
+      typedef typename __decay_selector<__remove_type>::__type type;
+    };
+
+  template<typename _Tp>
+    class reference_wrapper;
+
+  // Helper which adds a reference to a type when given a reference_wrapper
+  template<typename _Tp>
+    struct __strip_reference_wrapper
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename _Tp>
+    struct __decay_and_strip
+    {
+      typedef typename __strip_reference_wrapper<
+	typename decay<_Tp>::type>::__type __type;
+    };
+
+
+  // Primary template.
+  /// Define a member typedef @c type only if a boolean constant is true.
+  template<bool, typename _Tp = void>
+    struct enable_if 
+    { };
+
+  // Partial specialization for true.
+  template<typename _Tp>
+    struct enable_if<true, _Tp>
+    { typedef _Tp type; };
+
+  template<typename... _Cond>
+    using _Require = typename enable_if<__and_<_Cond...>::value>::type;
+
+  // Primary template.
+  /// Define a member typedef @c type to one of two argument types.
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct conditional
+    { typedef _Iftrue type; };
+
+  // Partial specialization for false.
+  template<typename _Iftrue, typename _Iffalse>
+    struct conditional<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse type; };
+
+  /// common_type
+  template<typename... _Tp>
+    struct common_type;
+
+  // Sfinae-friendly common_type implementation:
+
+  struct __do_common_type_impl
+  {
+    template<typename _Tp, typename _Up>
+      static __success_type<typename decay<decltype
+			    (true ? std::declval<_Tp>()
+			     : std::declval<_Up>())>::type> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Tp, typename _Up>
+    struct __common_type_impl
+    : private __do_common_type_impl
+    {
+      typedef decltype(_S_test<_Tp, _Up>(0)) type;
+    };
+
+  struct __do_member_type_wrapper
+  {
+    template<typename _Tp>
+      static __success_type<typename _Tp::type> _S_test(int);
+
+    template<typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Tp>
+    struct __member_type_wrapper
+    : private __do_member_type_wrapper
+    {
+      typedef decltype(_S_test<_Tp>(0)) type;
+    };
+
+  template<typename _CTp, typename... _Args>
+    struct __expanded_common_type_wrapper
+    {
+      typedef common_type<typename _CTp::type, _Args...> type;
+    };
+
+  template<typename... _Args>
+    struct __expanded_common_type_wrapper<__failure_type, _Args...>
+    { typedef __failure_type type; };
+
+  template<typename _Tp>
+    struct common_type<_Tp>
+    { typedef typename decay<_Tp>::type type; };
+
+  template<typename _Tp, typename _Up>
+    struct common_type<_Tp, _Up>
+    : public __common_type_impl<_Tp, _Up>::type
+    { };
+
+  template<typename _Tp, typename _Up, typename... _Vp>
+    struct common_type<_Tp, _Up, _Vp...>
+    : public __expanded_common_type_wrapper<typename __member_type_wrapper<
+               common_type<_Tp, _Up>>::type, _Vp...>::type
+    { };
+
+  /// The underlying type of an enum.
+  template<typename _Tp>
+    struct underlying_type
+    {
+      typedef __underlying_type(_Tp) type;
+    };
+
+  template<typename _Tp>
+    struct __declval_protector
+    {
+      static const bool __stop = false;
+      static typename add_rvalue_reference<_Tp>::type __delegate();
+    };
+
+  template<typename _Tp>
+    inline typename add_rvalue_reference<_Tp>::type
+    declval() noexcept
+    {
+      static_assert(__declval_protector<_Tp>::__stop,
+		    "declval() must not be used!");
+      return __declval_protector<_Tp>::__delegate();
+    }
+
+  /// result_of
+  template<typename _Signature>
+    class result_of;
+
+  // Sfinae-friendly result_of implementation:
+
+  // [func.require] paragraph 1 bullet 1:
+  struct __result_of_memfun_ref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __success_type<decltype(
+      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
+      )> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_ref
+    : private __result_of_memfun_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+
+  // [func.require] paragraph 1 bullet 2:
+  struct __result_of_memfun_deref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __success_type<decltype(
+      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
+      )> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_deref
+    : private __result_of_memfun_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+
+  // [func.require] paragraph 1 bullet 3:
+  struct __result_of_memobj_ref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __success_type<decltype(
+      std::declval<_Tp1>().*std::declval<_Fp>()
+      )> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_ref
+    : private __result_of_memobj_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+
+  // [func.require] paragraph 1 bullet 4:
+  struct __result_of_memobj_deref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __success_type<decltype(
+      (*std::declval<_Tp1>()).*std::declval<_Fp>()
+      )> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_deref
+    : private __result_of_memobj_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj;
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, _Arg>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memobj_ref<_MemPtr, _Arg>,
+        __result_of_memobj_deref<_MemPtr, _Arg>
+      >::type::type type;
+    };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun;
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
+        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
+      >::type::type type;
+    };
+
+  template<bool, bool, typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl
+    {
+      typedef __failure_type type;
+    };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_impl<true, false, _MemPtr, _Arg>
+    : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
+    { };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
+    : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
+    { };
+
+  // [func.require] paragraph 1 bullet 5:
+  struct __result_of_other_impl
+  {
+    template<typename _Fn, typename... _Args>
+      static __success_type<decltype(
+      std::declval<_Fn>()(std::declval<_Args>()...)
+      )> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl<false, false, _Functor, _ArgTypes...>
+    : private __result_of_other_impl
+    {
+      typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct result_of<_Functor(_ArgTypes...)>
+    : public __result_of_impl<
+        is_member_object_pointer<
+          typename remove_reference<_Functor>::type
+        >::value,
+        is_member_function_pointer<
+          typename remove_reference<_Functor>::type
+        >::value,
+	    _Functor, _ArgTypes...
+      >::type
+    { };
+
+#if __cplusplus > 201103L
+  /// Alias template for aligned_storage
+  template<size_t _Len, size_t _Align =
+	    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
+
+  /// Alias template for decay
+  template<typename _Tp>
+    using decay_t = typename decay<_Tp>::type;
+
+  /// Alias template for enable_if
+  template<bool _Cond, typename _Tp = void>
+    using enable_if_t = typename enable_if<_Cond, _Tp>::type;
+
+  /// Alias template for conditional
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
+
+  /// Alias template for common_type
+  template<typename... _Tp>
+    using common_type_t = typename common_type<_Tp...>::type;
+
+  /// Alias template for underlying_type
+  template<typename _Tp>
+    using underlying_type_t = typename underlying_type<_Tp>::type;
+
+  /// Alias template for result_of
+  template<typename _Tp>
+    using result_of_t = typename result_of<_Tp>::type;
+#endif
+
+  /// @} group metaprogramming
+	
+  /**
+   *  Use SFINAE to determine if the type _Tp has a publicly-accessible
+   *  member type _NTYPE.
+   */
+#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE)				\
+  template<typename _Tp>						\
+    class __has_##_NTYPE##_helper					\
+    {									\
+      template<typename _Up>						\
+	struct _Wrap_type						\
+	{ };								\
+									\
+      template<typename _Up>						\
+	static true_type __test(_Wrap_type<typename _Up::_NTYPE>*);	\
+									\
+      template<typename _Up>						\
+	static false_type __test(...);					\
+									\
+    public:								\
+      typedef decltype(__test<_Tp>(0)) type;				\
+    };									\
+									\
+  template<typename _Tp>						\
+    struct __has_##_NTYPE						\
+    : public __has_##_NTYPE##_helper					\
+			<typename remove_cv<_Tp>::type>::type		\
+    { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif  // C++11
+
+#endif  // _GLIBCXX_TYPE_TRAITS
diff --git a/gcc-4.9/libstdc++-v3/include/std/typeindex b/gcc-4.9/libstdc++-v3/include/std/typeindex
new file mode 100644
index 0000000..c158feb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/typeindex
@@ -0,0 +1,112 @@
+// C++11 <typeindex> -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/typeindex
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TYPEINDEX
+#define _GLIBCXX_TYPEINDEX 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <typeinfo>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @brief Class type_index
+   * @ingroup utilities
+   *
+   *  The class type_index provides a simple wrapper for type_info
+   *  which can be used as an index type in associative containers
+   *  (23.6) and in unordered associative containers (23.7).
+   */
+  struct type_index
+  {
+    type_index(const type_info& __rhs) noexcept
+    : _M_target(&__rhs) { }
+
+    bool
+    operator==(const type_index& __rhs) const noexcept
+    { return *_M_target == *__rhs._M_target; }
+
+    bool
+    operator!=(const type_index& __rhs) const noexcept
+    { return *_M_target != *__rhs._M_target; }
+
+    bool
+    operator<(const type_index& __rhs) const noexcept
+    { return _M_target->before(*__rhs._M_target); }
+
+    bool
+    operator<=(const type_index& __rhs) const noexcept
+    { return !__rhs._M_target->before(*_M_target); }
+
+    bool
+    operator>(const type_index& __rhs) const noexcept
+    { return __rhs._M_target->before(*_M_target); }
+
+    bool
+    operator>=(const type_index& __rhs) const noexcept
+    { return !_M_target->before(*__rhs._M_target); }
+
+    size_t
+    hash_code() const noexcept
+    { return _M_target->hash_code(); }
+
+    const char*
+    name() const noexcept
+    { return _M_target->name(); }
+
+  private:
+    const type_info* _M_target;
+  };
+
+  template<typename _Tp> struct hash;
+
+  /// std::hash specialization for type_index.
+  template<>
+    struct hash<type_index>
+    {
+      typedef size_t        result_type;
+      typedef type_index  argument_type;
+
+      size_t
+      operator()(const type_index& __ti) const noexcept
+      { return __ti.hash_code(); }
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif  // C++11
+
+#endif  // _GLIBCXX_TYPEINDEX
diff --git a/gcc-4.9/libstdc++-v3/include/std/unordered_map b/gcc-4.9/libstdc++-v3/include/std/unordered_map
new file mode 100644
index 0000000..32da303
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/unordered_map
@@ -0,0 +1,61 @@
+// <unordered_map> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/unordered_map
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_UNORDERED_MAP
+#define _GLIBCXX_UNORDERED_MAP 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <utility>
+#include <type_traits>
+#include <initializer_list>
+#include <tuple>
+#include <bits/allocator.h>
+#include <ext/alloc_traits.h>
+#include <ext/aligned_buffer.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <bits/functional_hash.h>
+#include <bits/hashtable.h>
+#include <bits/unordered_map.h>
+#include <bits/range_access.h>
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/unordered_map>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/unordered_map>
+#endif
+
+#endif // C++11
+
+#endif // _GLIBCXX_UNORDERED_MAP
diff --git a/gcc-4.9/libstdc++-v3/include/std/unordered_set b/gcc-4.9/libstdc++-v3/include/std/unordered_set
new file mode 100644
index 0000000..da55f2c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/unordered_set
@@ -0,0 +1,60 @@
+// <unordered_set> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/unordered_set
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_UNORDERED_SET
+#define _GLIBCXX_UNORDERED_SET 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <utility>
+#include <type_traits>
+#include <initializer_list>
+#include <tuple>
+#include <bits/allocator.h>
+#include <ext/alloc_traits.h>
+#include <ext/aligned_buffer.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <bits/functional_hash.h>
+#include <bits/hashtable.h>
+#include <bits/unordered_set.h>
+#include <bits/range_access.h>
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/unordered_set>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/unordered_set>
+#endif
+#endif // C++11
+
+#endif // _GLIBCXX_UNORDERED_SET
diff --git a/gcc-4.9/libstdc++-v3/include/std/utility b/gcc-4.9/libstdc++-v3/include/std/utility
new file mode 100644
index 0000000..4da9209
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/utility
@@ -0,0 +1,263 @@
+// <utility> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/utility
+ *  This is a Standard C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_UTILITY
+#define _GLIBCXX_UTILITY 1
+
+#pragma GCC system_header
+
+/**
+ * @defgroup utilities Utilities
+ *
+ * Components deemed generally useful. Includes pair, tuple,
+ * forward/move helpers, ratio, function object, metaprogramming and
+ * type traits, time, date, and memory functions.
+ */
+
+#include <bits/c++config.h>
+#include <bits/stl_relops.h>
+#include <bits/stl_pair.h>
+
+#if __cplusplus >= 201103L
+#include <bits/move.h>
+#include <initializer_list>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<class _Tp>
+    class tuple_size;
+
+  template<std::size_t _Int, class _Tp>
+    class tuple_element;
+
+   // Various functions which give std::pair a tuple-like interface.
+  template<class _Tp1, class _Tp2>
+    struct tuple_size<std::pair<_Tp1, _Tp2>>
+    : public integral_constant<std::size_t, 2> { };
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<0, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp1 type; };
+ 
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<1, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp2 type; };
+
+  template<std::size_t _Int>
+    struct __pair_get;
+
+  template<>
+    struct __pair_get<0>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp1>(__pair.first); }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp1&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+    };
+
+  template<>
+    struct __pair_get<1>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp2>(__pair.second); }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp2&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+    };
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__get(__in); }
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
+    get(std::pair<_Tp1, _Tp2>&& __in) noexcept
+    { return __pair_get<_Int>::__move_get(std::move(__in)); }
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(const std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__const_get(__in); }
+
+#if __cplusplus > 201103L
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Tp, _Up>&& __p) noexcept
+    { return std::move(__p.first); }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Up, _Tp>&& __p) noexcept
+    { return std::move(__p.second); }
+
+  /// Assign @p __new_val to @p __obj and return its previous value.
+  template <typename _Tp, typename _Up = _Tp>
+    inline _Tp
+    exchange(_Tp& __obj, _Up&& __new_val)
+    {
+      _Tp __old_val = std::move(__obj);
+      __obj = std::forward<_Up>(__new_val);
+      return __old_val;
+    }
+#endif
+
+  // Stores a tuple of indices.  Used by tuple and pair, and by bind() to
+  // extract the elements in a tuple.
+  template<size_t... _Indexes>
+    struct _Index_tuple
+    {
+      typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
+    };
+
+  // Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
+  template<size_t _Num>
+    struct _Build_index_tuple
+    {
+      typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
+    };
+
+  template<>
+    struct _Build_index_tuple<0>
+    {
+      typedef _Index_tuple<> __type;
+    };
+
+#if __cplusplus > 201103L
+  /// Class template integer_sequence
+  template<typename _Tp, _Tp... _Idx>
+    struct integer_sequence
+    {
+      typedef _Tp value_type;
+      static constexpr size_t size() { return sizeof...(_Idx); }
+    };
+
+  template<typename _Tp, _Tp _Num,
+	   typename _ISeq = typename _Build_index_tuple<_Num>::__type>
+    struct _Make_integer_sequence;
+
+  template<typename _Tp, _Tp _Num,  size_t... _Idx>
+    struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
+    {
+      static_assert( _Num >= 0,
+		     "Cannot make integer sequence of negative length" );
+
+      typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
+    };
+
+  /// Alias template make_integer_sequence
+  template<typename _Tp, _Tp _Num>
+    using make_integer_sequence
+      = typename _Make_integer_sequence<_Tp, _Num>::__type;
+
+  /// Alias template index_sequence
+  template<size_t... _Idx>
+    using index_sequence = integer_sequence<size_t, _Idx...>;
+
+  /// Alias template make_index_sequence
+  template<size_t _Num>
+    using make_index_sequence = make_integer_sequence<size_t, _Num>;
+
+  /// Alias template index_sequence_for
+  template<typename... _Types>
+    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif
+
+#endif /* _GLIBCXX_UTILITY */
diff --git a/gcc-4.9/libstdc++-v3/include/std/valarray b/gcc-4.9/libstdc++-v3/include/std/valarray
new file mode 100644
index 0000000..e0d48dc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/valarray
@@ -0,0 +1,1235 @@
+// The template and inlines for the -*- C++ -*- valarray class.
+
+// Copyright (C) 1997-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/valarray
+ *  This is a Standard C++ Library header. 
+ */
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _GLIBCXX_VALARRAY
+#define _GLIBCXX_VALARRAY 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <cmath>
+#include <algorithm>
+#include <debug/debug.h>
+#if __cplusplus >= 201103L
+#include <initializer_list>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<class _Clos, typename _Tp> 
+    class _Expr;
+
+  template<typename _Tp1, typename _Tp2> 
+    class _ValArray;    
+
+  template<class _Oper, template<class, class> class _Meta, class _Dom>
+    struct _UnClos;
+
+  template<class _Oper,
+        template<class, class> class _Meta1,
+        template<class, class> class _Meta2,
+        class _Dom1, class _Dom2> 
+    class _BinClos;
+
+  template<template<class, class> class _Meta, class _Dom> 
+    class _SClos;
+
+  template<template<class, class> class _Meta, class _Dom> 
+    class _GClos;
+    
+  template<template<class, class> class _Meta, class _Dom> 
+    class _IClos;
+    
+  template<template<class, class> class _Meta, class _Dom> 
+    class _ValFunClos;
+  
+  template<template<class, class> class _Meta, class _Dom> 
+    class _RefFunClos;
+
+  template<class _Tp> class valarray;   // An array of type _Tp
+  class slice;                          // BLAS-like slice out of an array
+  template<class _Tp> class slice_array;
+  class gslice;                         // generalized slice out of an array
+  template<class _Tp> class gslice_array;
+  template<class _Tp> class mask_array;     // masked array
+  template<class _Tp> class indirect_array; // indirected array
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/valarray_array.h>
+#include <bits/valarray_before.h>
+  
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup numeric_arrays Numeric Arrays
+   * @ingroup numerics
+   *
+   * Classes and functions for representing and manipulating arrays of elements.
+   * @{
+   */
+
+  /**
+   *  @brief  Smart array designed to support numeric processing.
+   *
+   *  A valarray is an array that provides constraints intended to allow for
+   *  effective optimization of numeric array processing by reducing the
+   *  aliasing that can result from pointer representations.  It represents a
+   *  one-dimensional array from which different multidimensional subsets can
+   *  be accessed and modified.
+   *  
+   *  @tparam  _Tp  Type of object in the array.
+   */
+  template<class _Tp> 
+    class valarray
+    {
+      template<class _Op>
+	struct _UnaryOp 
+	{
+	  typedef typename __fun<_Op, _Tp>::result_type __rt;
+	  typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
+	};
+    public:
+      typedef _Tp value_type;
+      
+	// _lib.valarray.cons_ construct/destroy:
+      ///  Construct an empty array.
+      valarray();
+
+      ///  Construct an array with @a n elements.
+      explicit valarray(size_t);
+
+      ///  Construct an array with @a n elements initialized to @a t.
+      valarray(const _Tp&, size_t);
+
+      ///  Construct an array initialized to the first @a n elements of @a t.
+      valarray(const _Tp* __restrict__, size_t);
+
+      ///  Copy constructor.
+      valarray(const valarray&);
+
+#if __cplusplus >= 201103L
+      ///  Move constructor.
+      valarray(valarray&&) noexcept;
+#endif
+
+      ///  Construct an array with the same size and values in @a sa.
+      valarray(const slice_array<_Tp>&);
+
+      ///  Construct an array with the same size and values in @a ga.
+      valarray(const gslice_array<_Tp>&);
+
+      ///  Construct an array with the same size and values in @a ma.
+      valarray(const mask_array<_Tp>&);
+
+      ///  Construct an array with the same size and values in @a ia.
+      valarray(const indirect_array<_Tp>&);
+
+#if __cplusplus >= 201103L
+      ///  Construct an array with an initializer_list of values.
+      valarray(initializer_list<_Tp>);
+#endif
+
+      template<class _Dom>
+	valarray(const _Expr<_Dom, _Tp>& __e);
+
+      ~valarray() _GLIBCXX_NOEXCEPT;
+
+      // _lib.valarray.assign_ assignment:
+      /**
+       *  @brief  Assign elements to an array.
+       *
+       *  Assign elements of array to values in @a v.
+       *
+       *  @param  __v  Valarray to get values from.
+       */
+      valarray<_Tp>& operator=(const valarray<_Tp>& __v);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Move assign elements to an array.
+       *
+       *  Move assign elements of array to values in @a v.
+       *
+       *  @param  __v  Valarray to get values from.
+       */
+      valarray<_Tp>& operator=(valarray<_Tp>&& __v) noexcept;
+#endif
+
+      /**
+       *  @brief  Assign elements to a value.
+       *
+       *  Assign all elements of array to @a t.
+       *
+       *  @param  __t  Value for elements.
+       */
+      valarray<_Tp>& operator=(const _Tp& __t);
+
+      /**
+       *  @brief  Assign elements to an array subset.
+       *
+       *  Assign elements of array to values in @a sa.  Results are undefined
+       *  if @a sa does not have the same size as this array.
+       *
+       *  @param  __sa  Array slice to get values from.
+       */
+      valarray<_Tp>& operator=(const slice_array<_Tp>& __sa);
+
+      /**
+       *  @brief  Assign elements to an array subset.
+       *
+       *  Assign elements of array to values in @a ga.  Results are undefined
+       *  if @a ga does not have the same size as this array.
+       *
+       *  @param  __ga  Array slice to get values from.
+       */
+      valarray<_Tp>& operator=(const gslice_array<_Tp>& __ga);
+
+      /**
+       *  @brief  Assign elements to an array subset.
+       *
+       *  Assign elements of array to values in @a ma.  Results are undefined
+       *  if @a ma does not have the same size as this array.
+       *
+       *  @param  __ma  Array slice to get values from.
+       */
+      valarray<_Tp>& operator=(const mask_array<_Tp>& __ma);
+
+      /**
+       *  @brief  Assign elements to an array subset.
+       *
+       *  Assign elements of array to values in @a ia.  Results are undefined
+       *  if @a ia does not have the same size as this array.
+       *
+       *  @param  __ia  Array slice to get values from.
+       */
+      valarray<_Tp>& operator=(const indirect_array<_Tp>& __ia);
+
+#if __cplusplus >= 201103L
+      /**
+       *  @brief  Assign elements to an initializer_list.
+       *
+       *  Assign elements of array to values in @a __l.  Results are undefined
+       *  if @a __l does not have the same size as this array.
+       *
+       *  @param  __l  initializer_list to get values from.
+       */
+      valarray& operator=(initializer_list<_Tp> __l);
+#endif
+
+      template<class _Dom> valarray<_Tp>&
+	operator= (const _Expr<_Dom, _Tp>&);
+
+      // _lib.valarray.access_ element access:
+      /**
+       *  Return a reference to the i'th array element.  
+       *
+       *  @param  __i  Index of element to return.
+       *  @return  Reference to the i'th element.
+       */
+      _Tp&                operator[](size_t __i);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 389. Const overload of valarray::operator[] returns by value.
+      const _Tp&          operator[](size_t) const;
+
+      // _lib.valarray.sub_ subset operations:
+      /**
+       *  @brief  Return an array subset.
+       *
+       *  Returns a new valarray containing the elements of the array
+       *  indicated by the slice argument.  The new valarray has the same size
+       *  as the input slice.  @see slice.
+       *
+       *  @param  __s  The source slice.
+       *  @return  New valarray containing elements in @a __s.
+       */
+      _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice __s) const;
+
+      /**
+       *  @brief  Return a reference to an array subset.
+       *
+       *  Returns a new valarray containing the elements of the array
+       *  indicated by the slice argument.  The new valarray has the same size
+       *  as the input slice.  @see slice.
+       *
+       *  @param  __s  The source slice.
+       *  @return  New valarray containing elements in @a __s.
+       */
+      slice_array<_Tp>    operator[](slice __s);
+
+      /**
+       *  @brief  Return an array subset.
+       *
+       *  Returns a slice_array referencing the elements of the array
+       *  indicated by the slice argument.  @see gslice.
+       *
+       *  @param  __s  The source slice.
+       *  @return  Slice_array referencing elements indicated by @a __s.
+       */
+      _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice& __s) const;
+
+      /**
+       *  @brief  Return a reference to an array subset.
+       *
+       *  Returns a new valarray containing the elements of the array
+       *  indicated by the gslice argument.  The new valarray has
+       *  the same size as the input gslice.  @see gslice.
+       *
+       *  @param  __s  The source gslice.
+       *  @return  New valarray containing elements in @a __s.
+       */
+      gslice_array<_Tp>   operator[](const gslice& __s);
+
+      /**
+       *  @brief  Return an array subset.
+       *
+       *  Returns a new valarray containing the elements of the array
+       *  indicated by the argument.  The input is a valarray of bool which
+       *  represents a bitmask indicating which elements should be copied into
+       *  the new valarray.  Each element of the array is added to the return
+       *  valarray if the corresponding element of the argument is true.
+       *
+       *  @param  __m  The valarray bitmask.
+       *  @return  New valarray containing elements indicated by @a __m.
+       */
+      valarray<_Tp>       operator[](const valarray<bool>& __m) const;
+
+      /**
+       *  @brief  Return a reference to an array subset.
+       *
+       *  Returns a new mask_array referencing the elements of the array
+       *  indicated by the argument.  The input is a valarray of bool which
+       *  represents a bitmask indicating which elements are part of the
+       *  subset.  Elements of the array are part of the subset if the
+       *  corresponding element of the argument is true.
+       *
+       *  @param  __m  The valarray bitmask.
+       *  @return  New valarray containing elements indicated by @a __m.
+       */
+      mask_array<_Tp>     operator[](const valarray<bool>& __m);
+
+      /**
+       *  @brief  Return an array subset.
+       *
+       *  Returns a new valarray containing the elements of the array
+       *  indicated by the argument.  The elements in the argument are
+       *  interpreted as the indices of elements of this valarray to copy to
+       *  the return valarray.
+       *
+       *  @param  __i  The valarray element index list.
+       *  @return  New valarray containing elements in @a __s.
+       */
+      _Expr<_IClos<_ValArray, _Tp>, _Tp>
+        operator[](const valarray<size_t>& __i) const;
+
+      /**
+       *  @brief  Return a reference to an array subset.
+       *
+       *  Returns an indirect_array referencing the elements of the array
+       *  indicated by the argument.  The elements in the argument are
+       *  interpreted as the indices of elements of this valarray to include
+       *  in the subset.  The returned indirect_array refers to these
+       *  elements.
+       *
+       *  @param  __i  The valarray element index list.
+       *  @return  Indirect_array referencing elements in @a __i.
+       */
+      indirect_array<_Tp> operator[](const valarray<size_t>& __i);
+
+      // _lib.valarray.unary_ unary operators:
+      ///  Return a new valarray by applying unary + to each element.
+      typename _UnaryOp<__unary_plus>::_Rt  operator+() const;
+
+      ///  Return a new valarray by applying unary - to each element.
+      typename _UnaryOp<__negate>::_Rt      operator-() const;
+
+      ///  Return a new valarray by applying unary ~ to each element.
+      typename _UnaryOp<__bitwise_not>::_Rt operator~() const;
+
+      ///  Return a new valarray by applying unary ! to each element.
+      typename _UnaryOp<__logical_not>::_Rt operator!() const;
+
+      // _lib.valarray.cassign_ computed assignment:
+      ///  Multiply each element of array by @a t.
+      valarray<_Tp>& operator*=(const _Tp&);
+
+      ///  Divide each element of array by @a t.
+      valarray<_Tp>& operator/=(const _Tp&);
+
+      ///  Set each element e of array to e % @a t.
+      valarray<_Tp>& operator%=(const _Tp&);
+
+      ///  Add @a t to each element of array.
+      valarray<_Tp>& operator+=(const _Tp&);
+
+      ///  Subtract @a t to each element of array.
+      valarray<_Tp>& operator-=(const _Tp&);
+
+      ///  Set each element e of array to e ^ @a t.
+      valarray<_Tp>& operator^=(const _Tp&);
+
+      ///  Set each element e of array to e & @a t.
+      valarray<_Tp>& operator&=(const _Tp&);
+
+      ///  Set each element e of array to e | @a t.
+      valarray<_Tp>& operator|=(const _Tp&);
+
+      ///  Left shift each element e of array by @a t bits.
+      valarray<_Tp>& operator<<=(const _Tp&);
+
+      ///  Right shift each element e of array by @a t bits.
+      valarray<_Tp>& operator>>=(const _Tp&);
+
+      ///  Multiply elements of array by corresponding elements of @a v.
+      valarray<_Tp>& operator*=(const valarray<_Tp>&);
+
+      ///  Divide elements of array by corresponding elements of @a v.
+      valarray<_Tp>& operator/=(const valarray<_Tp>&);
+
+      ///  Modulo elements of array by corresponding elements of @a v.
+      valarray<_Tp>& operator%=(const valarray<_Tp>&);
+
+      ///  Add corresponding elements of @a v to elements of array.
+      valarray<_Tp>& operator+=(const valarray<_Tp>&);
+
+      ///  Subtract corresponding elements of @a v from elements of array.
+      valarray<_Tp>& operator-=(const valarray<_Tp>&);
+
+      ///  Logical xor corresponding elements of @a v with elements of array.
+      valarray<_Tp>& operator^=(const valarray<_Tp>&);
+
+      ///  Logical or corresponding elements of @a v with elements of array.
+      valarray<_Tp>& operator|=(const valarray<_Tp>&);
+
+      ///  Logical and corresponding elements of @a v with elements of array.
+      valarray<_Tp>& operator&=(const valarray<_Tp>&);
+
+      ///  Left shift elements of array by corresponding elements of @a v.
+      valarray<_Tp>& operator<<=(const valarray<_Tp>&);
+
+      ///  Right shift elements of array by corresponding elements of @a v.
+      valarray<_Tp>& operator>>=(const valarray<_Tp>&);
+
+      template<class _Dom>
+	valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+        valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&);
+      template<class _Dom>
+	valarray<_Tp>& operator>>=(const _Expr<_Dom, _Tp>&);
+
+      // _lib.valarray.members_ member functions:
+#if __cplusplus >= 201103L
+      ///  Swap.
+      void swap(valarray<_Tp>& __v) noexcept;
+#endif
+
+      ///  Return the number of elements in array.
+      size_t size() const;
+
+      /**
+       *  @brief  Return the sum of all elements in the array.
+       *
+       *  Accumulates the sum of all elements into a Tp using +=.  The order
+       *  of adding the elements is unspecified.
+       */
+      _Tp    sum() const;
+
+      ///  Return the minimum element using operator<().
+      _Tp    min() const;	
+
+      ///  Return the maximum element using operator<().
+      _Tp    max() const;	
+
+      /**
+       *  @brief  Return a shifted array.
+       *
+       *  A new valarray is constructed as a copy of this array with elements
+       *  in shifted positions.  For an element with index i, the new position
+       *  is i - n.  The new valarray has the same size as the current one.
+       *  New elements without a value are set to 0.  Elements whose new
+       *  position is outside the bounds of the array are discarded.
+       *
+       *  Positive arguments shift toward index 0, discarding elements [0, n).
+       *  Negative arguments discard elements from the top of the array.
+       *
+       *  @param  __n  Number of element positions to shift.
+       *  @return  New valarray with elements in shifted positions.
+       */
+      valarray<_Tp> shift (int __n) const;
+
+      /**
+       *  @brief  Return a rotated array.
+       *
+       *  A new valarray is constructed as a copy of this array with elements
+       *  in shifted positions.  For an element with index i, the new position
+       *  is (i - n) % size().  The new valarray has the same size as the
+       *  current one.  Elements that are shifted beyond the array bounds are
+       *  shifted into the other end of the array.  No elements are lost.
+       *
+       *  Positive arguments shift toward index 0, wrapping around the top.
+       *  Negative arguments shift towards the top, wrapping around to 0.
+       *
+       *  @param  __n  Number of element positions to rotate.
+       *  @return  New valarray with elements in shifted positions.
+       */
+      valarray<_Tp> cshift(int __n) const;
+
+      /**
+       *  @brief  Apply a function to the array.
+       *
+       *  Returns a new valarray with elements assigned to the result of
+       *  applying func to the corresponding element of this array.  The new
+       *  array has the same size as this one.
+       *
+       *  @param  func  Function of Tp returning Tp to apply.
+       *  @return  New valarray with transformed elements.
+       */
+      _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const;
+
+      /**
+       *  @brief  Apply a function to the array.
+       *
+       *  Returns a new valarray with elements assigned to the result of
+       *  applying func to the corresponding element of this array.  The new
+       *  array has the same size as this one.
+       *
+       *  @param  func  Function of const Tp& returning Tp to apply.
+       *  @return  New valarray with transformed elements.
+       */
+      _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const;
+
+      /**
+       *  @brief  Resize array.
+       *
+       *  Resize this array to @a size and set all elements to @a c.  All
+       *  references and iterators are invalidated.
+       *
+       *  @param  __size  New array size.
+       *  @param  __c  New value for all elements.
+       */
+      void resize(size_t __size, _Tp __c = _Tp());
+
+    private:
+      size_t _M_size;
+      _Tp* __restrict__ _M_data;
+      
+      friend class _Array<_Tp>;
+    };
+  
+  template<typename _Tp>
+    inline const _Tp&
+    valarray<_Tp>::operator[](size_t __i) const
+    { 
+      __glibcxx_requires_subscript(__i);
+      return _M_data[__i];
+    }
+
+  template<typename _Tp>
+    inline _Tp&
+    valarray<_Tp>::operator[](size_t __i)
+    { 
+      __glibcxx_requires_subscript(__i);
+      return _M_data[__i];
+    }
+
+  // @} group numeric_arrays
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#include <bits/valarray_after.h>
+#include <bits/slice_array.h>
+#include <bits/gslice.h>
+#include <bits/gslice_array.h>
+#include <bits/mask_array.h>
+#include <bits/indirect_array.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup numeric_arrays
+   * @{
+   */
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}
+
+  template<typename _Tp>
+    inline 
+    valarray<_Tp>::valarray(size_t __n) 
+    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
+    { std::__valarray_default_construct(_M_data, _M_data + __n); }
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(const _Tp& __t, size_t __n)
+    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
+    { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); }
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
+    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
+    { 
+      _GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0);
+      std::__valarray_copy_construct(__p, __p + __n, _M_data); 
+    }
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(const valarray<_Tp>& __v)
+    : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
+    { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
+				     _M_data); }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(valarray<_Tp>&& __v) noexcept
+    : _M_size(__v._M_size), _M_data(__v._M_data)
+    {
+      __v._M_size = 0;
+      __v._M_data = 0;
+    }
+#endif
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(const slice_array<_Tp>& __sa)
+    : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
+    {
+      std::__valarray_copy_construct
+	(__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
+    }
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga)
+    : _M_size(__ga._M_index.size()),
+      _M_data(__valarray_get_storage<_Tp>(_M_size))
+    {
+      std::__valarray_copy_construct
+	(__ga._M_array, _Array<size_t>(__ga._M_index),
+	 _Array<_Tp>(_M_data), _M_size);
+    }
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
+    : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
+    {
+      std::__valarray_copy_construct
+	(__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
+    }
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
+    : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
+    {
+      std::__valarray_copy_construct
+	(__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::valarray(initializer_list<_Tp> __l)
+    : _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size()))
+    { std::__valarray_copy_construct(__l.begin(), __l.end(), _M_data); }
+#endif
+
+  template<typename _Tp> template<class _Dom>
+    inline
+    valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
+    : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
+    { std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); }
+
+  template<typename _Tp>
+    inline
+    valarray<_Tp>::~valarray() _GLIBCXX_NOEXCEPT
+    {
+      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
+      std::__valarray_release_memory(_M_data);
+    }
+
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(const valarray<_Tp>& __v)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 630. arrays of valarray.
+      if (_M_size == __v._M_size)
+	std::__valarray_copy(__v._M_data, _M_size, _M_data);
+      else
+	{
+	  if (_M_data)
+	    {
+	      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
+	      std::__valarray_release_memory(_M_data);
+	    }
+	  _M_size = __v._M_size;
+	  _M_data = __valarray_get_storage<_Tp>(_M_size);
+	  std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
+					 _M_data);
+	}
+      return *this;
+    }
+
+#if __cplusplus >= 201103L
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(valarray<_Tp>&& __v) noexcept
+    {
+      if (_M_data)
+	{
+	  std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
+	  std::__valarray_release_memory(_M_data);
+	}
+      _M_size = __v._M_size;
+      _M_data = __v._M_data;
+      __v._M_size = 0;
+      __v._M_data = 0;
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(initializer_list<_Tp> __l)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 630. arrays of valarray.
+      if (_M_size == __l.size())
+	std::__valarray_copy(__l.begin(), __l.size(), _M_data);
+      else
+	{
+	  if (_M_data)
+	    {
+	      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
+	      std::__valarray_release_memory(_M_data);
+	    }
+	  _M_size = __l.size();
+	  _M_data = __valarray_get_storage<_Tp>(_M_size);
+	  std::__valarray_copy_construct(__l.begin(), __l.begin() + _M_size,
+					 _M_data);
+	}
+      return *this;
+    }
+#endif
+
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(const _Tp& __t)
+    {
+      std::__valarray_fill(_M_data, _M_size, __t);
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz);
+      std::__valarray_copy(__sa._M_array, __sa._M_sz,
+			   __sa._M_stride, _Array<_Tp>(_M_data));
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size());
+      std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
+			   _Array<_Tp>(_M_data), _M_size);
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz);
+      std::__valarray_copy(__ma._M_array, __ma._M_mask,
+			   _Array<_Tp>(_M_data), _M_size);
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz);
+      std::__valarray_copy(__ia._M_array, __ia._M_index,
+			   _Array<_Tp>(_M_data), _M_size);
+      return *this;
+    }
+
+  template<typename _Tp> template<class _Dom>
+    inline valarray<_Tp>&
+    valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
+    {
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 630. arrays of valarray.
+      if (_M_size == __e.size())
+	std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
+      else
+	{
+	  if (_M_data)
+	    {
+	      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
+	      std::__valarray_release_memory(_M_data);
+	    }
+	  _M_size = __e.size();
+	  _M_data = __valarray_get_storage<_Tp>(_M_size);
+	  std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data));
+	}
+      return *this;
+    }
+
+  template<typename _Tp>
+    inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
+    valarray<_Tp>::operator[](slice __s) const
+    {
+      typedef _SClos<_ValArray,_Tp> _Closure;
+      return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s));
+    }
+
+  template<typename _Tp>
+    inline slice_array<_Tp>
+    valarray<_Tp>::operator[](slice __s)
+    { return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); }
+
+  template<typename _Tp>
+    inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
+    valarray<_Tp>::operator[](const gslice& __gs) const
+    {
+      typedef _GClos<_ValArray,_Tp> _Closure;
+      return _Expr<_Closure, _Tp>
+	(_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index));
+    }
+
+  template<typename _Tp>
+    inline gslice_array<_Tp>
+    valarray<_Tp>::operator[](const gslice& __gs)
+    {
+      return gslice_array<_Tp>
+	(_Array<_Tp>(_M_data), __gs._M_index->_M_index);
+    }
+
+  template<typename _Tp>
+    inline valarray<_Tp>
+    valarray<_Tp>::operator[](const valarray<bool>& __m) const
+    {
+      size_t __s = 0;
+      size_t __e = __m.size();
+      for (size_t __i=0; __i<__e; ++__i)
+	if (__m[__i]) ++__s;
+      return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s,
+					   _Array<bool> (__m)));
+    }
+
+  template<typename _Tp>
+    inline mask_array<_Tp>
+    valarray<_Tp>::operator[](const valarray<bool>& __m)
+    {
+      size_t __s = 0;
+      size_t __e = __m.size();
+      for (size_t __i=0; __i<__e; ++__i)
+	if (__m[__i]) ++__s;
+      return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m));
+    }
+
+  template<typename _Tp>
+    inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
+    valarray<_Tp>::operator[](const valarray<size_t>& __i) const
+    {
+      typedef _IClos<_ValArray,_Tp> _Closure;
+      return _Expr<_Closure, _Tp>(_Closure(*this, __i));
+    }
+
+  template<typename _Tp>
+    inline indirect_array<_Tp>
+    valarray<_Tp>::operator[](const valarray<size_t>& __i)
+    {
+      return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(),
+				 _Array<size_t>(__i));
+    }
+
+#if __cplusplus >= 201103L
+  template<class _Tp>
+    inline void
+    valarray<_Tp>::swap(valarray<_Tp>& __v) noexcept
+    {
+      std::swap(_M_size, __v._M_size);
+      std::swap(_M_data, __v._M_data);
+    }
+#endif
+
+  template<class _Tp>
+    inline size_t 
+    valarray<_Tp>::size() const
+    { return _M_size; }
+
+  template<class _Tp>
+    inline _Tp
+    valarray<_Tp>::sum() const
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
+      return std::__valarray_sum(_M_data, _M_data + _M_size);
+    }
+
+  template<class _Tp>
+     inline valarray<_Tp>
+     valarray<_Tp>::shift(int __n) const
+     {
+       valarray<_Tp> __ret;
+
+       if (_M_size == 0)
+	 return __ret;
+
+       _Tp* __restrict__ __tmp_M_data =
+	 std::__valarray_get_storage<_Tp>(_M_size);
+
+       if (__n == 0)
+	 std::__valarray_copy_construct(_M_data,
+					_M_data + _M_size, __tmp_M_data);
+       else if (__n > 0)      // shift left
+	 {
+	   if (size_t(__n) > _M_size)
+	     __n = int(_M_size);
+
+	   std::__valarray_copy_construct(_M_data + __n,
+					  _M_data + _M_size, __tmp_M_data);
+	   std::__valarray_default_construct(__tmp_M_data + _M_size - __n,
+					     __tmp_M_data + _M_size);
+	 }
+       else                   // shift right
+	 {
+	   if (-size_t(__n) > _M_size)
+	     __n = -int(_M_size);
+
+	   std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
+					  __tmp_M_data - __n);
+	   std::__valarray_default_construct(__tmp_M_data,
+					     __tmp_M_data - __n);
+	 }
+
+       __ret._M_size = _M_size;
+       __ret._M_data = __tmp_M_data;
+       return __ret;
+     }
+
+  template<class _Tp>
+     inline valarray<_Tp>
+     valarray<_Tp>::cshift(int __n) const
+     {
+       valarray<_Tp> __ret;
+
+       if (_M_size == 0)
+	 return __ret;
+
+       _Tp* __restrict__ __tmp_M_data =
+	 std::__valarray_get_storage<_Tp>(_M_size);
+
+       if (__n == 0)
+	 std::__valarray_copy_construct(_M_data,
+					_M_data + _M_size, __tmp_M_data);
+       else if (__n > 0)      // cshift left
+	 {
+	   if (size_t(__n) > _M_size)
+	     __n = int(__n % _M_size);
+
+	   std::__valarray_copy_construct(_M_data, _M_data + __n,
+					  __tmp_M_data + _M_size - __n);
+	   std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size,
+					  __tmp_M_data);
+	 }
+       else                   // cshift right
+	 {
+	   if (-size_t(__n) > _M_size)
+	     __n = -int(-size_t(__n) % _M_size);
+
+	   std::__valarray_copy_construct(_M_data + _M_size + __n,
+					  _M_data + _M_size, __tmp_M_data);
+	   std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
+					  __tmp_M_data - __n);
+	 }
+
+       __ret._M_size = _M_size;
+       __ret._M_data = __tmp_M_data;
+       return __ret;
+     }
+
+  template<class _Tp>
+    inline void
+    valarray<_Tp>::resize(size_t __n, _Tp __c)
+    {
+      // This complication is so to make valarray<valarray<T> > work
+      // even though it is not required by the standard.  Nobody should
+      // be saying valarray<valarray<T> > anyway.  See the specs.
+      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
+      if (_M_size != __n)
+	{
+	  std::__valarray_release_memory(_M_data);
+	  _M_size = __n;
+	  _M_data = __valarray_get_storage<_Tp>(__n);
+	}
+      std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
+    }
+    
+  template<typename _Tp>
+    inline _Tp
+    valarray<_Tp>::min() const
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
+      return *std::min_element(_M_data, _M_data + _M_size);
+    }
+
+  template<typename _Tp>
+    inline _Tp
+    valarray<_Tp>::max() const
+    {
+      _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
+      return *std::max_element(_M_data, _M_data + _M_size);
+    }
+  
+  template<class _Tp>
+    inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
+    valarray<_Tp>::apply(_Tp func(_Tp)) const
+    {
+      typedef _ValFunClos<_ValArray, _Tp> _Closure;
+      return _Expr<_Closure, _Tp>(_Closure(*this, func));
+    }
+
+  template<class _Tp>
+    inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp>
+    valarray<_Tp>::apply(_Tp func(const _Tp &)) const
+    {
+      typedef _RefFunClos<_ValArray, _Tp> _Closure;
+      return _Expr<_Closure, _Tp>(_Closure(*this, func));
+    }
+
+#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name)                     \
+  template<typename _Tp>						\
+    inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt      	\
+    valarray<_Tp>::operator _Op() const					\
+    {									\
+      typedef _UnClos<_Name, _ValArray, _Tp> _Closure;	                \
+      typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
+      return _Expr<_Closure, _Rt>(_Closure(*this));			\
+    }
+
+    _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus)
+    _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate)
+    _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not)
+    _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not)
+
+#undef _DEFINE_VALARRAY_UNARY_OPERATOR
+
+#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name)               \
+  template<class _Tp>							\
+    inline valarray<_Tp>&						\
+    valarray<_Tp>::operator _Op##=(const _Tp &__t)			\
+    {									\
+      _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t);	\
+      return *this;							\
+    }									\
+									\
+  template<class _Tp>							\
+    inline valarray<_Tp>&						\
+    valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v)		\
+    {									\
+      _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size);                    \
+      _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, 		\
+			       _Array<_Tp>(__v._M_data));		\
+      return *this;							\
+    }
+
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left)
+_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right)
+
+#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
+
+#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name)          \
+  template<class _Tp> template<class _Dom>				\
+    inline valarray<_Tp>&						\
+    valarray<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e)		\
+    {									\
+      _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size);	\
+      return *this;							\
+    }
+
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left)
+_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
+
+#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
+    
+
+#define _DEFINE_BINARY_OPERATOR(_Op, _Name)				\
+  template<typename _Tp>						\
+    inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>,       \
+                 typename __fun<_Name, _Tp>::result_type>               \
+    operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w)	\
+    {									\
+      _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size());                  \
+      typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \
+      typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
+      return _Expr<_Closure, _Rt>(_Closure(__v, __w));                  \
+    }									\
+									\
+  template<typename _Tp>						\
+    inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>,        \
+                 typename __fun<_Name, _Tp>::result_type>               \
+    operator _Op(const valarray<_Tp>& __v, const _Tp& __t)		\
+    {									\
+      typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure;	\
+      typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
+      return _Expr<_Closure, _Rt>(_Closure(__v, __t));	                \
+    }									\
+									\
+  template<typename _Tp>						\
+    inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>,       \
+                 typename __fun<_Name, _Tp>::result_type>               \
+    operator _Op(const _Tp& __t, const valarray<_Tp>& __v)		\
+    {									\
+      typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \
+      typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
+      return _Expr<_Closure, _Rt>(_Closure(__t, __v));        	        \
+    }
+
+_DEFINE_BINARY_OPERATOR(+, __plus)
+_DEFINE_BINARY_OPERATOR(-, __minus)
+_DEFINE_BINARY_OPERATOR(*, __multiplies)
+_DEFINE_BINARY_OPERATOR(/, __divides)
+_DEFINE_BINARY_OPERATOR(%, __modulus)
+_DEFINE_BINARY_OPERATOR(^, __bitwise_xor)
+_DEFINE_BINARY_OPERATOR(&, __bitwise_and)
+_DEFINE_BINARY_OPERATOR(|, __bitwise_or)
+_DEFINE_BINARY_OPERATOR(<<, __shift_left)
+_DEFINE_BINARY_OPERATOR(>>, __shift_right)
+_DEFINE_BINARY_OPERATOR(&&, __logical_and)
+_DEFINE_BINARY_OPERATOR(||, __logical_or)
+_DEFINE_BINARY_OPERATOR(==, __equal_to)
+_DEFINE_BINARY_OPERATOR(!=, __not_equal_to)
+_DEFINE_BINARY_OPERATOR(<, __less)
+_DEFINE_BINARY_OPERATOR(>, __greater)
+_DEFINE_BINARY_OPERATOR(<=, __less_equal)
+_DEFINE_BINARY_OPERATOR(>=, __greater_equal)
+
+#undef _DEFINE_BINARY_OPERATOR
+
+#if __cplusplus >= 201103L
+  /**
+   *  @brief  Return an iterator pointing to the first element of
+   *          the valarray.
+   *  @param  __va  valarray.
+   */
+  template<class _Tp>
+    inline _Tp*
+    begin(valarray<_Tp>& __va)
+    { return std::__addressof(__va[0]); }
+
+  /**
+   *  @brief  Return an iterator pointing to the first element of
+   *          the const valarray.
+   *  @param  __va  valarray.
+   */
+  template<class _Tp>
+    inline const _Tp*
+    begin(const valarray<_Tp>& __va)
+    { return std::__addressof(__va[0]); }
+
+  /**
+   *  @brief  Return an iterator pointing to one past the last element of
+   *          the valarray.
+   *  @param  __va  valarray.
+   */
+  template<class _Tp>
+    inline _Tp*
+    end(valarray<_Tp>& __va)
+    { return std::__addressof(__va[0]) + __va.size(); }
+
+  /**
+   *  @brief  Return an iterator pointing to one past the last element of
+   *          the const valarray.
+   *  @param  __va  valarray.
+   */
+  template<class _Tp>
+    inline const _Tp*
+    end(const valarray<_Tp>& __va)
+    { return std::__addressof(__va[0]) + __va.size(); }
+#endif // C++11
+
+  // @} group numeric_arrays
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _GLIBCXX_VALARRAY */
diff --git a/gcc-4.9/libstdc++-v3/include/std/vector b/gcc-4.9/libstdc++-v3/include/std/vector
new file mode 100644
index 0000000..c00fbc1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/std/vector
@@ -0,0 +1,81 @@
+// <vector> -*- C++ -*-
+
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/** @file include/vector
+ *  This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_VECTOR
+#define _GLIBCXX_VECTOR 1
+
+#pragma GCC system_header
+
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/stl_construct.h>
+#include <bits/stl_uninitialized.h>
+#include <bits/stl_vector.h>
+#include <bits/stl_bvector.h> 
+#include <bits/range_access.h>
+
+#ifndef _GLIBCXX_EXPORT_TEMPLATE
+# include <bits/vector.tcc>
+#endif
+
+#ifdef _GLIBCXX_DEBUG
+# include <debug/vector>
+#endif
+
+#ifdef _GLIBCXX_PROFILE
+# include <profile/vector>
+#endif
+
+#endif /* _GLIBCXX_VECTOR */
+
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/array b/gcc-4.9/libstdc++-v3/include/tr1/array
new file mode 100644
index 0000000..47013f7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/array
@@ -0,0 +1,251 @@
+// class template array -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/array
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_ARRAY
+#define _GLIBCXX_TR1_ARRAY 1
+
+#pragma GCC system_header
+
+#include <bits/stl_algobase.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  @brief A standard container for storing a fixed size sequence of elements.
+   *
+   *  @ingroup sequences
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
+   *  <a href="tables.html#66">reversible container</a>, and a
+   *  <a href="tables.html#67">sequence</a>.
+   *
+   *  Sets support random access iterators.
+   *
+   *  @param  Tp  Type of element. Required to be a complete type.
+   *  @param  N  Number of elements.
+  */
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp 	    			      value_type;
+      typedef value_type&                   	      reference;
+      typedef const value_type&             	      const_reference;
+      typedef value_type*          		      iterator;
+      typedef const value_type*			      const_iterator;
+      typedef std::size_t                    	      size_type;
+      typedef std::ptrdiff_t                   	      difference_type;
+      typedef std::reverse_iterator<iterator>	      reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+
+      // Support for zero-sized arrays mandatory.
+      value_type _M_instance[_Nm ? _Nm : 1];
+
+      // No explicit construct/copy/destroy for aggregate type.
+
+      void
+      assign(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void
+      swap(array& __other)
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+      // Iterators.
+      iterator
+      begin()
+      { return iterator(std::__addressof(_M_instance[0])); }
+
+      const_iterator
+      begin() const 
+      { return const_iterator(std::__addressof(_M_instance[0])); }
+
+      iterator
+      end()
+      { return iterator(std::__addressof(_M_instance[_Nm])); }
+
+      const_iterator
+      end() const
+      { return const_iterator(std::__addressof(_M_instance[_Nm])); }
+
+      reverse_iterator 
+      rbegin()
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator 
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator 
+      rend()
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator 
+      rend() const
+      { return const_reverse_iterator(begin()); }
+
+      // Capacity.
+      size_type 
+      size() const { return _Nm; }
+
+      size_type 
+      max_size() const { return _Nm; }
+
+      bool 
+      empty() const { return size() == 0; }
+
+      // Element access.
+      reference
+      operator[](size_type __n)
+      { return _M_instance[__n]; }
+
+      const_reference
+      operator[](size_type __n) const
+      { return _M_instance[__n]; }
+
+      reference
+      at(size_type __n)
+      {
+	if (__n >= _Nm)
+	  std::__throw_out_of_range(__N("array::at"));
+	return _M_instance[__n];
+      }
+
+      const_reference
+      at(size_type __n) const
+      {
+	if (__n >= _Nm)
+	  std::__throw_out_of_range(__N("array::at"));
+	return _M_instance[__n];
+      }
+
+      reference 
+      front()
+      { return *begin(); }
+
+      const_reference 
+      front() const
+      { return *begin(); }
+
+      reference 
+      back()
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      const_reference 
+      back() const
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      _Tp*
+      data()
+      { return std::__addressof(_M_instance[0]); }
+
+      const _Tp*
+      data() const
+      { return std::__addressof(_M_instance[0]); }
+    };
+
+  // Array comparisons.
+  template<typename _Tp, std::size_t _Nm>
+    inline bool 
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    { 
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+					  __b.begin(), __b.end()); 
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+  // Specialized algorithms [6.2.2.2].
+  template<typename _Tp, std::size_t _Nm>
+    inline void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    { __one.swap(__two); }
+
+  // Tuple interface to class template array [6.2.2.5].
+
+  /// tuple_size
+  template<typename _Tp> 
+    class tuple_size;
+
+  /// tuple_element
+  template<int _Int, typename _Tp>
+    class tuple_element;
+
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<array<_Tp, _Nm> >
+    { static const int value = _Nm; };
+
+  template<typename _Tp, std::size_t _Nm>
+    const int
+    tuple_size<array<_Tp, _Nm> >::value;  
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, array<_Tp, _Nm> >
+    { typedef _Tp type; };
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    inline _Tp&
+    get(array<_Tp, _Nm>& __arr)
+    { return __arr[_Int]; }
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    inline const _Tp&
+    get(const array<_Tp, _Nm>& __arr)
+    { return __arr[_Int]; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_ARRAY
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/bessel_function.tcc b/gcc-4.9/libstdc++-v3/include/tr1/bessel_function.tcc
new file mode 100644
index 0000000..9cb329a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/bessel_function.tcc
@@ -0,0 +1,628 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/bessel_function.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland.
+//
+// References:
+//   (1) Handbook of Mathematical Functions,
+//       ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 9, pp. 355-434, Section 10 pp. 435-478
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 240-245
+
+#ifndef _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
+#define _GLIBCXX_TR1_BESSEL_FUNCTION_TCC 1
+
+#include "special_function_util.h"
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief Compute the gamma functions required by the Temme series
+     *          expansions of @f$ N_\nu(x) @f$ and @f$ K_\nu(x) @f$.
+     *   @f[
+     *     \Gamma_1 = \frac{1}{2\mu}
+     *                [\frac{1}{\Gamma(1 - \mu)} - \frac{1}{\Gamma(1 + \mu)}]
+     *   @f]
+     *   and
+     *   @f[
+     *     \Gamma_2 = \frac{1}{2}
+     *                [\frac{1}{\Gamma(1 - \mu)} + \frac{1}{\Gamma(1 + \mu)}]
+     *   @f]
+     *   where @f$ -1/2 <= \mu <= 1/2 @f$ is @f$ \mu = \nu - N @f$ and @f$ N @f$.
+     *   is the nearest integer to @f$ \nu @f$.
+     *   The values of \f$ \Gamma(1 + \mu) \f$ and \f$ \Gamma(1 - \mu) \f$
+     *   are returned as well.
+     * 
+     *   The accuracy requirements on this are exquisite.
+     *
+     *   @param __mu     The input parameter of the gamma functions.
+     *   @param __gam1   The output function \f$ \Gamma_1(\mu) \f$
+     *   @param __gam2   The output function \f$ \Gamma_2(\mu) \f$
+     *   @param __gampl  The output function \f$ \Gamma(1 + \mu) \f$
+     *   @param __gammi  The output function \f$ \Gamma(1 - \mu) \f$
+     */
+    template <typename _Tp>
+    void
+    __gamma_temme(_Tp __mu,
+                  _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
+    {
+#if _GLIBCXX_USE_C99_MATH_TR1
+      __gampl = _Tp(1) / std::tr1::tgamma(_Tp(1) + __mu);
+      __gammi = _Tp(1) / std::tr1::tgamma(_Tp(1) - __mu);
+#else
+      __gampl = _Tp(1) / __gamma(_Tp(1) + __mu);
+      __gammi = _Tp(1) / __gamma(_Tp(1) - __mu);
+#endif
+
+      if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon())
+        __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e());
+      else
+        __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu);
+
+      __gam2 = (__gammi + __gampl) / (_Tp(2));
+
+      return;
+    }
+
+
+    /**
+     *   @brief  Compute the Bessel @f$ J_\nu(x) @f$ and Neumann
+     *           @f$ N_\nu(x) @f$ functions and their first derivatives
+     *           @f$ J'_\nu(x) @f$ and @f$ N'_\nu(x) @f$ respectively.
+     *           These four functions are computed together for numerical
+     *           stability.
+     *
+     *   @param  __nu  The order of the Bessel functions.
+     *   @param  __x   The argument of the Bessel functions.
+     *   @param  __Jnu  The output Bessel function of the first kind.
+     *   @param  __Nnu  The output Neumann function (Bessel function of the second kind).
+     *   @param  __Jpnu  The output derivative of the Bessel function of the first kind.
+     *   @param  __Npnu  The output derivative of the Neumann function.
+     */
+    template <typename _Tp>
+    void
+    __bessel_jn(_Tp __nu, _Tp __x,
+                _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu)
+    {
+      if (__x == _Tp(0))
+        {
+          if (__nu == _Tp(0))
+            {
+              __Jnu = _Tp(1);
+              __Jpnu = _Tp(0);
+            }
+          else if (__nu == _Tp(1))
+            {
+              __Jnu = _Tp(0);
+              __Jpnu = _Tp(0.5L);
+            }
+          else
+            {
+              __Jnu = _Tp(0);
+              __Jpnu = _Tp(0);
+            }
+          __Nnu = -std::numeric_limits<_Tp>::infinity();
+          __Npnu = std::numeric_limits<_Tp>::infinity();
+          return;
+        }
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      //  When the multiplier is N i.e.
+      //  fp_min = N * min()
+      //  Then J_0 and N_0 tank at x = 8 * N (J_0 = 0 and N_0 = nan)!
+      //const _Tp __fp_min = _Tp(20) * std::numeric_limits<_Tp>::min();
+      const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min());
+      const int __max_iter = 15000;
+      const _Tp __x_min = _Tp(2);
+
+      const int __nl = (__x < __x_min
+                    ? static_cast<int>(__nu + _Tp(0.5L))
+                    : std::max(0, static_cast<int>(__nu - __x + _Tp(1.5L))));
+
+      const _Tp __mu = __nu - __nl;
+      const _Tp __mu2 = __mu * __mu;
+      const _Tp __xi = _Tp(1) / __x;
+      const _Tp __xi2 = _Tp(2) * __xi;
+      _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi();
+      int __isign = 1;
+      _Tp __h = __nu * __xi;
+      if (__h < __fp_min)
+        __h = __fp_min;
+      _Tp __b = __xi2 * __nu;
+      _Tp __d = _Tp(0);
+      _Tp __c = __h;
+      int __i;
+      for (__i = 1; __i <= __max_iter; ++__i)
+        {
+          __b += __xi2;
+          __d = __b - __d;
+          if (std::abs(__d) < __fp_min)
+            __d = __fp_min;
+          __c = __b - _Tp(1) / __c;
+          if (std::abs(__c) < __fp_min)
+            __c = __fp_min;
+          __d = _Tp(1) / __d;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (__d < _Tp(0))
+            __isign = -__isign;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            break;
+        }
+      if (__i > __max_iter)
+        std::__throw_runtime_error(__N("Argument x too large in __bessel_jn; "
+                                       "try asymptotic expansion."));
+      _Tp __Jnul = __isign * __fp_min;
+      _Tp __Jpnul = __h * __Jnul;
+      _Tp __Jnul1 = __Jnul;
+      _Tp __Jpnu1 = __Jpnul;
+      _Tp __fact = __nu * __xi;
+      for ( int __l = __nl; __l >= 1; --__l )
+        {
+          const _Tp __Jnutemp = __fact * __Jnul + __Jpnul;
+          __fact -= __xi;
+          __Jpnul = __fact * __Jnutemp - __Jnul;
+          __Jnul = __Jnutemp;
+        }
+      if (__Jnul == _Tp(0))
+        __Jnul = __eps;
+      _Tp __f= __Jpnul / __Jnul;
+      _Tp __Nmu, __Nnu1, __Npmu, __Jmu;
+      if (__x < __x_min)
+        {
+          const _Tp __x2 = __x / _Tp(2);
+          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
+          _Tp __fact = (std::abs(__pimu) < __eps
+                      ? _Tp(1) : __pimu / std::sin(__pimu));
+          _Tp __d = -std::log(__x2);
+          _Tp __e = __mu * __d;
+          _Tp __fact2 = (std::abs(__e) < __eps
+                       ? _Tp(1) : std::sinh(__e) / __e);
+          _Tp __gam1, __gam2, __gampl, __gammi;
+          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
+          _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi())
+                   * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
+          __e = std::exp(__e);
+          _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl);
+          _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi);
+          const _Tp __pimu2 = __pimu / _Tp(2);
+          _Tp __fact3 = (std::abs(__pimu2) < __eps
+                       ? _Tp(1) : std::sin(__pimu2) / __pimu2 );
+          _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3;
+          _Tp __c = _Tp(1);
+          __d = -__x2 * __x2;
+          _Tp __sum = __ff + __r * __q;
+          _Tp __sum1 = __p;
+          for (__i = 1; __i <= __max_iter; ++__i)
+            {
+              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
+              __c *= __d / _Tp(__i);
+              __p /= _Tp(__i) - __mu;
+              __q /= _Tp(__i) + __mu;
+              const _Tp __del = __c * (__ff + __r * __q);
+              __sum += __del; 
+              const _Tp __del1 = __c * __p - __i * __del;
+              __sum1 += __del1;
+              if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) )
+                break;
+            }
+          if ( __i > __max_iter )
+            std::__throw_runtime_error(__N("Bessel y series failed to converge "
+                                           "in __bessel_jn."));
+          __Nmu = -__sum;
+          __Nnu1 = -__sum1 * __xi2;
+          __Npmu = __mu * __xi * __Nmu - __Nnu1;
+          __Jmu = __w / (__Npmu - __f * __Nmu);
+        }
+      else
+        {
+          _Tp __a = _Tp(0.25L) - __mu2;
+          _Tp __q = _Tp(1);
+          _Tp __p = -__xi / _Tp(2);
+          _Tp __br = _Tp(2) * __x;
+          _Tp __bi = _Tp(2);
+          _Tp __fact = __a * __xi / (__p * __p + __q * __q);
+          _Tp __cr = __br + __q * __fact;
+          _Tp __ci = __bi + __p * __fact;
+          _Tp __den = __br * __br + __bi * __bi;
+          _Tp __dr = __br / __den;
+          _Tp __di = -__bi / __den;
+          _Tp __dlr = __cr * __dr - __ci * __di;
+          _Tp __dli = __cr * __di + __ci * __dr;
+          _Tp __temp = __p * __dlr - __q * __dli;
+          __q = __p * __dli + __q * __dlr;
+          __p = __temp;
+          int __i;
+          for (__i = 2; __i <= __max_iter; ++__i)
+            {
+              __a += _Tp(2 * (__i - 1));
+              __bi += _Tp(2);
+              __dr = __a * __dr + __br;
+              __di = __a * __di + __bi;
+              if (std::abs(__dr) + std::abs(__di) < __fp_min)
+                __dr = __fp_min;
+              __fact = __a / (__cr * __cr + __ci * __ci);
+              __cr = __br + __cr * __fact;
+              __ci = __bi - __ci * __fact;
+              if (std::abs(__cr) + std::abs(__ci) < __fp_min)
+                __cr = __fp_min;
+              __den = __dr * __dr + __di * __di;
+              __dr /= __den;
+              __di /= -__den;
+              __dlr = __cr * __dr - __ci * __di;
+              __dli = __cr * __di + __ci * __dr;
+              __temp = __p * __dlr - __q * __dli;
+              __q = __p * __dli + __q * __dlr;
+              __p = __temp;
+              if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps)
+                break;
+          }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(__N("Lentz's method failed "
+                                           "in __bessel_jn."));
+          const _Tp __gam = (__p - __f) / __q;
+          __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));
+#if _GLIBCXX_USE_C99_MATH_TR1
+          __Jmu = std::tr1::copysign(__Jmu, __Jnul);
+#else
+          if (__Jmu * __Jnul < _Tp(0))
+            __Jmu = -__Jmu;
+#endif
+          __Nmu = __gam * __Jmu;
+          __Npmu = (__p + __q / __gam) * __Nmu;
+          __Nnu1 = __mu * __xi * __Nmu - __Npmu;
+      }
+      __fact = __Jmu / __Jnul;
+      __Jnu = __fact * __Jnul1;
+      __Jpnu = __fact * __Jpnu1;
+      for (__i = 1; __i <= __nl; ++__i)
+        {
+          const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu;
+          __Nmu = __Nnu1;
+          __Nnu1 = __Nnutemp;
+        }
+      __Nnu = __Nmu;
+      __Npnu = __nu * __xi * __Nmu - __Nnu1;
+
+      return;
+    }
+
+
+    /**
+     *   @brief This routine computes the asymptotic cylindrical Bessel
+     *          and Neumann functions of order nu: \f$ J_{\nu} \f$,
+     *          \f$ N_{\nu} \f$.
+     *
+     *   References:
+     *    (1) Handbook of Mathematical Functions,
+     *        ed. Milton Abramowitz and Irene A. Stegun,
+     *        Dover Publications,
+     *        Section 9 p. 364, Equations 9.2.5-9.2.10
+     *
+     *   @param  __nu  The order of the Bessel functions.
+     *   @param  __x   The argument of the Bessel functions.
+     *   @param  __Jnu  The output Bessel function of the first kind.
+     *   @param  __Nnu  The output Neumann function (Bessel function of the second kind).
+     */
+    template <typename _Tp>
+    void
+    __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu)
+    {
+      const _Tp __mu   = _Tp(4) * __nu * __nu;
+      const _Tp __mum1 = __mu - _Tp(1);
+      const _Tp __mum9 = __mu - _Tp(9);
+      const _Tp __mum25 = __mu - _Tp(25);
+      const _Tp __mum49 = __mu - _Tp(49);
+      const _Tp __xx = _Tp(64) * __x * __x;
+      const _Tp __P = _Tp(1) - __mum1 * __mum9 / (_Tp(2) * __xx)
+                    * (_Tp(1) - __mum25 * __mum49 / (_Tp(12) * __xx));
+      const _Tp __Q = __mum1 / (_Tp(8) * __x)
+                    * (_Tp(1) - __mum9 * __mum25 / (_Tp(6) * __xx));
+
+      const _Tp __chi = __x - (__nu + _Tp(0.5L))
+                            * __numeric_constants<_Tp>::__pi_2();
+      const _Tp __c = std::cos(__chi);
+      const _Tp __s = std::sin(__chi);
+
+      const _Tp __coef = std::sqrt(_Tp(2)
+                             / (__numeric_constants<_Tp>::__pi() * __x));
+      __Jnu = __coef * (__c * __P - __s * __Q);
+      __Nnu = __coef * (__s * __P + __c * __Q);
+
+      return;
+    }
+
+
+    /**
+     *   @brief This routine returns the cylindrical Bessel functions
+     *          of order \f$ \nu \f$: \f$ J_{\nu} \f$ or \f$ I_{\nu} \f$
+     *          by series expansion.
+     *
+     *   The modified cylindrical Bessel function is:
+     *   @f[
+     *    Z_{\nu}(x) = \sum_{k=0}^{\infty}
+     *              \frac{\sigma^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
+     *   @f]
+     *   where \f$ \sigma = +1 \f$ or\f$  -1 \f$ for
+     *   \f$ Z = I \f$ or \f$ J \f$ respectively.
+     * 
+     *   See Abramowitz & Stegun, 9.1.10
+     *       Abramowitz & Stegun, 9.6.7
+     *    (1) Handbook of Mathematical Functions,
+     *        ed. Milton Abramowitz and Irene A. Stegun,
+     *        Dover Publications,
+     *        Equation 9.1.10 p. 360 and Equation 9.6.10 p. 375
+     *
+     *   @param  __nu  The order of the Bessel function.
+     *   @param  __x   The argument of the Bessel function.
+     *   @param  __sgn  The sign of the alternate terms
+     *                  -1 for the Bessel function of the first kind.
+     *                  +1 for the modified Bessel function of the first kind.
+     *   @return  The output Bessel function.
+     */
+    template <typename _Tp>
+    _Tp
+    __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn,
+                           unsigned int __max_iter)
+    {
+      if (__x == _Tp(0))
+	return __nu == _Tp(0) ? _Tp(1) : _Tp(0);
+
+      const _Tp __x2 = __x / _Tp(2);
+      _Tp __fact = __nu * std::log(__x2);
+#if _GLIBCXX_USE_C99_MATH_TR1
+      __fact -= std::tr1::lgamma(__nu + _Tp(1));
+#else
+      __fact -= __log_gamma(__nu + _Tp(1));
+#endif
+      __fact = std::exp(__fact);
+      const _Tp __xx4 = __sgn * __x2 * __x2;
+      _Tp __Jn = _Tp(1);
+      _Tp __term = _Tp(1);
+
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i)));
+          __Jn += __term;
+          if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+
+      return __fact * __Jn;
+    }
+
+
+    /**
+     *   @brief  Return the Bessel function of order \f$ \nu \f$:
+     *           \f$ J_{\nu}(x) \f$.
+     *
+     *   The cylindrical Bessel function is:
+     *   @f[
+     *    J_{\nu}(x) = \sum_{k=0}^{\infty}
+     *              \frac{(-1)^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
+     *   @f]
+     *
+     *   @param  __nu  The order of the Bessel function.
+     *   @param  __x   The argument of the Bessel function.
+     *   @return  The output Bessel function.
+     */
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_j(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __cyl_bessel_j."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
+        return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200);
+      else if (__x > _Tp(1000))
+        {
+          _Tp __J_nu, __N_nu;
+          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
+          return __J_nu;
+        }
+      else
+        {
+          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          return __J_nu;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the Neumann function of order \f$ \nu \f$:
+     *           \f$ N_{\nu}(x) \f$.
+     *
+     *   The Neumann function is defined by:
+     *   @f[
+     *      N_{\nu}(x) = \frac{J_{\nu}(x) \cos \nu\pi - J_{-\nu}(x)}
+     *                        {\sin \nu\pi}
+     *   @f]
+     *   where for integral \f$ \nu = n \f$ a limit is taken:
+     *   \f$ lim_{\nu \to n} \f$.
+     *
+     *   @param  __nu  The order of the Neumann function.
+     *   @param  __x   The argument of the Neumann function.
+     *   @return  The output Neumann function.
+     */
+    template<typename _Tp>
+    _Tp
+    __cyl_neumann_n(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __cyl_neumann_n."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x > _Tp(1000))
+        {
+          _Tp __J_nu, __N_nu;
+          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
+          return __N_nu;
+        }
+      else
+        {
+          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          return __N_nu;
+        }
+    }
+
+
+    /**
+     *   @brief  Compute the spherical Bessel @f$ j_n(x) @f$
+     *           and Neumann @f$ n_n(x) @f$ functions and their first
+     *           derivatives @f$ j'_n(x) @f$ and @f$ n'_n(x) @f$
+     *           respectively.
+     *
+     *   @param  __n  The order of the spherical Bessel function.
+     *   @param  __x  The argument of the spherical Bessel function.
+     *   @param  __j_n  The output spherical Bessel function.
+     *   @param  __n_n  The output spherical Neumann function.
+     *   @param  __jp_n The output derivative of the spherical Bessel function.
+     *   @param  __np_n The output derivative of the spherical Neumann function.
+     */
+    template <typename _Tp>
+    void
+    __sph_bessel_jn(unsigned int __n, _Tp __x,
+                    _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n)
+    {
+      const _Tp __nu = _Tp(__n) + _Tp(0.5L);
+
+      _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+      __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+
+      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
+                         / std::sqrt(__x);
+
+      __j_n = __factor * __J_nu;
+      __n_n = __factor * __N_nu;
+      __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x);
+      __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x);
+
+      return;
+    }
+
+
+    /**
+     *   @brief  Return the spherical Bessel function
+     *           @f$ j_n(x) @f$ of order n.
+     *
+     *   The spherical Bessel function is defined by:
+     *   @f[
+     *    j_n(x) = \left( \frac{\pi}{2x} \right) ^{1/2} J_{n+1/2}(x)
+     *   @f]
+     *
+     *   @param  __n  The order of the spherical Bessel function.
+     *   @param  __x  The argument of the spherical Bessel function.
+     *   @return  The output spherical Bessel function.
+     */
+    template <typename _Tp>
+    _Tp
+    __sph_bessel(unsigned int __n, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __sph_bessel."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == _Tp(0))
+        {
+          if (__n == 0)
+            return _Tp(1);
+          else
+            return _Tp(0);
+        }
+      else
+        {
+          _Tp __j_n, __n_n, __jp_n, __np_n;
+          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
+          return __j_n;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the spherical Neumann function
+     *           @f$ n_n(x) @f$.
+     *
+     *   The spherical Neumann function is defined by:
+     *   @f[
+     *    n_n(x) = \left( \frac{\pi}{2x} \right) ^{1/2} N_{n+1/2}(x)
+     *   @f]
+     *
+     *   @param  __n  The order of the spherical Neumann function.
+     *   @param  __x  The argument of the spherical Neumann function.
+     *   @return  The output spherical Neumann function.
+     */
+    template <typename _Tp>
+    _Tp
+    __sph_neumann(unsigned int __n, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __sph_neumann."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == _Tp(0))
+        return -std::numeric_limits<_Tp>::infinity();
+      else
+        {
+          _Tp __j_n, __n_n, __jp_n, __np_n;
+          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
+          return __n_n;
+        }
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/beta_function.tcc b/gcc-4.9/libstdc++-v3/include/tr1/beta_function.tcc
new file mode 100644
index 0000000..c4fe6e8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/beta_function.tcc
@@ -0,0 +1,197 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/beta_function.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 6, pp. 253-266
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 213-216
+//   (4) Gamma, Exploring Euler's Constant, Julian Havil,
+//       Princeton, 2003.
+
+#ifndef _GLIBCXX_TR1_BETA_FUNCTION_TCC
+#define _GLIBCXX_TR1_BETA_FUNCTION_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief  Return the beta function: \f$B(x,y)\f$.
+     * 
+     *   The beta function is defined by
+     *   @f[
+     *     B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
+     *   @f]
+     *
+     *   @param __x The first argument of the beta function.
+     *   @param __y The second argument of the beta function.
+     *   @return  The beta function.
+     */
+    template<typename _Tp>
+    _Tp
+    __beta_gamma(_Tp __x, _Tp __y)
+    {
+
+      _Tp __bet;
+#if _GLIBCXX_USE_C99_MATH_TR1
+      if (__x > __y)
+        {
+          __bet = std::tr1::tgamma(__x)
+                / std::tr1::tgamma(__x + __y);
+          __bet *= std::tr1::tgamma(__y);
+        }
+      else
+        {
+          __bet = std::tr1::tgamma(__y)
+                / std::tr1::tgamma(__x + __y);
+          __bet *= std::tr1::tgamma(__x);
+        }
+#else
+      if (__x > __y)
+        {
+          __bet = __gamma(__x) / __gamma(__x + __y);
+          __bet *= __gamma(__y);
+        }
+      else
+        {
+          __bet = __gamma(__y) / __gamma(__x + __y);
+          __bet *= __gamma(__x);
+        }
+#endif
+
+      return __bet;
+    }
+
+    /**
+     *   @brief  Return the beta function \f$B(x,y)\f$ using
+     *           the log gamma functions.
+     * 
+     *   The beta function is defined by
+     *   @f[
+     *     B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
+     *   @f]
+     *
+     *   @param __x The first argument of the beta function.
+     *   @param __y The second argument of the beta function.
+     *   @return  The beta function.
+     */
+    template<typename _Tp>
+    _Tp
+    __beta_lgamma(_Tp __x, _Tp __y)
+    {
+#if _GLIBCXX_USE_C99_MATH_TR1
+      _Tp __bet = std::tr1::lgamma(__x)
+                + std::tr1::lgamma(__y)
+                - std::tr1::lgamma(__x + __y);
+#else
+      _Tp __bet = __log_gamma(__x)
+                + __log_gamma(__y)
+                - __log_gamma(__x + __y);
+#endif
+      __bet = std::exp(__bet);
+      return __bet;
+    }
+
+
+    /**
+     *   @brief  Return the beta function \f$B(x,y)\f$ using
+     *           the product form.
+     * 
+     *   The beta function is defined by
+     *   @f[
+     *     B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
+     *   @f]
+     *
+     *   @param __x The first argument of the beta function.
+     *   @param __y The second argument of the beta function.
+     *   @return  The beta function.
+     */
+    template<typename _Tp>
+    _Tp
+    __beta_product(_Tp __x, _Tp __y)
+    {
+
+      _Tp __bet = (__x + __y) / (__x * __y);
+
+      unsigned int __max_iter = 1000000;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          _Tp __term = (_Tp(1) + (__x + __y) / __k)
+                     / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k));
+          __bet *= __term;
+        }
+
+      return __bet;
+    }
+
+
+    /**
+     *   @brief  Return the beta function \f$ B(x,y) \f$.
+     * 
+     *   The beta function is defined by
+     *   @f[
+     *     B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
+     *   @f]
+     *
+     *   @param __x The first argument of the beta function.
+     *   @param __y The second argument of the beta function.
+     *   @return  The beta function.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __beta(_Tp __x, _Tp __y)
+    {
+      if (__isnan(__x) || __isnan(__y))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __beta_lgamma(__x, __y);
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // __GLIBCXX_TR1_BETA_FUNCTION_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/ccomplex b/gcc-4.9/libstdc++-v3/include/tr1/ccomplex
new file mode 100644
index 0000000..04b8a6f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/ccomplex
@@ -0,0 +1,34 @@
+// TR1 ccomplex -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/ccomplex
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CCOMPLEX
+#define _GLIBCXX_TR1_CCOMPLEX 1
+
+#include <tr1/complex>
+
+#endif // _GLIBCXX_TR1_CCOMPLEX
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cctype b/gcc-4.9/libstdc++-v3/include/tr1/cctype
new file mode 100644
index 0000000..02de895
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cctype
@@ -0,0 +1,49 @@
+// TR1 cctype -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cctype
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CCTYPE
+#define _GLIBCXX_TR1_CCTYPE 1
+
+#include <bits/c++config.h>
+#include <cctype>
+
+#ifdef _GLIBCXX_USE_C99_CTYPE_TR1
+
+#undef isblank
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  using ::isblank;
+}
+}
+
+#endif
+
+#endif // _GLIBCXX_TR1_CCTYPE
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cfenv b/gcc-4.9/libstdc++-v3/include/tr1/cfenv
new file mode 100644
index 0000000..dd6515e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cfenv
@@ -0,0 +1,81 @@
+// TR1 cfenv -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cfenv
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CFENV
+#define _GLIBCXX_TR1_CFENV 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_FENV_H
+# include <fenv.h>
+#endif
+
+#ifdef _GLIBCXX_USE_C99_FENV_TR1
+
+#undef feclearexcept
+#undef fegetexceptflag
+#undef feraiseexcept
+#undef fesetexceptflag
+#undef fetestexcept
+#undef fegetround
+#undef fesetround
+#undef fegetenv
+#undef feholdexcept
+#undef fesetenv
+#undef feupdateenv
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // types
+  using ::fenv_t;
+  using ::fexcept_t;
+
+  // functions
+  using ::feclearexcept;
+  using ::fegetexceptflag;
+  using ::feraiseexcept;
+  using ::fesetexceptflag;
+  using ::fetestexcept;
+
+  using ::fegetround;
+  using ::fesetround;
+
+  using ::fegetenv;
+  using ::feholdexcept;
+  using ::fesetenv;
+  using ::feupdateenv;
+}
+}
+
+#endif // _GLIBCXX_USE_C99_FENV_TR1
+
+#endif // _GLIBCXX_TR1_CFENV
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cfloat b/gcc-4.9/libstdc++-v3/include/tr1/cfloat
new file mode 100644
index 0000000..a316ebb
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cfloat
@@ -0,0 +1,42 @@
+// TR1 cfloat -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cfloat
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CFLOAT
+#define _GLIBCXX_TR1_CFLOAT 1
+
+#include <cfloat>
+
+#ifndef DECIMAL_DIG
+#define DECIMAL_DIG __DECIMAL_DIG__
+#endif
+
+#ifndef FLT_EVAL_METHOD
+#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+#endif
+
+#endif //_GLIBCXX_TR1_CFLOAT 
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cinttypes b/gcc-4.9/libstdc++-v3/include/tr1/cinttypes
new file mode 100644
index 0000000..3d28d0a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cinttypes
@@ -0,0 +1,84 @@
+// TR1 cinttypes -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cinttypes
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CINTTYPES
+#define _GLIBCXX_TR1_CINTTYPES 1
+
+#pragma GCC system_header
+
+#include <tr1/cstdint>
+
+// For 8.11.1/1 (see C99, Note 184)
+#if _GLIBCXX_HAVE_INTTYPES_H
+# ifndef __STDC_FORMAT_MACROS
+#  define _UNDEF__STDC_FORMAT_MACROS
+#  define __STDC_FORMAT_MACROS
+# endif
+# include <inttypes.h>
+# ifdef _UNDEF__STDC_FORMAT_MACROS
+#  undef __STDC_FORMAT_MACROS
+#  undef _UNDEF__STDC_FORMAT_MACROS
+# endif
+#endif
+
+#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // types
+  using ::imaxdiv_t;
+
+  // functions
+  using ::imaxabs;
+
+  // May collide with _Longlong abs(_Longlong), and is not described
+  // anywhere outside the synopsis.  Likely, a defect.
+  //
+  // intmax_t abs(intmax_t)
+
+  using ::imaxdiv;
+
+  // Likewise, with lldiv_t div(_Longlong, _Longlong).
+  //
+  // imaxdiv_t div(intmax_t, intmax_t)
+
+  using ::strtoimax;
+  using ::strtoumax;
+
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1
+  using ::wcstoimax;
+  using ::wcstoumax;
+#endif
+}
+}
+
+#endif // _GLIBCXX_USE_C99_INTTYPES_TR1
+
+#endif // _GLIBCXX_TR1_CINTTYPES
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/climits b/gcc-4.9/libstdc++-v3/include/tr1/climits
new file mode 100644
index 0000000..843db32
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/climits
@@ -0,0 +1,46 @@
+// TR1 climits -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/climits
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CLIMITS
+#define _GLIBCXX_TR1_CLIMITS 1
+
+#include <climits>
+
+#ifndef LLONG_MIN
+#define LLONG_MIN (-__LONG_LONG_MAX__ - 1)
+#endif
+
+#ifndef LLONG_MAX
+#define LLONG_MAX __LONG_LONG_MAX__
+#endif
+
+#ifndef ULLONG_MAX
+#define ULLONG_MAX (__LONG_LONG_MAX__ * 2ULL + 1)
+#endif
+
+#endif // _GLIBCXX_TR1_CLIMITS
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cmath b/gcc-4.9/libstdc++-v3/include/tr1/cmath
new file mode 100644
index 0000000..ea40656
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cmath
@@ -0,0 +1,1445 @@
+// TR1 cmath -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cmath
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CMATH
+#define _GLIBCXX_TR1_CMATH 1
+
+#pragma GCC system_header
+
+#include <cmath>
+
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+
+#undef acosh
+#undef acoshf
+#undef acoshl
+#undef asinh
+#undef asinhf
+#undef asinhl
+#undef atanh
+#undef atanhf
+#undef atanhl
+#undef cbrt
+#undef cbrtf
+#undef cbrtl
+#undef copysign
+#undef copysignf
+#undef copysignl
+#undef erf
+#undef erff
+#undef erfl
+#undef erfc
+#undef erfcf
+#undef erfcl
+#undef exp2
+#undef exp2f
+#undef exp2l
+#undef expm1
+#undef expm1f
+#undef expm1l
+#undef fdim
+#undef fdimf
+#undef fdiml
+#undef fma
+#undef fmaf
+#undef fmal
+#undef fmax
+#undef fmaxf
+#undef fmaxl
+#undef fmin
+#undef fminf
+#undef fminl
+#undef hypot
+#undef hypotf
+#undef hypotl
+#undef ilogb
+#undef ilogbf
+#undef ilogbl
+#undef lgamma
+#undef lgammaf
+#undef lgammal
+#undef llrint
+#undef llrintf
+#undef llrintl
+#undef llround
+#undef llroundf
+#undef llroundl
+#undef log1p
+#undef log1pf
+#undef log1pl
+#undef log2
+#undef log2f
+#undef log2l
+#undef logb
+#undef logbf
+#undef logbl
+#undef lrint
+#undef lrintf
+#undef lrintl
+#undef lround
+#undef lroundf
+#undef lroundl
+#undef nan
+#undef nanf
+#undef nanl
+#undef nearbyint
+#undef nearbyintf
+#undef nearbyintl
+#undef nextafter
+#undef nextafterf
+#undef nextafterl
+#undef nexttoward
+#undef nexttowardf
+#undef nexttowardl
+#undef remainder
+#undef remainderf
+#undef remainderl
+#undef remquo
+#undef remquof
+#undef remquol
+#undef rint
+#undef rintf
+#undef rintl
+#undef round
+#undef roundf
+#undef roundl
+#undef scalbln
+#undef scalblnf
+#undef scalblnl
+#undef scalbn
+#undef scalbnf
+#undef scalbnl
+#undef tgamma
+#undef tgammaf
+#undef tgammal
+#undef trunc
+#undef truncf
+#undef truncl
+
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+  // types
+  using ::double_t;
+  using ::float_t;
+
+  // functions
+  using ::acosh;
+  using ::acoshf;
+  using ::acoshl;
+
+  using ::asinh;
+  using ::asinhf;
+  using ::asinhl;
+
+  using ::atanh;
+  using ::atanhf;
+  using ::atanhl;
+
+  using ::cbrt;
+  using ::cbrtf;
+  using ::cbrtl;
+
+  using ::copysign;
+  using ::copysignf;
+  using ::copysignl;
+
+  using ::erf;
+  using ::erff;
+  using ::erfl;
+
+  using ::erfc;
+  using ::erfcf;
+  using ::erfcl;
+
+  using ::exp2;
+  using ::exp2f;
+  using ::exp2l;
+
+  using ::expm1;
+  using ::expm1f;
+  using ::expm1l;
+
+  using ::fdim;
+  using ::fdimf;
+  using ::fdiml;
+
+  using ::fma;
+  using ::fmaf;
+  using ::fmal;
+
+  using ::fmax;
+  using ::fmaxf;
+  using ::fmaxl;
+
+  using ::fmin;
+  using ::fminf;
+  using ::fminl;
+
+  using ::hypot;
+  using ::hypotf;
+  using ::hypotl;
+
+  using ::ilogb;
+  using ::ilogbf;
+  using ::ilogbl;
+
+  using ::lgamma;
+  using ::lgammaf;
+  using ::lgammal;
+
+  using ::llrint;
+  using ::llrintf;
+  using ::llrintl;
+
+  using ::llround;
+  using ::llroundf;
+  using ::llroundl;
+
+  using ::log1p;
+  using ::log1pf;
+  using ::log1pl;
+
+  using ::log2;
+  using ::log2f;
+  using ::log2l;
+
+  using ::logb;
+  using ::logbf;
+  using ::logbl;
+
+  using ::lrint;
+  using ::lrintf;
+  using ::lrintl;
+
+  using ::lround;
+  using ::lroundf;
+  using ::lroundl;
+
+  using ::nan;
+  using ::nanf;
+  using ::nanl;
+
+  using ::nearbyint;
+  using ::nearbyintf;
+  using ::nearbyintl;
+
+  using ::nextafter;
+  using ::nextafterf;
+  using ::nextafterl;
+
+  using ::nexttoward;
+  using ::nexttowardf;
+  using ::nexttowardl;
+
+  using ::remainder;
+  using ::remainderf;
+  using ::remainderl;
+
+  using ::remquo;
+  using ::remquof;
+  using ::remquol;
+
+  using ::rint;
+  using ::rintf;
+  using ::rintl;
+
+  using ::round;
+  using ::roundf;
+  using ::roundl;
+
+  using ::scalbln;
+  using ::scalblnf;
+  using ::scalblnl;
+
+  using ::scalbn;
+  using ::scalbnf;
+  using ::scalbnl;
+
+  using ::tgamma;
+  using ::tgammaf;
+  using ::tgammal;
+
+  using ::trunc;
+  using ::truncf;
+  using ::truncl;
+
+#endif
+
+#if _GLIBCXX_USE_C99_MATH
+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+
+  /// Function template definitions [8.16.3].
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    fpclassify(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+				  FP_SUBNORMAL, FP_ZERO, __type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isfinite(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isfinite(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isinf(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isinf(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isnan(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnan(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isnormal(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnormal(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    signbit(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_signbit(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isgreaterequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isless(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isless(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    islessequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    islessgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+					   int>::__type
+    isunordered(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isunordered(__type(__f1), __type(__f2));
+    }
+
+#endif
+#endif
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+  /// Additional overloads [8.16.4].
+  using std::acos;
+
+  inline float
+  acosh(float __x)
+  { return __builtin_acoshf(__x); }
+
+  inline long double
+  acosh(long double __x)
+  { return __builtin_acoshl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    acosh(_Tp __x)
+    { return __builtin_acosh(__x); }
+
+  using std::asin;
+
+  inline float
+  asinh(float __x)
+  { return __builtin_asinhf(__x); }
+
+  inline long double
+  asinh(long double __x)
+  { return __builtin_asinhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    asinh(_Tp __x)
+    { return __builtin_asinh(__x); }
+
+  using std::atan;
+  using std::atan2;
+
+  inline float
+  atanh(float __x)
+  { return __builtin_atanhf(__x); }
+
+  inline long double
+  atanh(long double __x)
+  { return __builtin_atanhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    atanh(_Tp __x)
+    { return __builtin_atanh(__x); }
+
+  inline float
+  cbrt(float __x)
+  { return __builtin_cbrtf(__x); }
+
+  inline long double
+  cbrt(long double __x)
+  { return __builtin_cbrtl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    cbrt(_Tp __x)
+    { return __builtin_cbrt(__x); }
+
+  using std::ceil;
+
+  inline float
+  copysign(float __x, float __y)
+  { return __builtin_copysignf(__x, __y); }
+
+  inline long double
+  copysign(long double __x, long double __y)
+  { return __builtin_copysignl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    copysign(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return copysign(__type(__x), __type(__y));
+    }
+
+  using std::cos;
+  using std::cosh;  
+
+  inline float
+  erf(float __x)
+  { return __builtin_erff(__x); }
+
+  inline long double
+  erf(long double __x)
+  { return __builtin_erfl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    erf(_Tp __x)
+    { return __builtin_erf(__x); }
+
+  inline float
+  erfc(float __x)
+  { return __builtin_erfcf(__x); }
+
+  inline long double
+  erfc(long double __x)
+  { return __builtin_erfcl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    erfc(_Tp __x)
+    { return __builtin_erfc(__x); }
+
+  using std::exp;
+
+  inline float
+  exp2(float __x)
+  { return __builtin_exp2f(__x); }
+
+  inline long double
+  exp2(long double __x)
+  { return __builtin_exp2l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    exp2(_Tp __x)
+    { return __builtin_exp2(__x); }
+
+  inline float
+  expm1(float __x)
+  { return __builtin_expm1f(__x); }
+
+  inline long double
+  expm1(long double __x)
+  { return __builtin_expm1l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    expm1(_Tp __x)
+    { return __builtin_expm1(__x); }
+
+  // Note: we deal with fabs in a special way, because an using std::fabs
+  // would bring in also the overloads for complex types, which in C++0x
+  // mode have a different return type.
+  // With __CORRECT_ISO_CPP_MATH_H_PROTO, math.h imports std::fabs in the
+  // global namespace after the declarations of the float / double / long
+  // double overloads but before the std::complex overloads.
+  using ::fabs;
+
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
+  inline float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+#endif
+
+  inline float
+  fdim(float __x, float __y)
+  { return __builtin_fdimf(__x, __y); }
+
+  inline long double
+  fdim(long double __x, long double __y)
+  { return __builtin_fdiml(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fdim(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fdim(__type(__x), __type(__y));
+    }
+
+  using std::floor;
+
+  inline float
+  fma(float __x, float __y, float __z)
+  { return __builtin_fmaf(__x, __y, __z); }
+
+  inline long double
+  fma(long double __x, long double __y, long double __z)
+  { return __builtin_fmal(__x, __y, __z); }
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    fma(_Tp __x, _Up __y, _Vp __z)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+      return fma(__type(__x), __type(__y), __type(__z));
+    }
+
+  inline float
+  fmax(float __x, float __y)
+  { return __builtin_fmaxf(__x, __y); }
+
+  inline long double
+  fmax(long double __x, long double __y)
+  { return __builtin_fmaxl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmax(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmax(__type(__x), __type(__y));
+    }
+
+  inline float
+  fmin(float __x, float __y)
+  { return __builtin_fminf(__x, __y); }
+
+  inline long double
+  fmin(long double __x, long double __y)
+  { return __builtin_fminl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmin(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmin(__type(__x), __type(__y));
+    }
+
+  using std::fmod;
+  using std::frexp;
+
+  inline float
+  hypot(float __x, float __y)
+  { return __builtin_hypotf(__x, __y); }
+
+  inline long double
+  hypot(long double __x, long double __y)
+  { return __builtin_hypotl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    hypot(_Tp __y, _Up __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return hypot(__type(__y), __type(__x));
+    }
+
+  inline int
+  ilogb(float __x)
+  { return __builtin_ilogbf(__x); }
+
+  inline int
+  ilogb(long double __x)
+  { return __builtin_ilogbl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   int>::__type
+    ilogb(_Tp __x)
+    { return __builtin_ilogb(__x); }
+
+  using std::ldexp;
+
+  inline float
+  lgamma(float __x)
+  { return __builtin_lgammaf(__x); }
+
+  inline long double
+  lgamma(long double __x)
+  { return __builtin_lgammal(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    lgamma(_Tp __x)
+    { return __builtin_lgamma(__x); }
+
+  inline long long
+  llrint(float __x)
+  { return __builtin_llrintf(__x); }
+
+  inline long long
+  llrint(long double __x)
+  { return __builtin_llrintl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   long long>::__type
+    llrint(_Tp __x)
+    { return __builtin_llrint(__x); }
+
+  inline long long
+  llround(float __x)
+  { return __builtin_llroundf(__x); }
+
+  inline long long
+  llround(long double __x)
+  { return __builtin_llroundl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   long long>::__type
+    llround(_Tp __x)
+    { return __builtin_llround(__x); }
+
+  using std::log;
+  using std::log10;
+
+  inline float
+  log1p(float __x)
+  { return __builtin_log1pf(__x); }
+
+  inline long double
+  log1p(long double __x)
+  { return __builtin_log1pl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    log1p(_Tp __x)
+    { return __builtin_log1p(__x); }
+
+  // DR 568.
+  inline float
+  log2(float __x)
+  { return __builtin_log2f(__x); }
+
+  inline long double
+  log2(long double __x)
+  { return __builtin_log2l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    log2(_Tp __x)
+    { return __builtin_log2(__x); }
+
+  inline float
+  logb(float __x)
+  { return __builtin_logbf(__x); }
+
+  inline long double
+  logb(long double __x)
+  { return __builtin_logbl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    logb(_Tp __x)
+    {
+      return __builtin_logb(__x);
+    }
+
+  inline long
+  lrint(float __x)
+  { return __builtin_lrintf(__x); }
+
+  inline long
+  lrint(long double __x)
+  { return __builtin_lrintl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   long>::__type
+    lrint(_Tp __x)
+    { return __builtin_lrint(__x); }
+
+  inline long
+  lround(float __x)
+  { return __builtin_lroundf(__x); }
+
+  inline long
+  lround(long double __x)
+  { return __builtin_lroundl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   long>::__type
+    lround(_Tp __x)
+    { return __builtin_lround(__x); }
+
+  inline float
+  nearbyint(float __x)
+  { return __builtin_nearbyintf(__x); }
+
+  inline long double
+  nearbyint(long double __x)
+  { return __builtin_nearbyintl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    nearbyint(_Tp __x)
+    { return __builtin_nearbyint(__x); }
+
+  inline float
+  nextafter(float __x, float __y)
+  { return __builtin_nextafterf(__x, __y); }
+
+  inline long double
+  nextafter(long double __x, long double __y)
+  { return __builtin_nextafterl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    nextafter(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return nextafter(__type(__x), __type(__y));
+    }
+
+  inline float
+  nexttoward(float __x, long double __y)
+  { return __builtin_nexttowardf(__x, __y); }
+
+  inline long double
+  nexttoward(long double __x, long double __y)
+  { return __builtin_nexttowardl(__x, __y); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    nexttoward(_Tp __x, long double __y)
+    { return __builtin_nexttoward(__x, __y); }
+
+  inline float
+  remainder(float __x, float __y)
+  { return __builtin_remainderf(__x, __y); }
+
+  inline long double
+  remainder(long double __x, long double __y)
+  { return __builtin_remainderl(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remainder(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remainder(__type(__x), __type(__y));
+    }
+
+  inline float
+  remquo(float __x, float __y, int* __pquo)
+  { return __builtin_remquof(__x, __y, __pquo); }
+
+  inline long double
+  remquo(long double __x, long double __y, int* __pquo)
+  { return __builtin_remquol(__x, __y, __pquo); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remquo(_Tp __x, _Up __y, int* __pquo)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remquo(__type(__x), __type(__y), __pquo);
+    }
+
+  inline float
+  rint(float __x)
+  { return __builtin_rintf(__x); }
+
+  inline long double
+  rint(long double __x)
+  { return __builtin_rintl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    rint(_Tp __x)
+    { return __builtin_rint(__x); }
+
+  inline float
+  round(float __x)
+  { return __builtin_roundf(__x); }
+
+  inline long double
+  round(long double __x)
+  { return __builtin_roundl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    round(_Tp __x)
+    { return __builtin_round(__x); }
+
+  inline float
+  scalbln(float __x, long __ex)
+  { return __builtin_scalblnf(__x, __ex); }
+
+  inline long double
+  scalbln(long double __x, long __ex)
+  { return __builtin_scalblnl(__x, __ex); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    scalbln(_Tp __x, long __ex)
+    { return __builtin_scalbln(__x, __ex); }
+ 
+  inline float
+  scalbn(float __x, int __ex)
+  { return __builtin_scalbnf(__x, __ex); }
+
+  inline long double
+  scalbn(long double __x, int __ex)
+  { return __builtin_scalbnl(__x, __ex); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    scalbn(_Tp __x, int __ex)
+    { return __builtin_scalbn(__x, __ex); }
+
+  using std::sin;
+  using std::sinh;
+  using std::sqrt;
+  using std::tan;
+  using std::tanh;
+
+  inline float
+  tgamma(float __x)
+  { return __builtin_tgammaf(__x); }
+
+  inline long double
+  tgamma(long double __x)
+  { return __builtin_tgammal(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    tgamma(_Tp __x)
+    { return __builtin_tgamma(__x); }
+ 
+  inline float
+  trunc(float __x)
+  { return __builtin_truncf(__x); }
+
+  inline long double
+  trunc(long double __x)
+  { return __builtin_truncl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
+					   double>::__type
+    trunc(_Tp __x)
+    { return __builtin_trunc(__x); }
+
+#endif
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // DR 550. What should the return type of pow(float,int) be?
+  // NB: C++0x and TR1 != C++03.
+
+  // The std::tr1::pow(double, double) overload cannot be provided
+  // here, because it would clash with ::pow(double,double) declared
+  // in <math.h>, if <tr1/math.h> is included at the same time (raised
+  // by the fix of PR c++/54537). It is not possible either to use the
+  // using-declaration 'using ::pow;' here, because if the user code
+  // has a 'using std::pow;', it would bring the pow(*,int) averloads
+  // in the tr1 namespace, which is undesirable. Consequently, the
+  // solution is to forward std::tr1::pow(double,double) to
+  // std::pow(double,double) via the templatized version below. See
+  // the discussion about this issue here:
+  // http://gcc.gnu.org/ml/gcc-patches/2012-09/msg01278.html
+
+  inline float
+  pow(float __x, float __y)
+  { return std::pow(__x, __y); }
+
+  inline long double
+  pow(long double __x, long double __y)
+  { return std::pow(__x, __y); }
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(__type(__x), __type(__y));
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#include <bits/stl_algobase.h>
+#include <limits>
+#include <tr1/type_traits>
+
+#include <tr1/gamma.tcc>
+#include <tr1/bessel_function.tcc>
+#include <tr1/beta_function.tcc>
+#include <tr1/ell_integral.tcc>
+#include <tr1/exp_integral.tcc>
+#include <tr1/hypergeometric.tcc>
+#include <tr1/legendre_function.tcc>
+#include <tr1/modified_bessel_func.tcc>
+#include <tr1/poly_hermite.tcc>
+#include <tr1/poly_laguerre.tcc>
+#include <tr1/riemann_zeta.tcc>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @defgroup tr1_math_spec_func Mathematical Special Functions
+   * @ingroup numerics
+   *
+   * A collection of advanced mathematical special functions.
+   * @{
+   */
+
+  inline float
+  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
+  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
+
+  inline long double
+  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
+  {
+    return __detail::__assoc_laguerre<long double>(__n, __m, __x);
+  }
+
+  ///  5.2.1.1  Associated Laguerre polynomials.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__assoc_laguerre<__type>(__n, __m, __x);
+    }
+
+  inline float
+  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
+  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
+
+  inline long double
+  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
+  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
+
+  ///  5.2.1.2  Associated Legendre functions.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
+    }
+
+  inline float
+  betaf(float __x, float __y)
+  { return __detail::__beta<float>(__x, __y); }
+
+  inline long double
+  betal(long double __x, long double __y)
+  { return __detail::__beta<long double>(__x, __y); }
+
+  ///  5.2.1.3  Beta functions.
+  template<typename _Tpx, typename _Tpy>
+    inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type
+    beta(_Tpx __x, _Tpy __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type;
+      return __detail::__beta<__type>(__x, __y);
+    }
+
+  inline float
+  comp_ellint_1f(float __k)
+  { return __detail::__comp_ellint_1<float>(__k); }
+
+  inline long double
+  comp_ellint_1l(long double __k)
+  { return __detail::__comp_ellint_1<long double>(__k); }
+
+  ///  5.2.1.4  Complete elliptic integrals of the first kind.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    comp_ellint_1(_Tp __k)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__comp_ellint_1<__type>(__k);
+    }
+
+  inline float
+  comp_ellint_2f(float __k)
+  { return __detail::__comp_ellint_2<float>(__k); }
+
+  inline long double
+  comp_ellint_2l(long double __k)
+  { return __detail::__comp_ellint_2<long double>(__k); }
+
+  ///  5.2.1.5  Complete elliptic integrals of the second kind.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    comp_ellint_2(_Tp __k)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__comp_ellint_2<__type>(__k);
+    }
+
+  inline float
+  comp_ellint_3f(float __k, float __nu)
+  { return __detail::__comp_ellint_3<float>(__k, __nu); }
+
+  inline long double
+  comp_ellint_3l(long double __k, long double __nu)
+  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
+
+  ///  5.2.1.6  Complete elliptic integrals of the third kind.
+  template<typename _Tp, typename _Tpn>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
+    comp_ellint_3(_Tp __k, _Tpn __nu)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
+      return __detail::__comp_ellint_3<__type>(__k, __nu);
+    }
+
+  inline float
+  conf_hypergf(float __a, float __c, float __x)
+  { return __detail::__conf_hyperg<float>(__a, __c, __x); }
+
+  inline long double
+  conf_hypergl(long double __a, long double __c, long double __x)
+  { return __detail::__conf_hyperg<long double>(__a, __c, __x); }
+
+  ///  5.2.1.7  Confluent hypergeometric functions.
+  template<typename _Tpa, typename _Tpc, typename _Tp>
+    inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
+    conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
+      return __detail::__conf_hyperg<__type>(__a, __c, __x);
+    }
+
+  inline float
+  cyl_bessel_if(float __nu, float __x)
+  { return __detail::__cyl_bessel_i<float>(__nu, __x); }
+
+  inline long double
+  cyl_bessel_il(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
+
+  ///  5.2.1.8  Regular modified cylindrical Bessel functions.
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_i(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_i<__type>(__nu, __x);
+    }
+
+  inline float
+  cyl_bessel_jf(float __nu, float __x)
+  { return __detail::__cyl_bessel_j<float>(__nu, __x); }
+
+  inline long double
+  cyl_bessel_jl(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
+
+  ///  5.2.1.9  Cylindrical Bessel functions (of the first kind).
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_j(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_j<__type>(__nu, __x);
+    }
+
+  inline float
+  cyl_bessel_kf(float __nu, float __x)
+  { return __detail::__cyl_bessel_k<float>(__nu, __x); }
+
+  inline long double
+  cyl_bessel_kl(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
+
+  ///  5.2.1.10  Irregular modified cylindrical Bessel functions.
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_k(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_k<__type>(__nu, __x);
+    }
+
+  inline float
+  cyl_neumannf(float __nu, float __x)
+  { return __detail::__cyl_neumann_n<float>(__nu, __x); }
+
+  inline long double
+  cyl_neumannl(long double __nu, long double __x)
+  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
+
+  ///  5.2.1.11  Cylindrical Neumann functions.
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_neumann(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_neumann_n<__type>(__nu, __x);
+    }
+
+  inline float
+  ellint_1f(float __k, float __phi)
+  { return __detail::__ellint_1<float>(__k, __phi); }
+
+  inline long double
+  ellint_1l(long double __k, long double __phi)
+  { return __detail::__ellint_1<long double>(__k, __phi); }
+
+  ///  5.2.1.12  Incomplete elliptic integrals of the first kind.
+  template<typename _Tp, typename _Tpp>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
+    ellint_1(_Tp __k, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
+      return __detail::__ellint_1<__type>(__k, __phi);
+    }
+
+  inline float
+  ellint_2f(float __k, float __phi)
+  { return __detail::__ellint_2<float>(__k, __phi); }
+
+  inline long double
+  ellint_2l(long double __k, long double __phi)
+  { return __detail::__ellint_2<long double>(__k, __phi); }
+
+  ///  5.2.1.13  Incomplete elliptic integrals of the second kind.
+  template<typename _Tp, typename _Tpp>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
+    ellint_2(_Tp __k, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
+      return __detail::__ellint_2<__type>(__k, __phi);
+    }
+
+  inline float
+  ellint_3f(float __k, float __nu, float __phi)
+  { return __detail::__ellint_3<float>(__k, __nu, __phi); }
+
+  inline long double
+  ellint_3l(long double __k, long double __nu, long double __phi)
+  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
+
+  ///  5.2.1.14  Incomplete elliptic integrals of the third kind.
+  template<typename _Tp, typename _Tpn, typename _Tpp>
+    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
+    ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
+      return __detail::__ellint_3<__type>(__k, __nu, __phi);
+    }
+
+  inline float
+  expintf(float __x)
+  { return __detail::__expint<float>(__x); }
+
+  inline long double
+  expintl(long double __x)
+  { return __detail::__expint<long double>(__x); }
+
+  ///  5.2.1.15  Exponential integrals.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    expint(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__expint<__type>(__x);
+    }
+
+  inline float
+  hermitef(unsigned int __n, float __x)
+  { return __detail::__poly_hermite<float>(__n, __x); }
+
+  inline long double
+  hermitel(unsigned int __n, long double __x)
+  { return __detail::__poly_hermite<long double>(__n, __x); }
+
+  ///  5.2.1.16  Hermite polynomials.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    hermite(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__poly_hermite<__type>(__n, __x);
+    }
+
+  inline float
+  hypergf(float __a, float __b, float __c, float __x)
+  { return __detail::__hyperg<float>(__a, __b, __c, __x); }
+
+  inline long double
+  hypergl(long double __a, long double __b, long double __c, long double __x)
+  { return __detail::__hyperg<long double>(__a, __b, __c, __x); }
+
+  ///  5.2.1.17  Hypergeometric functions.
+  template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
+    inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
+    hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
+      return __detail::__hyperg<__type>(__a, __b, __c, __x);
+    }
+
+  inline float
+  laguerref(unsigned int __n, float __x)
+  { return __detail::__laguerre<float>(__n, __x); }
+
+  inline long double
+  laguerrel(unsigned int __n, long double __x)
+  { return __detail::__laguerre<long double>(__n, __x); }
+
+  ///  5.2.1.18  Laguerre polynomials.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    laguerre(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__laguerre<__type>(__n, __x);
+    }
+
+  inline float
+  legendref(unsigned int __n, float __x)
+  { return __detail::__poly_legendre_p<float>(__n, __x); }
+
+  inline long double
+  legendrel(unsigned int __n, long double __x)
+  { return __detail::__poly_legendre_p<long double>(__n, __x); }
+
+  ///  5.2.1.19  Legendre polynomials.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    legendre(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__poly_legendre_p<__type>(__n, __x);
+    }
+
+  inline float
+  riemann_zetaf(float __x)
+  { return __detail::__riemann_zeta<float>(__x); }
+
+  inline long double
+  riemann_zetal(long double __x)
+  { return __detail::__riemann_zeta<long double>(__x); }
+
+  ///  5.2.1.20  Riemann zeta function.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    riemann_zeta(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__riemann_zeta<__type>(__x);
+    }
+
+  inline float
+  sph_besself(unsigned int __n, float __x)
+  { return __detail::__sph_bessel<float>(__n, __x); }
+
+  inline long double
+  sph_bessell(unsigned int __n, long double __x)
+  { return __detail::__sph_bessel<long double>(__n, __x); }
+
+  ///  5.2.1.21  Spherical Bessel functions.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_bessel(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_bessel<__type>(__n, __x);
+    }
+
+  inline float
+  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
+  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
+
+  inline long double
+  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
+  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
+
+  ///  5.2.1.22  Spherical associated Legendre functions.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_legendre<__type>(__l, __m, __theta);
+    }
+
+  inline float
+  sph_neumannf(unsigned int __n, float __x)
+  { return __detail::__sph_neumann<float>(__n, __x); }
+
+  inline long double
+  sph_neumannl(unsigned int __n, long double __x)
+  { return __detail::__sph_neumann<long double>(__n, __x); }
+
+  ///  5.2.1.23  Spherical Neumann functions.
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_neumann(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_neumann<__type>(__n, __x);
+    }
+
+  /* @} */ // tr1_math_spec_func
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_CMATH
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/complex b/gcc-4.9/libstdc++-v3/include/tr1/complex
new file mode 100644
index 0000000..fae2b02
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/complex
@@ -0,0 +1,418 @@
+// TR1 complex -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/complex
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_COMPLEX
+#define _GLIBCXX_TR1_COMPLEX 1
+
+#pragma GCC system_header
+
+#include <complex>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup complex_numbers
+   * @{
+   */
+
+#if __cplusplus >= 201103L
+  using std::acos;
+  using std::asin;
+  using std::atan;
+#else
+  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
+#endif
+
+  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
+
+  // The std::fabs return type in C++0x mode is different (just _Tp).
+  template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
+
+#if __cplusplus < 201103L
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_acos(const std::complex<_Tp>& __z)
+    {
+      const std::complex<_Tp> __t = std::tr1::asin(__z);
+      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
+      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_acos(__complex__ float __z)
+  { return __builtin_cacosf(__z); }
+
+  inline __complex__ double
+  __complex_acos(__complex__ double __z)
+  { return __builtin_cacos(__z); }
+
+  inline __complex__ long double
+  __complex_acos(const __complex__ long double& __z)
+  { return __builtin_cacosl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acos(const std::complex<_Tp>& __z)
+    { return __complex_acos(__z.__rep()); }
+#else
+  /// acos(__z) [8.1.2].
+  //  Effects:  Behaves the same as C99 function cacos, defined
+  //            in subclause 7.3.5.1.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acos(const std::complex<_Tp>& __z)
+    { return __complex_acos(__z); }
+#endif
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_asin(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t(-__z.imag(), __z.real());
+      __t = std::tr1::asinh(__t);
+      return std::complex<_Tp>(__t.imag(), -__t.real());
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_asin(__complex__ float __z)
+  { return __builtin_casinf(__z); }
+
+  inline __complex__ double
+  __complex_asin(__complex__ double __z)
+  { return __builtin_casin(__z); }
+
+  inline __complex__ long double
+  __complex_asin(const __complex__ long double& __z)
+  { return __builtin_casinl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asin(const std::complex<_Tp>& __z)
+    { return __complex_asin(__z.__rep()); }
+#else
+  /// asin(__z) [8.1.3].
+  //  Effects:  Behaves the same as C99 function casin, defined
+  //            in subclause 7.3.5.2.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asin(const std::complex<_Tp>& __z)
+    { return __complex_asin(__z); }
+#endif
+  
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atan(const std::complex<_Tp>& __z)
+    {
+      const _Tp __r2 = __z.real() * __z.real();
+      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
+
+      _Tp __num = __z.imag() + _Tp(1.0);
+      _Tp __den = __z.imag() - _Tp(1.0);
+
+      __num = __r2 + __num * __num;
+      __den = __r2 + __den * __den;
+
+      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
+			       _Tp(0.25) * log(__num / __den));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_atan(__complex__ float __z)
+  { return __builtin_catanf(__z); }
+
+  inline __complex__ double
+  __complex_atan(__complex__ double __z)
+  { return __builtin_catan(__z); }
+
+  inline __complex__ long double
+  __complex_atan(const __complex__ long double& __z)
+  { return __builtin_catanl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atan(const std::complex<_Tp>& __z)
+    { return __complex_atan(__z.__rep()); }
+#else
+  /// atan(__z) [8.1.4].
+  //  Effects:  Behaves the same as C99 function catan, defined
+  //            in subclause 7.3.5.3.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atan(const std::complex<_Tp>& __z)
+    { return __complex_atan(__z); }
+#endif
+
+#endif // C++11
+
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_acosh(const std::complex<_Tp>& __z)
+    {
+      // Kahan's formula.
+      return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
+				 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_acosh(__complex__ float __z)
+  { return __builtin_cacoshf(__z); }
+
+  inline __complex__ double
+  __complex_acosh(__complex__ double __z)
+  { return __builtin_cacosh(__z); }
+
+  inline __complex__ long double
+  __complex_acosh(const __complex__ long double& __z)
+  { return __builtin_cacoshl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acosh(const std::complex<_Tp>& __z)
+    { return __complex_acosh(__z.__rep()); }
+#else
+  /// acosh(__z) [8.1.5].
+  //  Effects:  Behaves the same as C99 function cacosh, defined
+  //            in subclause 7.3.6.1.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acosh(const std::complex<_Tp>& __z)
+    { return __complex_acosh(__z); }
+#endif
+
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_asinh(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t((__z.real() - __z.imag())
+			    * (__z.real() + __z.imag()) + _Tp(1.0),
+			    _Tp(2.0) * __z.real() * __z.imag());
+      __t = std::sqrt(__t);
+
+      return std::log(__t + __z);
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_asinh(__complex__ float __z)
+  { return __builtin_casinhf(__z); }
+
+  inline __complex__ double
+  __complex_asinh(__complex__ double __z)
+  { return __builtin_casinh(__z); }
+
+  inline __complex__ long double
+  __complex_asinh(const __complex__ long double& __z)
+  { return __builtin_casinhl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asinh(const std::complex<_Tp>& __z)
+    { return __complex_asinh(__z.__rep()); }
+#else
+  /// asinh(__z) [8.1.6].
+  //  Effects:  Behaves the same as C99 function casin, defined
+  //            in subclause 7.3.6.2.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asinh(const std::complex<_Tp>& __z)
+    { return __complex_asinh(__z); }
+#endif
+
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atanh(const std::complex<_Tp>& __z)
+    {
+      const _Tp __i2 = __z.imag() * __z.imag();
+      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
+
+      _Tp __num = _Tp(1.0) + __z.real();
+      _Tp __den = _Tp(1.0) - __z.real();
+
+      __num = __i2 + __num * __num;
+      __den = __i2 + __den * __den;
+
+      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
+			       _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
+    }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+  inline __complex__ float
+  __complex_atanh(__complex__ float __z)
+  { return __builtin_catanhf(__z); }
+
+  inline __complex__ double
+  __complex_atanh(__complex__ double __z)
+  { return __builtin_catanh(__z); }
+
+  inline __complex__ long double
+  __complex_atanh(const __complex__ long double& __z)
+  { return __builtin_catanhl(__z); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atanh(const std::complex<_Tp>& __z)
+    { return __complex_atanh(__z.__rep()); }
+#else
+  /// atanh(__z) [8.1.7].
+  //  Effects:  Behaves the same as C99 function catanh, defined
+  //            in subclause 7.3.6.3.
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atanh(const std::complex<_Tp>& __z)
+    { return __complex_atanh(__z); }
+#endif
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    /// fabs(__z) [8.1.8].
+    //  Effects:  Behaves the same as C99 function cabs, defined
+    //            in subclause 7.3.8.1.
+    fabs(const std::complex<_Tp>& __z)
+    { return std::abs(__z); }
+
+  /// Additional overloads [8.1.9].
+#if __cplusplus < 201103L
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    arg(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
+      return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
+	                       : __type();
+#else
+      return std::arg(std::complex<__type>(__x));
+#endif
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    imag(_Tp)
+    { return _Tp(); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    norm(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __type(__x) * __type(__x);
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    real(_Tp __x)
+    { return __x; }
+
+#endif
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const _Up& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x), __type(__y));
+    }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const _Tp& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(__type(__x), std::complex<__type>(__y));
+    }
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x),
+		      std::complex<__type>(__y));
+    }
+
+  using std::arg;
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    conj(const std::complex<_Tp>& __z)
+    { return std::conj(__z); }  
+
+  template<typename _Tp>
+    inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
+    conj(_Tp __x)
+    { return __x; }
+
+  using std::imag;
+  using std::norm;
+  using std::polar;
+
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    polar(const _Tp& __rho, const _Up& __theta)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::polar(__type(__rho), __type(__theta));
+    }
+
+  using std::real;
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    pow(const std::complex<_Tp>& __x, const _Tp& __y)
+    { return std::pow(__x, __y); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    pow(const _Tp& __x, const std::complex<_Tp>& __y)
+    { return std::pow(__x, __y); }
+
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    pow(const std::complex<_Tp>& __x, const std::complex<_Tp>& __y)
+    { return std::pow(__x, __y); }
+
+// @} group complex_numbers
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_COMPLEX
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/complex.h b/gcc-4.9/libstdc++-v3/include/tr1/complex.h
new file mode 100644
index 0000000..1d06cc6
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/complex.h
@@ -0,0 +1,34 @@
+// TR1 complex.h -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/complex.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_COMPLEX_H
+#define _GLIBCXX_TR1_COMPLEX_H 1
+
+#include <tr1/ccomplex>
+
+#endif // _GLIBCXX_TR1_COMPLEX_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cstdarg b/gcc-4.9/libstdc++-v3/include/tr1/cstdarg
new file mode 100644
index 0000000..eae651e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cstdarg
@@ -0,0 +1,34 @@
+// TR1 cstdarg -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cstdarg
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDARG
+#define _GLIBCXX_TR1_CSTDARG 1
+
+#include <cstdarg>
+
+#endif // _GLIBCXX_TR1_CSTDARG
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cstdbool b/gcc-4.9/libstdc++-v3/include/tr1/cstdbool
new file mode 100644
index 0000000..8a8c274
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cstdbool
@@ -0,0 +1,40 @@
+// TR1 cstdbool -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cstdbool
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDBOOL
+#define _GLIBCXX_TR1_CSTDBOOL 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_STDBOOL_H
+#include <stdbool.h>
+#endif
+
+#endif // _GLIBCXX_TR1_CSTDBOOL
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cstdint b/gcc-4.9/libstdc++-v3/include/tr1/cstdint
new file mode 100644
index 0000000..90449aa
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cstdint
@@ -0,0 +1,104 @@
+// TR1 cstdint -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cstdint
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDINT
+#define _GLIBCXX_TR1_CSTDINT 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+// For 8.22.1/1 (see C99, Notes 219, 220, 222)
+# if _GLIBCXX_HAVE_STDINT_H
+#  ifndef __STDC_LIMIT_MACROS
+#   define _UNDEF__STDC_LIMIT_MACROS
+#   define __STDC_LIMIT_MACROS
+#  endif
+#  ifndef __STDC_CONSTANT_MACROS
+#   define _UNDEF__STDC_CONSTANT_MACROS
+#   define __STDC_CONSTANT_MACROS
+#  endif
+#  include <stdint.h>
+#  ifdef _UNDEF__STDC_LIMIT_MACROS
+#   undef __STDC_LIMIT_MACROS
+#   undef _UNDEF__STDC_LIMIT_MACROS
+#  endif
+#  ifdef _UNDEF__STDC_CONSTANT_MACROS
+#   undef __STDC_CONSTANT_MACROS
+#   undef _UNDEF__STDC_CONSTANT_MACROS
+#  endif
+# endif
+
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  using ::int8_t;
+  using ::int16_t;
+  using ::int32_t;
+  using ::int64_t;
+
+  using ::int_fast8_t;
+  using ::int_fast16_t;
+  using ::int_fast32_t;
+  using ::int_fast64_t;
+
+  using ::int_least8_t;
+  using ::int_least16_t;
+  using ::int_least32_t;
+  using ::int_least64_t;
+
+  using ::intmax_t;
+  using ::intptr_t;
+  
+  using ::uint8_t;
+  using ::uint16_t;
+  using ::uint32_t;
+  using ::uint64_t;
+
+  using ::uint_fast8_t;
+  using ::uint_fast16_t;
+  using ::uint_fast32_t;
+  using ::uint_fast64_t;
+
+  using ::uint_least8_t;
+  using ::uint_least16_t;
+  using ::uint_least32_t;
+  using ::uint_least64_t;
+
+  using ::uintmax_t;
+  using ::uintptr_t;
+}
+}
+
+#endif // _GLIBCXX_USE_C99_STDINT_TR1
+
+#endif // _GLIBCXX_TR1_CSTDINT
+
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cstdio b/gcc-4.9/libstdc++-v3/include/tr1/cstdio
new file mode 100644
index 0000000..b320ffd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cstdio
@@ -0,0 +1,53 @@
+// TR1 cstdio -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cstdio
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDIO
+#define _GLIBCXX_TR1_CSTDIO 1
+
+#pragma GCC system_header
+
+#include <cstdio>
+
+#if _GLIBCXX_USE_C99
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  using std::snprintf;
+  using std::vsnprintf;
+
+  using std::vfscanf;
+  using std::vscanf;
+  using std::vsscanf;
+}
+}
+
+#endif
+
+#endif // _GLIBCXX_TR1_CSTDIO
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cstdlib b/gcc-4.9/libstdc++-v3/include/tr1/cstdlib
new file mode 100644
index 0000000..fa4d93e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cstdlib
@@ -0,0 +1,72 @@
+// TR1 cstdlib -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cstdlib
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDLIB
+#define _GLIBCXX_TR1_CSTDLIB 1
+
+#pragma GCC system_header
+
+#include <cstdlib>
+
+#if _GLIBCXX_HOSTED
+
+#if _GLIBCXX_USE_C99
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  // types
+  using std::lldiv_t;
+
+  // functions
+  using std::llabs;
+  using std::lldiv;
+#endif
+
+  using std::atoll;
+  using std::strtoll;
+  using std::strtoull;
+
+  using std::strtof;
+  using std::strtold;
+
+  // overloads
+  using std::abs;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+  using std::div;
+#endif
+}
+}
+
+#endif // _GLIBCXX_USE_C99 
+
+#endif // _GLIBCXX_HOSTED
+
+#endif // _GLIBCXX_TR1_CSTDLIB
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/ctgmath b/gcc-4.9/libstdc++-v3/include/tr1/ctgmath
new file mode 100644
index 0000000..b672895
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/ctgmath
@@ -0,0 +1,34 @@
+// TR1 ctgmath -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/ctgmath
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CTGMATH
+#define _GLIBCXX_TR1_CTGMATH 1
+
+#include <tr1/cmath>
+
+#endif // _GLIBCXX_TR1_CTGMATH
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/ctime b/gcc-4.9/libstdc++-v3/include/tr1/ctime
new file mode 100644
index 0000000..33369ea
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/ctime
@@ -0,0 +1,34 @@
+// TR1 ctime -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/ctime
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CTIME
+#define _GLIBCXX_TR1_CTIME 1
+
+#include <ctime>
+
+#endif // _GLIBCXX_TR1_CTIME
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/ctype.h b/gcc-4.9/libstdc++-v3/include/tr1/ctype.h
new file mode 100644
index 0000000..7890eff
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/ctype.h
@@ -0,0 +1,34 @@
+// TR1 ctype.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/ctype.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_CTYPE_H
+#define _TR1_CTYPE_H 1
+
+#include <tr1/cctype>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cwchar b/gcc-4.9/libstdc++-v3/include/tr1/cwchar
new file mode 100644
index 0000000..4482574
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cwchar
@@ -0,0 +1,65 @@
+// TR1 cwchar -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cwchar
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CWCHAR
+#define _GLIBCXX_TR1_CWCHAR 1
+
+#pragma GCC system_header
+
+#include <cwchar>
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+#if _GLIBCXX_HAVE_WCSTOF
+  using std::wcstof;
+#endif
+#if _GLIBCXX_HAVE_VFWSCANF
+  using std::vfwscanf;
+#endif
+#if _GLIBCXX_HAVE_VSWSCANF
+  using std::vswscanf;
+#endif
+#if _GLIBCXX_HAVE_VWSCANF
+  using std::vwscanf;
+#endif
+
+#if _GLIBCXX_USE_C99
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoull;
+#endif
+}
+}
+
+#endif // _GLIBCXX_USE_WCHAR_T
+
+#endif // _GLIBCXX_TR1_CWCHAR
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/cwctype b/gcc-4.9/libstdc++-v3/include/tr1/cwctype
new file mode 100644
index 0000000..31b7fe1
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/cwctype
@@ -0,0 +1,50 @@
+// TR1 cwctype -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/cwctype
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CWCTYPE
+#define _GLIBCXX_TR1_CWCTYPE 1
+
+#pragma GCC system_header
+
+#include <cwctype>
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+#if _GLIBCXX_HAVE_ISWBLANK
+  using std::iswblank;
+#endif  
+}
+}
+
+#endif // _GLIBCXX_USE_WCHAR_T
+
+#endif // _GLIBCXX_TR1_CWCTYPE
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/ell_integral.tcc b/gcc-4.9/libstdc++-v3/include/tr1/ell_integral.tcc
new file mode 100644
index 0000000..55ac375
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/ell_integral.tcc
@@ -0,0 +1,750 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/ell_integral.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1)  B. C. Carlson Numer. Math. 33, 1 (1979)
+//   (2)  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+//   (3)  The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (4)  Numerical Recipes in C, 2nd ed, by W. H. Press, S. A. Teukolsky,
+//        W. T. Vetterling, B. P. Flannery, Cambridge University Press
+//        (1992), pp. 261-269
+
+#ifndef _GLIBCXX_TR1_ELL_INTEGRAL_TCC
+#define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief Return the Carlson elliptic function @f$ R_F(x,y,z) @f$
+     *          of the first kind.
+     * 
+     *   The Carlson elliptic function of the first kind is defined by:
+     *   @f[
+     *       R_F(x,y,z) = \frac{1}{2} \int_0^\infty
+     *                 \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}}
+     *   @f]
+     *
+     *   @param  __x  The first of three symmetric arguments.
+     *   @param  __y  The second of three symmetric arguments.
+     *   @param  __z  The third of three symmetric arguments.
+     *   @return  The Carlson elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rf(_Tp __x, _Tp __y, _Tp __z)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rf."));
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim)
+        std::__throw_domain_error(__N("Argument too small in __ellint_rf"));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(24);
+          const _Tp __c2 = _Tp(1) / _Tp(10);
+          const _Tp __c3 = _Tp(3) / _Tp(44);
+          const _Tp __c4 = _Tp(1) / _Tp(14);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn) / _Tp(3);
+              __xndev = 2 - (__mu + __xn) / __mu;
+              __yndev = 2 - (__mu + __yn) / __mu;
+              __zndev = 2 - (__mu + __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+
+          const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
+          const _Tp __e3 = __xndev * __yndev * __zndev;
+          const _Tp __s  = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
+                   + __c4 * __e3;
+
+          return __s / std::sqrt(__mu);
+        }
+    }
+
+
+    /**
+     *   @brief Return the complete elliptic integral of the first kind
+     *          @f$ K(k) @f$ by series expansion.
+     * 
+     *   The complete elliptic integral of the first kind is defined as
+     *   @f[
+     *     K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta}
+     *                              {\sqrt{1 - k^2sin^2\theta}}
+     *   @f]
+     * 
+     *   This routine is not bad as long as |k| is somewhat smaller than 1
+     *   but is not is good as the Carlson elliptic integral formulation.
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1_series(_Tp __k)
+    {
+
+      const _Tp __kk = __k * __k;
+
+      _Tp __term = __kk / _Tp(4);
+      _Tp __sum = _Tp(1) + __term;
+
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          __term *= (2 * __i - 1) * __kk / (2 * __i);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+
+      return __numeric_constants<_Tp>::__pi_2() * __sum;
+    }
+
+
+    /**
+     *   @brief  Return the complete elliptic integral of the first kind
+     *           @f$ K(k) @f$ using the Carlson formulation.
+     * 
+     *   The complete elliptic integral of the first kind is defined as
+     *   @f[
+     *     K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta}
+     *                                           {\sqrt{1 - k^2 sin^2\theta}}
+     *   @f]
+     *   where @f$ F(k,\phi) @f$ is the incomplete elliptic integral of the
+     *   first kind.
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1(_Tp __k)
+    {
+
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) >= _Tp(1))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
+    }
+
+
+    /**
+     *   @brief  Return the incomplete elliptic integral of the first kind
+     *           @f$ F(k,\phi) @f$ using the Carlson formulation.
+     * 
+     *   The incomplete elliptic integral of the first kind is defined as
+     *   @f[
+     *     F(k,\phi) = \int_0^{\phi}\frac{d\theta}
+     *                                   {\sqrt{1 - k^2 sin^2\theta}}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __phi  The integral limit argument of the elliptic function.
+     *   @return  The elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_1(_Tp __k, _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __ellint_1."));
+      else
+        {
+          //  Reduce phi to -pi/2 < phi < +pi/2.
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __c = std::cos(__phi_red);
+
+          const _Tp __F = __s
+                        * __ellint_rf(__c * __c,
+                                _Tp(1) - __k * __k * __s * __s, _Tp(1));
+
+          if (__n == 0)
+            return __F;
+          else
+            return __F + _Tp(2) * __n * __comp_ellint_1(__k);
+        }
+    }
+
+
+    /**
+     *   @brief Return the complete elliptic integral of the second kind
+     *          @f$ E(k) @f$ by series expansion.
+     * 
+     *   The complete elliptic integral of the second kind is defined as
+     *   @f[
+     *     E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta}
+     *   @f]
+     * 
+     *   This routine is not bad as long as |k| is somewhat smaller than 1
+     *   but is not is good as the Carlson elliptic integral formulation.
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2_series(_Tp __k)
+    {
+
+      const _Tp __kk = __k * __k;
+
+      _Tp __term = __kk;
+      _Tp __sum = __term;
+
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          const _Tp __i2m = 2 * __i - 1;
+          const _Tp __i2 = 2 * __i;
+          __term *= __i2m * __i2m * __kk / (__i2 * __i2);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term / __i2m;
+        }
+
+      return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
+    }
+
+
+    /**
+     *   @brief  Return the Carlson elliptic function of the second kind
+     *           @f$ R_D(x,y,z) = R_J(x,y,z,z) @f$ where
+     *           @f$ R_J(x,y,z,p) @f$ is the Carlson elliptic function
+     *           of the third kind.
+     * 
+     *   The Carlson elliptic function of the second kind is defined by:
+     *   @f[
+     *       R_D(x,y,z) = \frac{3}{2} \int_0^\infty
+     *                 \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{3/2}}
+     *   @f]
+     *
+     *   Based on Carlson's algorithms:
+     *   -  B. C. Carlson Numer. Math. 33, 1 (1979)
+     *   -  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+     *   -  Numerical Recipes in C, 2nd ed, pp. 261-269,
+     *      by Press, Teukolsky, Vetterling, Flannery (1992)
+     *
+     *   @param  __x  The first of two symmetric arguments.
+     *   @param  __y  The second of two symmetric arguments.
+     *   @param  __z  The third argument.
+     *   @return  The Carlson elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rd(_Tp __x, _Tp __y, _Tp __z)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));
+      const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3));
+
+      if (__x < _Tp(0) || __y < _Tp(0))
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rd."));
+      else if (__x + __y < __lolim || __z < __lolim)
+        std::__throw_domain_error(__N("Argument too small "
+                                      "in __ellint_rd."));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(6);
+          const _Tp __c3 = _Tp(9) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              _Tp __xnroot = std::sqrt(__xn);
+              _Tp __ynroot = std::sqrt(__yn);
+              _Tp __znroot = std::sqrt(__zn);
+              _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                           + __ynroot * __znroot;
+              __sigma += __power4 / (__znroot * (__zn + __lambda));
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+
+	  // Note: __ea is an SPU badname.
+          _Tp __eaa = __xndev * __yndev;
+          _Tp __eb = __zndev * __zndev;
+          _Tp __ec = __eaa - __eb;
+          _Tp __ed = __eaa - _Tp(6) * __eb;
+          _Tp __ef = __ed + __ec + __ec;
+          _Tp __s1 = __ed * (-__c1 + __c3 * __ed
+                                   / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef
+                                   / _Tp(2));
+          _Tp __s2 = __zndev
+                   * (__c2 * __ef
+                    + __zndev * (-__c3 * __ec - __zndev * __c4 - __eaa));
+
+          return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
+                                        / (__mu * std::sqrt(__mu));
+        }
+    }
+
+
+    /**
+     *   @brief  Return the complete elliptic integral of the second kind
+     *           @f$ E(k) @f$ using the Carlson formulation.
+     * 
+     *   The complete elliptic integral of the second kind is defined as
+     *   @f[
+     *     E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2(_Tp __k)
+    {
+
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) == 1)
+        return _Tp(1);
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __comp_ellint_2."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
+        }
+    }
+
+
+    /**
+     *   @brief  Return the incomplete elliptic integral of the second kind
+     *           @f$ E(k,\phi) @f$ using the Carlson formulation.
+     * 
+     *   The incomplete elliptic integral of the second kind is defined as
+     *   @f[
+     *     E(k,\phi) = \int_0^{\phi} \sqrt{1 - k^2 sin^2\theta}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __phi  The integral limit argument of the elliptic function.
+     *   @return  The elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_2(_Tp __k, _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __ellint_2."));
+      else
+        {
+          //  Reduce phi to -pi/2 < phi < +pi/2.
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+
+          const _Tp __E = __s
+                        * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        - __kk * __sss
+                        * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        / _Tp(3);
+
+          if (__n == 0)
+            return __E;
+          else
+            return __E + _Tp(2) * __n * __comp_ellint_2(__k);
+        }
+    }
+
+
+    /**
+     *   @brief  Return the Carlson elliptic function
+     *           @f$ R_C(x,y) = R_F(x,y,y) @f$ where @f$ R_F(x,y,z) @f$
+     *           is the Carlson elliptic function of the first kind.
+     * 
+     *   The Carlson elliptic function is defined by:
+     *   @f[
+     *       R_C(x,y) = \frac{1}{2} \int_0^\infty
+     *                 \frac{dt}{(t + x)^{1/2}(t + y)}
+     *   @f]
+     *
+     *   Based on Carlson's algorithms:
+     *   -  B. C. Carlson Numer. Math. 33, 1 (1979)
+     *   -  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+     *   -  Numerical Recipes in C, 2nd ed, pp. 261-269,
+     *      by Press, Teukolsky, Vetterling, Flannery (1992)
+     *
+     *   @param  __x  The first argument.
+     *   @param  __y  The second argument.
+     *   @return  The Carlson elliptic function.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rc(_Tp __x, _Tp __y)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rc."));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(7);
+          const _Tp __c2 = _Tp(9) / _Tp(22);
+          const _Tp __c3 = _Tp(3) / _Tp(10);
+          const _Tp __c4 = _Tp(3) / _Tp(8);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __sn;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + _Tp(2) * __yn) / _Tp(3);
+              __sn = (__yn + __mu) / __mu - _Tp(2);
+              if (std::abs(__sn) < __errtol)
+                break;
+              const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
+                             + __yn;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+            }
+
+          _Tp __s = __sn * __sn
+                  * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));
+
+          return (_Tp(1) + __s) / std::sqrt(__mu);
+        }
+    }
+
+
+    /**
+     *   @brief  Return the Carlson elliptic function @f$ R_J(x,y,z,p) @f$
+     *           of the third kind.
+     * 
+     *   The Carlson elliptic function of the third kind is defined by:
+     *   @f[
+     *       R_J(x,y,z,p) = \frac{3}{2} \int_0^\infty
+     *       \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}(t + p)}
+     *   @f]
+     *
+     *   Based on Carlson's algorithms:
+     *   -  B. C. Carlson Numer. Math. 33, 1 (1979)
+     *   -  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+     *   -  Numerical Recipes in C, 2nd ed, pp. 261-269,
+     *      by Press, Teukolsky, Vetterling, Flannery (1992)
+     *
+     *   @param  __x  The first of three symmetric arguments.
+     *   @param  __y  The second of three symmetric arguments.
+     *   @param  __z  The third of three symmetric arguments.
+     *   @param  __p  The fourth argument.
+     *   @return  The Carlson elliptic function of the fourth kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));
+      const _Tp __uplim = _Tp(0.3L)
+                        * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3));
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rj."));
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim || __p < __lolim)
+        std::__throw_domain_error(__N("Argument too small "
+                                      "in __ellint_rj"));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(3);
+          const _Tp __c3 = _Tp(3) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __pn = __p;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+
+          _Tp __lambda, __mu;
+          _Tp __xndev, __yndev, __zndev, __pndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              __pndev = (__mu - __pn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              __epsilon = std::max(__epsilon, std::abs(__pndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
+                                + __xnroot * __ynroot * __znroot;
+              const _Tp __alpha2 = __alpha1 * __alpha1;
+              const _Tp __beta = __pn * (__pn + __lambda)
+                                      * (__pn + __lambda);
+              __sigma += __power4 * __ellint_rc(__alpha2, __beta);
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+              __pn = __c0 * (__pn + __lambda);
+            }
+
+	  // Note: __ea is an SPU badname.
+          _Tp __eaa = __xndev * (__yndev + __zndev) + __yndev * __zndev;
+          _Tp __eb = __xndev * __yndev * __zndev;
+          _Tp __ec = __pndev * __pndev;
+          _Tp __e2 = __eaa - _Tp(3) * __ec;
+          _Tp __e3 = __eb + _Tp(2) * __pndev * (__eaa - __ec);
+          _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4)
+                            - _Tp(3) * __c4 * __e3 / _Tp(2));
+          _Tp __s2 = __eb * (__c2 / _Tp(2)
+                   + __pndev * (-__c3 - __c3 + __pndev * __c4));
+          _Tp __s3 = __pndev * __eaa * (__c2 - __pndev * __c3)
+                   - __c2 * __pndev * __ec;
+
+          return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
+                                             / (__mu * std::sqrt(__mu));
+        }
+    }
+
+
+    /**
+     *   @brief Return the complete elliptic integral of the third kind
+     *          @f$ \Pi(k,\nu) = \Pi(k,\nu,\pi/2) @f$ using the
+     *          Carlson formulation.
+     * 
+     *   The complete elliptic integral of the third kind is defined as
+     *   @f[
+     *     \Pi(k,\nu) = \int_0^{\pi/2}
+     *                   \frac{d\theta}
+     *                 {(1 - \nu \sin^2\theta)\sqrt{1 - k^2 \sin^2\theta}}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __nu  The second argument of the elliptic function.
+     *   @return  The complete elliptic function of the third kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_3(_Tp __k, _Tp __nu)
+    {
+
+      if (__isnan(__k) || __isnan(__nu))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__nu == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __comp_ellint_3."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               - __nu
+               * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) + __nu)
+               / _Tp(3);
+        }
+    }
+
+
+    /**
+     *   @brief Return the incomplete elliptic integral of the third kind
+     *          @f$ \Pi(k,\nu,\phi) @f$ using the Carlson formulation.
+     * 
+     *   The incomplete elliptic integral of the third kind is defined as
+     *   @f[
+     *     \Pi(k,\nu,\phi) = \int_0^{\phi}
+     *                       \frac{d\theta}
+     *                            {(1 - \nu \sin^2\theta)
+     *                             \sqrt{1 - k^2 \sin^2\theta}}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __nu  The second argument of the elliptic function.
+     *   @param  __phi  The integral limit argument of the elliptic function.
+     *   @return  The elliptic function of the third kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __ellint_3."));
+      else
+        {
+          //  Reduce phi to -pi/2 < phi < +pi/2.
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+
+          const _Tp __Pi = __s
+                         * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                         - __nu * __sss
+                         * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
+                                       _Tp(1) + __nu * __ss) / _Tp(3);
+
+          if (__n == 0)
+            return __Pi;
+          else
+            return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
+        }
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_ELL_INTEGRAL_TCC
+
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/exp_integral.tcc b/gcc-4.9/libstdc++-v3/include/tr1/exp_integral.tcc
new file mode 100644
index 0000000..10d072c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/exp_integral.tcc
@@ -0,0 +1,526 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/exp_integral.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+//  Written by Edward Smith-Rowland based on:
+//
+//   (1) Handbook of Mathematical Functions,
+//       Ed. by Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications, New-York, Section 5, pp. 228-251.
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 222-225.
+//
+
+#ifndef _GLIBCXX_TR1_EXP_INTEGRAL_TCC
+#define _GLIBCXX_TR1_EXP_INTEGRAL_TCC 1
+
+#include "special_function_util.h"
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    template<typename _Tp> _Tp __expint_E1(_Tp);
+
+    /**
+     *   @brief Return the exponential integral @f$ E_1(x) @f$
+     *          by series summation.  This should be good
+     *          for @f$ x < 1 @f$.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_1(x) = \int_{1}^{\infty} \frac{e^{-xt}}{t} dt
+     *          \f]
+     * 
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_E1_series(_Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      _Tp __term = _Tp(1);
+      _Tp __esum = _Tp(0);
+      _Tp __osum = _Tp(0);
+      const unsigned int __max_iter = 100;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= - __x / __i;
+          if (std::abs(__term) < __eps)
+            break;
+          if (__term >= _Tp(0))
+            __esum += __term / __i;
+          else
+            __osum += __term / __i;
+        }
+
+      return - __esum - __osum
+             - __numeric_constants<_Tp>::__gamma_e() - std::log(__x);
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_1(x) @f$
+     *          by asymptotic expansion.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_1(x) = \int_{1}^\infty \frac{e^{-xt}}{t} dt
+     *          \f]
+     * 
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_E1_asymp(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __esum = _Tp(1);
+      _Tp __osum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= - __i / __x;
+          if (std::abs(__term) > std::abs(__prev))
+            break;
+          if (__term >= _Tp(0))
+            __esum += __term;
+          else
+            __osum += __term;
+        }
+
+      return std::exp(- __x) * (__esum + __osum) / __x;
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_n(x) @f$
+     *          by series summation.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
+     *          \f]
+     * 
+     *   @param  __n  The order of the exponential integral function.
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_En_series(unsigned int __n, _Tp __x)
+    {
+      const unsigned int __max_iter = 100;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const int __nm1 = __n - 1;
+      _Tp __ans = (__nm1 != 0
+                ? _Tp(1) / __nm1 : -std::log(__x)
+                                   - __numeric_constants<_Tp>::__gamma_e());
+      _Tp __fact = _Tp(1);
+      for (int __i = 1; __i <= __max_iter; ++__i)
+        {
+          __fact *= -__x / _Tp(__i);
+          _Tp __del;
+          if ( __i != __nm1 )
+            __del = -__fact / _Tp(__i - __nm1);
+          else
+            {
+              _Tp __psi = -__numeric_constants<_Tp>::gamma_e();
+              for (int __ii = 1; __ii <= __nm1; ++__ii)
+                __psi += _Tp(1) / _Tp(__ii);
+              __del = __fact * (__psi - std::log(__x)); 
+            }
+          __ans += __del;
+          if (std::abs(__del) < __eps * std::abs(__ans))
+            return __ans;
+        }
+      std::__throw_runtime_error(__N("Series summation failed "
+                                     "in __expint_En_series."));
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_n(x) @f$
+     *          by continued fractions.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
+     *          \f]
+     * 
+     *   @param  __n  The order of the exponential integral function.
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_En_cont_frac(unsigned int __n, _Tp __x)
+    {
+      const unsigned int __max_iter = 100;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = std::numeric_limits<_Tp>::min();
+      const int __nm1 = __n - 1;
+      _Tp __b = __x + _Tp(__n);
+      _Tp __c = _Tp(1) / __fp_min;
+      _Tp __d = _Tp(1) / __b;
+      _Tp __h = __d;
+      for ( unsigned int __i = 1; __i <= __max_iter; ++__i )
+        {
+          _Tp __a = -_Tp(__i * (__nm1 + __i));
+          __b += _Tp(2);
+          __d = _Tp(1) / (__a * __d + __b);
+          __c = __b + __a / __c;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            {
+              const _Tp __ans = __h * std::exp(-__x);
+              return __ans;
+            }
+        }
+      std::__throw_runtime_error(__N("Continued fraction failed "
+                                     "in __expint_En_cont_frac."));
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_n(x) @f$
+     *          by recursion.  Use upward recursion for @f$ x < n @f$
+     *          and downward recursion (Miller's algorithm) otherwise.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
+     *          \f]
+     * 
+     *   @param  __n  The order of the exponential integral function.
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_En_recursion(unsigned int __n, _Tp __x)
+    {
+      _Tp __En;
+      _Tp __E1 = __expint_E1(__x);
+      if (__x < _Tp(__n))
+        {
+          //  Forward recursion is stable only for n < x.
+          __En = __E1;
+          for (unsigned int __j = 2; __j < __n; ++__j)
+            __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1);
+        }
+      else
+        {
+          //  Backward recursion is stable only for n >= x.
+          __En = _Tp(1);
+          const int __N = __n + 20;  //  TODO: Check this starting number.
+          _Tp __save = _Tp(0);
+          for (int __j = __N; __j > 0; --__j)
+            {
+              __En = (std::exp(-__x) - __j * __En) / __x;
+              if (__j == __n)
+                __save = __En;
+            }
+            _Tp __norm = __En / __E1;
+            __En /= __norm;
+        }
+
+      return __En;
+    }
+
+    /**
+     *   @brief Return the exponential integral @f$ Ei(x) @f$
+     *          by series summation.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
+     *          \f]
+     * 
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_Ei_series(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= __x / __i;
+          __sum += __term / __i;
+          if (__term < std::numeric_limits<_Tp>::epsilon() * __sum)
+            break;
+        }
+
+      return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x);
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ Ei(x) @f$
+     *          by asymptotic expansion.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
+     *          \f]
+     * 
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_Ei_asymp(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= __i / __x;
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          if (__term >= __prev)
+            break;
+          __sum += __term;
+        }
+
+      return std::exp(__x) * __sum / __x;
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ Ei(x) @f$.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
+     *          \f]
+     * 
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_Ei(_Tp __x)
+    {
+      if (__x < _Tp(0))
+        return -__expint_E1(-__x);
+      else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon()))
+        return __expint_Ei_series(__x);
+      else
+        return __expint_Ei_asymp(__x);
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_1(x) @f$.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_1(x) = \int_{1}^\infty \frac{e^{-xt}}{t} dt
+     *          \f]
+     * 
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_E1(_Tp __x)
+    {
+      if (__x < _Tp(0))
+        return -__expint_Ei(-__x);
+      else if (__x < _Tp(1))
+        return __expint_E1_series(__x);
+      else if (__x < _Tp(100))  //  TODO: Find a good asymptotic switch point.
+        return __expint_En_cont_frac(1, __x);
+      else
+        return __expint_E1_asymp(__x);
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_n(x) @f$
+     *          for large argument.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
+     *          \f]
+     * 
+     *   This is something of an extension.
+     * 
+     *   @param  __n  The order of the exponential integral function.
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_asymp(unsigned int __n, _Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      for (unsigned int __i = 1; __i <= __n; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= -(__n - __i + 1) / __x;
+          if (std::abs(__term) > std::abs(__prev))
+            break;
+          __sum += __term;
+        }
+
+      return std::exp(-__x) * __sum / __x;
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_n(x) @f$
+     *          for large order.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
+     *          \f]
+     *        
+     *   This is something of an extension.
+     * 
+     *   @param  __n  The order of the exponential integral function.
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint_large_n(unsigned int __n, _Tp __x)
+    {
+      const _Tp __xpn = __x + __n;
+      const _Tp __xpn2 = __xpn * __xpn;
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      for (unsigned int __i = 1; __i <= __n; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= (__n - 2 * (__i - 1) * __x) / __xpn2;
+          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+
+      return std::exp(-__x) * __sum / __xpn;
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ E_n(x) @f$.
+     * 
+     *   The exponential integral is given by
+     *          \f[
+     *            E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
+     *          \f]
+     *   This is something of an extension.
+     * 
+     *   @param  __n  The order of the exponential integral function.
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    _Tp
+    __expint(unsigned int __n, _Tp __x)
+    {
+      //  Return NaN on NaN input.
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__n <= 1 && __x == _Tp(0))
+        return std::numeric_limits<_Tp>::infinity();
+      else
+        {
+          _Tp __E0 = std::exp(__x) / __x;
+          if (__n == 0)
+            return __E0;
+
+          _Tp __E1 = __expint_E1(__x);
+          if (__n == 1)
+            return __E1;
+
+          if (__x == _Tp(0))
+            return _Tp(1) / static_cast<_Tp>(__n - 1);
+
+          _Tp __En = __expint_En_recursion(__n, __x);
+
+          return __En;
+        }
+    }
+
+
+    /**
+     *   @brief Return the exponential integral @f$ Ei(x) @f$.
+     * 
+     *   The exponential integral is given by
+     *   \f[
+     *     Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
+     *   \f]
+     * 
+     *   @param  __x  The argument of the exponential integral function.
+     *   @return  The exponential integral.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __expint(_Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __expint_Ei(__x);
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_EXP_INTEGRAL_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/fenv.h b/gcc-4.9/libstdc++-v3/include/tr1/fenv.h
new file mode 100644
index 0000000..a5f232c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/fenv.h
@@ -0,0 +1,34 @@
+// TR1 fenv.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/fenv.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_FENV_H
+#define _TR1_FENV_H 1
+
+#include <tr1/cfenv>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/float.h b/gcc-4.9/libstdc++-v3/include/tr1/float.h
new file mode 100644
index 0000000..4a06215
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/float.h
@@ -0,0 +1,34 @@
+// TR1 float.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/float.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_FLOAT_H
+#define _TR1_FLOAT_H 1
+
+#include <tr1/cfloat>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/functional b/gcc-4.9/libstdc++-v3/include/tr1/functional
new file mode 100644
index 0000000..20785ff
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/functional
@@ -0,0 +1,2308 @@
+// TR1 functional header -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/functional
+ *  This is a TR1 C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TR1_FUNCTIONAL
+#define _GLIBCXX_TR1_FUNCTIONAL 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stl_function.h>
+
+#include <typeinfo>
+#include <new>
+#include <tr1/tuple>
+#include <tr1/type_traits>
+#include <bits/stringfwd.h>
+#include <tr1/functional_hash.h>
+#include <ext/type_traits.h>
+#include <bits/move.h> // for std::__addressof
+#if __cplusplus >= 201103L
+#  include <type_traits> // for integral_constant, true_type, false_type
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+#if __cplusplus >= 201103L
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+  template<int> struct _Placeholder;
+  template<typename> class _Bind;
+  template<typename, typename> class _Bind_result;
+_GLIBCXX_END_NAMESPACE_VERSION
+#endif
+
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename _MemberPointer>
+    class _Mem_fn;
+  template<typename _Tp, typename _Class>
+    _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::*);
+
+  /**
+   *  Actual implementation of _Has_result_type, which uses SFINAE to
+   *  determine if the type _Tp has a publicly-accessible member type
+   *  result_type.
+  */
+  template<typename _Tp>
+    class _Has_result_type_helper : __sfinae_types
+    {
+      template<typename _Up>
+        struct _Wrap_type
+	{ };
+
+      template<typename _Up>
+        static __one __test(_Wrap_type<typename _Up::result_type>*);
+
+      template<typename _Up>
+        static __two __test(...);
+
+    public:
+      static const bool value = sizeof(__test<_Tp>(0)) == 1;
+    };
+
+  template<typename _Tp>
+    struct _Has_result_type
+    : integral_constant<bool,
+	      _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
+    { };
+
+  /**
+   *  
+  */
+  /// If we have found a result_type, extract it.
+  template<bool _Has_result_type, typename _Functor>
+    struct _Maybe_get_result_type
+    { };
+
+  template<typename _Functor>
+    struct _Maybe_get_result_type<true, _Functor>
+    {
+      typedef typename _Functor::result_type result_type;
+    };
+
+  /**
+   *  Base class for any function object that has a weak result type, as
+   *  defined in 3.3/3 of TR1.
+  */
+  template<typename _Functor>
+    struct _Weak_result_type_impl
+    : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
+    {
+    };
+
+  /// Retrieve the result type for a function type.
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /// Retrieve the result type for a function reference.
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /// Retrieve the result type for a function pointer.
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /// Retrieve result type for a member function pointer. 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
+    {
+      typedef _Res result_type;
+    };
+
+  /// Retrieve result type for a const member function pointer. 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
+    {
+      typedef _Res result_type;
+    };
+
+  /// Retrieve result type for a volatile member function pointer. 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
+    {
+      typedef _Res result_type;
+    };
+
+  /// Retrieve result type for a const volatile member function pointer. 
+  template<typename _Res, typename _Class, typename... _ArgTypes> 
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile>
+    {
+      typedef _Res result_type;
+    };
+
+  /**
+   *  Strip top-level cv-qualifiers from the function object and let
+   *  _Weak_result_type_impl perform the real work.
+  */
+  template<typename _Functor>
+    struct _Weak_result_type
+    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
+    {
+    };
+
+  template<typename _Signature>
+    class result_of;
+
+  /**
+   *  Actual implementation of result_of. When _Has_result_type is
+   *  true, gets its result from _Weak_result_type. Otherwise, uses
+   *  the function object's member template result to extract the
+   *  result type.
+  */
+  template<bool _Has_result_type, typename _Signature>
+    struct _Result_of_impl;
+
+  // Handle member data pointers using _Mem_fn's logic
+  template<typename _Res, typename _Class, typename _T1>
+    struct _Result_of_impl<false, _Res _Class::*(_T1)>
+    {
+      typedef typename _Mem_fn<_Res _Class::*>
+                ::template _Result_type<_T1>::type type;
+    };
+
+  /**
+   * Determine whether we can determine a result type from @c Functor 
+   * alone.
+   */ 
+  template<typename _Functor, typename... _ArgTypes>
+    class result_of<_Functor(_ArgTypes...)>
+    : public _Result_of_impl<
+               _Has_result_type<_Weak_result_type<_Functor> >::value,
+               _Functor(_ArgTypes...)>
+    {
+    };
+
+  /// We already know the result type for @c Functor; use it.
+  template<typename _Functor, typename... _ArgTypes>
+    struct _Result_of_impl<true, _Functor(_ArgTypes...)>
+    {
+      typedef typename _Weak_result_type<_Functor>::result_type type;
+    };
+
+  /**
+   * We need to compute the result type for this invocation the hard 
+   * way.
+   */
+  template<typename _Functor, typename... _ArgTypes>
+    struct _Result_of_impl<false, _Functor(_ArgTypes...)>
+    {
+      typedef typename _Functor
+                ::template result<_Functor(_ArgTypes...)>::type type;
+    };
+
+  /**
+   * It is unsafe to access ::result when there are zero arguments, so we 
+   * return @c void instead.
+   */
+  template<typename _Functor>
+    struct _Result_of_impl<false, _Functor()>
+    {
+      typedef void type;
+    };
+
+  /// Determines if the type _Tp derives from unary_function.
+  template<typename _Tp>
+    struct _Derives_from_unary_function : __sfinae_types
+    {
+    private:
+      template<typename _T1, typename _Res>
+        static __one __test(const volatile unary_function<_T1, _Res>*);
+
+      // It's tempting to change "..." to const volatile void*, but
+      // that fails when _Tp is a function type.
+      static __two __test(...);
+
+    public:
+      static const bool value = sizeof(__test((_Tp*)0)) == 1;
+    };
+
+  /// Determines if the type _Tp derives from binary_function.
+  template<typename _Tp>
+    struct _Derives_from_binary_function : __sfinae_types
+    {
+    private:
+      template<typename _T1, typename _T2, typename _Res>
+        static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
+
+      // It's tempting to change "..." to const volatile void*, but
+      // that fails when _Tp is a function type.
+      static __two __test(...);
+
+    public:
+      static const bool value = sizeof(__test((_Tp*)0)) == 1;
+    };
+
+  /// Turns a function type into a function pointer type
+  template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
+    struct _Function_to_function_pointer
+    {
+      typedef _Tp type;
+    };
+
+  template<typename _Tp>
+    struct _Function_to_function_pointer<_Tp, true>
+    {
+      typedef _Tp* type;
+    };
+
+  /**
+   * Invoke a function object, which may be either a member pointer or a
+   * function object. The first parameter will tell which.
+   */
+  template<typename _Functor, typename... _Args>
+    inline
+    typename __gnu_cxx::__enable_if<
+             (!is_member_pointer<_Functor>::value
+              && !is_function<_Functor>::value
+              && !is_function<typename remove_pointer<_Functor>::type>::value),
+             typename result_of<_Functor(_Args...)>::type
+           >::__type
+    __invoke(_Functor& __f, _Args&... __args)
+    {
+      return __f(__args...);
+    }
+
+  template<typename _Functor, typename... _Args>
+    inline
+    typename __gnu_cxx::__enable_if<
+             (is_member_pointer<_Functor>::value
+              && !is_function<_Functor>::value
+              && !is_function<typename remove_pointer<_Functor>::type>::value),
+             typename result_of<_Functor(_Args...)>::type
+           >::__type
+    __invoke(_Functor& __f, _Args&... __args)
+    {
+      return mem_fn(__f)(__args...);
+    }
+
+  // To pick up function references (that will become function pointers)
+  template<typename _Functor, typename... _Args>
+    inline
+    typename __gnu_cxx::__enable_if<
+             (is_pointer<_Functor>::value
+              && is_function<typename remove_pointer<_Functor>::type>::value),
+             typename result_of<_Functor(_Args...)>::type
+           >::__type
+    __invoke(_Functor __f, _Args&... __args)
+    {
+      return __f(__args...);
+    }
+
+  /**
+   *  Knowing which of unary_function and binary_function _Tp derives
+   *  from, derives from the same and ensures that reference_wrapper
+   *  will have a weak result type. See cases below.
+   */
+  template<bool _Unary, bool _Binary, typename _Tp>
+    struct _Reference_wrapper_base_impl;
+
+  // Not a unary_function or binary_function, so try a weak result type.
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, false, _Tp>
+    : _Weak_result_type<_Tp>
+    { };
+
+  // unary_function but not binary_function
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, false, _Tp>
+    : unary_function<typename _Tp::argument_type,
+		     typename _Tp::result_type>
+    { };
+
+  // binary_function but not unary_function
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, true, _Tp>
+    : binary_function<typename _Tp::first_argument_type,
+		      typename _Tp::second_argument_type,
+		      typename _Tp::result_type>
+    { };
+
+  // Both unary_function and binary_function. Import result_type to
+  // avoid conflicts.
+   template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, true, _Tp>
+    : unary_function<typename _Tp::argument_type,
+		     typename _Tp::result_type>,
+      binary_function<typename _Tp::first_argument_type,
+		      typename _Tp::second_argument_type,
+		      typename _Tp::result_type>
+    {
+      typedef typename _Tp::result_type result_type;
+    };
+
+  /**
+   *  Derives from unary_function or binary_function when it
+   *  can. Specializations handle all of the easy cases. The primary
+   *  template determines what to do with a class type, which may
+   *  derive from both unary_function and binary_function.
+  */
+  template<typename _Tp>
+    struct _Reference_wrapper_base
+    : _Reference_wrapper_base_impl<
+      _Derives_from_unary_function<_Tp>::value,
+      _Derives_from_binary_function<_Tp>::value,
+      _Tp>
+    { };
+
+  // - a function type (unary)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+  // - a function type (binary)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  // - a function pointer type (unary)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(*)(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+  // - a function pointer type (binary)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, no qualifiers)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)()>
+    : unary_function<_T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, no qualifiers)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
+    : binary_function<_T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, const)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const>
+    : unary_function<const _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, const)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
+    : binary_function<const _T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, volatile)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
+    : unary_function<volatile _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, volatile)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
+    : binary_function<volatile _T1*, _T2, _Res>
+    { };
+
+  // - a pointer to member function type (unary, const volatile)
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
+    : unary_function<const volatile _T1*, _Res>
+    { };
+
+  // - a pointer to member function type (binary, const volatile)
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
+    : binary_function<const volatile _T1*, _T2, _Res>
+    { };
+
+  /// reference_wrapper
+  template<typename _Tp>
+    class reference_wrapper
+    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
+    {
+      // If _Tp is a function type, we can't form result_of<_Tp(...)>,
+      // so turn it into a function pointer type.
+      typedef typename _Function_to_function_pointer<_Tp>::type
+        _M_func_type;
+
+      _Tp* _M_data;
+    public:
+      typedef _Tp type;
+
+      explicit
+      reference_wrapper(_Tp& __indata)
+      : _M_data(std::__addressof(__indata))
+      { }
+
+      reference_wrapper(const reference_wrapper<_Tp>& __inref):
+      _M_data(__inref._M_data)
+      { }
+
+      reference_wrapper&
+      operator=(const reference_wrapper<_Tp>& __inref)
+      {
+        _M_data = __inref._M_data;
+        return *this;
+      }
+
+      operator _Tp&() const
+      { return this->get(); }
+
+      _Tp&
+      get() const
+      { return *_M_data; }
+
+      template<typename... _Args>
+        typename result_of<_M_func_type(_Args...)>::type
+        operator()(_Args&... __args) const
+        {
+	  return __invoke(get(), __args...);
+	}
+    };
+
+
+  // Denotes a reference should be taken to a variable.
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(_Tp& __t)
+    { return reference_wrapper<_Tp>(__t); }
+
+  // Denotes a const reference should be taken to a variable.
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(const _Tp& __t)
+    { return reference_wrapper<const _Tp>(__t); }
+
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(reference_wrapper<_Tp> __t)
+    { return ref(__t.get()); }
+
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(reference_wrapper<_Tp> __t)
+    { return cref(__t.get()); }
+
+  template<typename _Tp, bool>
+    struct _Mem_fn_const_or_non
+    {
+      typedef const _Tp& type;
+    };
+
+  template<typename _Tp>
+    struct _Mem_fn_const_or_non<_Tp, false>
+    {
+      typedef _Tp& type;
+    };
+
+  /**
+   * Derives from @c unary_function or @c binary_function, or perhaps
+   * nothing, depending on the number of arguments provided. The
+   * primary template is the basis case, which derives nothing.
+   */
+  template<typename _Res, typename... _ArgTypes> 
+    struct _Maybe_unary_or_binary_function { };
+
+  /// Derives from @c unary_function, as appropriate. 
+  template<typename _Res, typename _T1> 
+    struct _Maybe_unary_or_binary_function<_Res, _T1>
+    : std::unary_function<_T1, _Res> { };
+
+  /// Derives from @c binary_function, as appropriate. 
+  template<typename _Res, typename _T1, typename _T2> 
+    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+    : std::binary_function<_T1, _T2, _Res> { };
+
+  /// Implementation of @c mem_fn for member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...);
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res
+      operator()(_Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res
+      operator()(_Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res
+	operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /// Implementation of @c mem_fn for const member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
+    : public _Maybe_unary_or_binary_function<_Res, const _Class*, 
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res
+      operator()(const _Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res
+      operator()(const _Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /// Implementation of @c mem_fn for volatile member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
+    : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, 
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res
+      operator()(volatile _Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res
+      operator()(volatile _Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res
+	operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+  /// Implementation of @c mem_fn for const volatile member function pointers.
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
+    : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, 
+					     _ArgTypes...>
+    {
+      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __object, const volatile _Class *, 
+                _ArgTypes... __args) const
+        { return (__object.*__pmf)(__args...); }
+
+      template<typename _Tp>
+        _Res
+        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+        { return ((*__ptr).*__pmf)(__args...); }
+
+    public:
+      typedef _Res result_type;
+
+      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
+
+      // Handle objects
+      _Res 
+      operator()(const volatile _Class& __object, _ArgTypes... __args) const
+      { return (__object.*__pmf)(__args...); }
+
+      // Handle pointers
+      _Res 
+      operator()(const volatile _Class* __object, _ArgTypes... __args) const
+      { return (__object->*__pmf)(__args...); }
+
+      // Handle smart pointers, references and pointers to derived
+      template<typename _Tp>
+        _Res operator()(_Tp& __object, _ArgTypes... __args) const
+        { return _M_call(__object, &__object, __args...); }
+
+    private:
+      _Functor __pmf;
+    };
+
+
+  template<typename _Res, typename _Class>
+    class _Mem_fn<_Res _Class::*>
+    {
+      // This bit of genius is due to Peter Dimov, improved slightly by
+      // Douglas Gregor.
+      template<typename _Tp>
+        _Res&
+        _M_call(_Tp& __object, _Class *) const
+        { return __object.*__pm; }
+
+      template<typename _Tp, typename _Up>
+        _Res&
+        _M_call(_Tp& __object, _Up * const *) const
+        { return (*__object).*__pm; }
+
+      template<typename _Tp, typename _Up>
+        const _Res&
+        _M_call(_Tp& __object, const _Up * const *) const
+        { return (*__object).*__pm; }
+
+      template<typename _Tp>
+        const _Res&
+        _M_call(_Tp& __object, const _Class *) const
+        { return __object.*__pm; }
+
+      template<typename _Tp>
+        const _Res&
+        _M_call(_Tp& __ptr, const volatile void*) const
+        { return (*__ptr).*__pm; }
+
+      template<typename _Tp> static _Tp& __get_ref();
+
+      template<typename _Tp>
+        static __sfinae_types::__one __check_const(_Tp&, _Class*);
+      template<typename _Tp, typename _Up>
+        static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
+      template<typename _Tp, typename _Up>
+        static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
+      template<typename _Tp>
+        static __sfinae_types::__two __check_const(_Tp&, const _Class*);
+      template<typename _Tp>
+        static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
+
+    public:
+      template<typename _Tp>
+        struct _Result_type
+	: _Mem_fn_const_or_non<_Res,
+	  (sizeof(__sfinae_types::__two)
+	   == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
+        { };
+
+      template<typename _Signature>
+        struct result;
+
+      template<typename _CVMem, typename _Tp>
+        struct result<_CVMem(_Tp)>
+	: public _Result_type<_Tp> { };
+
+      template<typename _CVMem, typename _Tp>
+        struct result<_CVMem(_Tp&)>
+	: public _Result_type<_Tp> { };
+
+      explicit
+      _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
+
+      // Handle objects
+      _Res&
+      operator()(_Class& __object) const
+      { return __object.*__pm; }
+
+      const _Res&
+      operator()(const _Class& __object) const
+      { return __object.*__pm; }
+
+      // Handle pointers
+      _Res&
+      operator()(_Class* __object) const
+      { return __object->*__pm; }
+
+      const _Res&
+      operator()(const _Class* __object) const
+      { return __object->*__pm; }
+
+      // Handle smart pointers and derived
+      template<typename _Tp>
+        typename _Result_type<_Tp>::type
+        operator()(_Tp& __unknown) const
+        { return _M_call(__unknown, &__unknown); }
+
+    private:
+      _Res _Class::*__pm;
+    };
+
+  /**
+   *  @brief Returns a function object that forwards to the member
+   *  pointer @a pm.
+   */
+  template<typename _Tp, typename _Class>
+    inline _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::* __pm)
+    {
+      return _Mem_fn<_Tp _Class::*>(__pm);
+    }
+
+  /**
+   *  @brief Determines if the given type _Tp is a function object
+   *  should be treated as a subexpression when evaluating calls to
+   *  function objects returned by bind(). [TR1 3.6.1]
+   */
+  template<typename _Tp>
+    struct is_bind_expression
+    { static const bool value = false; };
+
+  template<typename _Tp>
+    const bool is_bind_expression<_Tp>::value;
+
+  /**
+   *  @brief Determines if the given type _Tp is a placeholder in a
+   *  bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
+   */
+  template<typename _Tp>
+    struct is_placeholder
+    { static const int value = 0; };
+
+  template<typename _Tp>
+    const int is_placeholder<_Tp>::value;
+
+  /// The type of placeholder objects defined by libstdc++.
+  template<int _Num> struct _Placeholder { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+
+  /** @namespace std::tr1::placeholders
+   *  @brief Sub-namespace for tr1/functional.
+   */
+  namespace placeholders 
+  { 
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+    /*  Define a large number of placeholders. There is no way to
+     *  simplify this with variadic templates, because we're introducing
+     *  unique names for each.
+     */
+    namespace 
+    {
+      _Placeholder<1> _1;
+      _Placeholder<2> _2;
+      _Placeholder<3> _3;
+      _Placeholder<4> _4;
+      _Placeholder<5> _5;
+      _Placeholder<6> _6;
+      _Placeholder<7> _7;
+      _Placeholder<8> _8;
+      _Placeholder<9> _9;
+      _Placeholder<10> _10;
+      _Placeholder<11> _11;
+      _Placeholder<12> _12;
+      _Placeholder<13> _13;
+      _Placeholder<14> _14;
+      _Placeholder<15> _15;
+      _Placeholder<16> _16;
+      _Placeholder<17> _17;
+      _Placeholder<18> _18;
+      _Placeholder<19> _19;
+      _Placeholder<20> _20;
+      _Placeholder<21> _21;
+      _Placeholder<22> _22;
+      _Placeholder<23> _23;
+      _Placeholder<24> _24;
+      _Placeholder<25> _25;
+      _Placeholder<26> _26;
+      _Placeholder<27> _27;
+      _Placeholder<28> _28;
+      _Placeholder<29> _29;
+    } 
+  _GLIBCXX_END_NAMESPACE_VERSION
+  }
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+  /**
+   *  Partial specialization of is_placeholder that provides the placeholder
+   *  number for the placeholder objects defined by libstdc++.
+   */
+  template<int _Num>
+    struct is_placeholder<_Placeholder<_Num> >
+    { static const int value = _Num; };
+
+  template<int _Num>
+    const int is_placeholder<_Placeholder<_Num> >::value;
+
+#if __cplusplus >= 201103L
+  template<int _Num>
+    struct is_placeholder<std::_Placeholder<_Num>>
+    : std::integral_constant<int, _Num>
+    { };
+
+  template<int _Num>
+    struct is_placeholder<const std::_Placeholder<_Num>>
+    : std::integral_constant<int, _Num>
+    { };
+#endif
+
+  /**
+   * Stores a tuple of indices. Used by bind() to extract the elements
+   * in a tuple. 
+   */
+  template<int... _Indexes>
+    struct _Index_tuple { };
+
+  /// Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
+  template<std::size_t _Num, typename _Tuple = _Index_tuple<> >
+    struct _Build_index_tuple;
+ 
+  template<std::size_t _Num, int... _Indexes> 
+    struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
+    : _Build_index_tuple<_Num - 1, 
+                         _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
+    {
+    };
+
+  template<int... _Indexes>
+    struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
+    {
+      typedef _Index_tuple<_Indexes...> __type;
+    };
+
+  /** 
+   * Used by _Safe_tuple_element to indicate that there is no tuple
+   * element at this position.
+   */
+  struct _No_tuple_element;
+
+  /**
+   * Implementation helper for _Safe_tuple_element. This primary
+   * template handles the case where it is safe to use @c
+   * tuple_element.
+   */
+  template<int __i, typename _Tuple, bool _IsSafe>
+    struct _Safe_tuple_element_impl
+    : tuple_element<__i, _Tuple> { };
+
+  /**
+   * Implementation helper for _Safe_tuple_element. This partial
+   * specialization handles the case where it is not safe to use @c
+   * tuple_element. We just return @c _No_tuple_element.
+   */
+  template<int __i, typename _Tuple>
+    struct _Safe_tuple_element_impl<__i, _Tuple, false>
+    {
+      typedef _No_tuple_element type;
+    };
+
+  /**
+   * Like tuple_element, but returns @c _No_tuple_element when
+   * tuple_element would return an error.
+   */
+ template<int __i, typename _Tuple>
+   struct _Safe_tuple_element
+   : _Safe_tuple_element_impl<__i, _Tuple, 
+                              (__i >= 0 && __i < tuple_size<_Tuple>::value)>
+   {
+   };
+
+  /**
+   *  Maps an argument to bind() into an actual argument to the bound
+   *  function object [TR1 3.6.3/5]. Only the first parameter should
+   *  be specified: the rest are used to determine among the various
+   *  implementations. Note that, although this class is a function
+   *  object, it isn't entirely normal because it takes only two
+   *  parameters regardless of the number of parameters passed to the
+   *  bind expression. The first parameter is the bound argument and
+   *  the second parameter is a tuple containing references to the
+   *  rest of the arguments.
+   */
+  template<typename _Arg,
+           bool _IsBindExp = is_bind_expression<_Arg>::value,
+           bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+    class _Mu;
+
+  /**
+   *  If the argument is reference_wrapper<_Tp>, returns the
+   *  underlying reference. [TR1 3.6.3/5 bullet 1]
+   */
+  template<typename _Tp>
+    class _Mu<reference_wrapper<_Tp>, false, false>
+    {
+    public:
+      typedef _Tp& result_type;
+
+      /* Note: This won't actually work for const volatile
+       * reference_wrappers, because reference_wrapper::get() is const
+       * but not volatile-qualified. This might be a defect in the TR.
+       */
+      template<typename _CVRef, typename _Tuple>
+        result_type
+        operator()(_CVRef& __arg, const _Tuple&) const volatile
+        { return __arg.get(); }
+    };
+
+  /**
+   *  If the argument is a bind expression, we invoke the underlying
+   *  function object with the same cv-qualifiers as we are given and
+   *  pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, true, false>
+    {
+    public:
+      template<typename _Signature> class result;
+
+      // Determine the result type when we pass the arguments along. This
+      // involves passing along the cv-qualifiers placed on _Mu and
+      // unwrapping the argument bundle.
+      template<typename _CVMu, typename _CVArg, typename... _Args>
+        class result<_CVMu(_CVArg, tuple<_Args...>)>
+	: public result_of<_CVArg(_Args...)> { };
+
+      template<typename _CVArg, typename... _Args>
+        typename result_of<_CVArg(_Args...)>::type
+        operator()(_CVArg& __arg,
+		   const tuple<_Args...>& __tuple) const volatile
+        {
+	  // Construct an index tuple and forward to __call
+	  typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+	    _Indexes;
+	  return this->__call(__arg, __tuple, _Indexes());
+	}
+
+    private:
+      // Invokes the underlying function object __arg by unpacking all
+      // of the arguments in the tuple. 
+      template<typename _CVArg, typename... _Args, int... _Indexes>
+        typename result_of<_CVArg(_Args...)>::type
+        __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
+	       const _Index_tuple<_Indexes...>&) const volatile
+        {
+	  return __arg(tr1::get<_Indexes>(__tuple)...);
+	}
+    };
+
+  /**
+   *  If the argument is a placeholder for the Nth argument, returns
+   *  a reference to the Nth argument to the bind function object.
+   *  [TR1 3.6.3/5 bullet 3]
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, false, true>
+    {
+    public:
+      template<typename _Signature> class result;
+
+      template<typename _CVMu, typename _CVArg, typename _Tuple>
+        class result<_CVMu(_CVArg, _Tuple)>
+        {
+	  // Add a reference, if it hasn't already been done for us.
+	  // This allows us to be a little bit sloppy in constructing
+	  // the tuple that we pass to result_of<...>.
+	  typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
+						- 1), _Tuple>::type
+	    __base_type;
+
+	public:
+	  typedef typename add_reference<__base_type>::type type;
+	};
+
+      template<typename _Tuple>
+        typename result<_Mu(_Arg, _Tuple)>::type
+        operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
+        {
+	  return ::std::tr1::get<(is_placeholder<_Arg>::value - 1)>(__tuple);
+	}
+    };
+
+  /**
+   *  If the argument is just a value, returns a reference to that
+   *  value. The cv-qualifiers on the reference are the same as the
+   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
+   */
+  template<typename _Arg>
+    class _Mu<_Arg, false, false>
+    {
+    public:
+      template<typename _Signature> struct result;
+
+      template<typename _CVMu, typename _CVArg, typename _Tuple>
+        struct result<_CVMu(_CVArg, _Tuple)>
+        {
+	  typedef typename add_reference<_CVArg>::type type;
+	};
+
+      // Pick up the cv-qualifiers of the argument
+      template<typename _CVArg, typename _Tuple>
+        _CVArg&
+        operator()(_CVArg& __arg, const _Tuple&) const volatile
+        { return __arg; }
+    };
+
+  /**
+   *  Maps member pointers into instances of _Mem_fn but leaves all
+   *  other function objects untouched. Used by tr1::bind(). The
+   *  primary template handles the non--member-pointer case.
+   */
+  template<typename _Tp>
+    struct _Maybe_wrap_member_pointer
+    {
+      typedef _Tp type;
+      
+      static const _Tp&
+      __do_wrap(const _Tp& __x)
+      { return __x; }
+    };
+
+  /**
+   *  Maps member pointers into instances of _Mem_fn but leaves all
+   *  other function objects untouched. Used by tr1::bind(). This
+   *  partial specialization handles the member pointer case.
+   */
+  template<typename _Tp, typename _Class>
+    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
+    {
+      typedef _Mem_fn<_Tp _Class::*> type;
+      
+      static type
+      __do_wrap(_Tp _Class::* __pm)
+      { return type(__pm); }
+    };
+
+  /// Type of the function object returned from bind().
+  template<typename _Signature>
+    struct _Bind;
+
+   template<typename _Functor, typename... _Bound_args>
+    class _Bind<_Functor(_Bound_args...)>
+    : public _Weak_result_type<_Functor>
+    {
+      typedef _Bind __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
+        _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+      // Call unqualified
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   _Functor(typename result_of<_Mu<_Bound_args> 
+                            (_Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   const _Functor(typename result_of<_Mu<_Bound_args> 
+                                    (const _Bound_args, tuple<_Args...>)
+                                  >::type...)>::type
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as volatile
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                                    (volatile _Bound_args, tuple<_Args...>)
+                                  >::type...)>::type
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const volatile
+      template<typename... _Args, int... _Indexes>
+        typename result_of<
+                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                                    (const volatile _Bound_args, 
+                                     tuple<_Args...>)
+                                  >::type...)>::type
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) const volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+     public:
+      explicit _Bind(_Functor __f, _Bound_args... __bound_args)
+        : _M_f(__f), _M_bound_args(__bound_args...) { }
+
+      // Call unqualified
+      template<typename... _Args>
+        typename result_of<
+                   _Functor(typename result_of<_Mu<_Bound_args> 
+                            (_Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args)
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+
+      // Call as const
+      template<typename... _Args>
+        typename result_of<
+                   const _Functor(typename result_of<_Mu<_Bound_args> 
+                            (const _Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args) const
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+
+
+      // Call as volatile
+      template<typename... _Args>
+        typename result_of<
+                   volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                            (volatile _Bound_args, tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args) volatile
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+
+
+      // Call as const volatile
+      template<typename... _Args>
+        typename result_of<
+                   const volatile _Functor(typename result_of<_Mu<_Bound_args> 
+                            (const volatile _Bound_args, 
+                             tuple<_Args...>)>::type...)
+                 >::type
+        operator()(_Args&... __args) const volatile
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+    };
+
+  /// Type of the function object returned from bind<R>().
+  template<typename _Result, typename _Signature>
+    struct _Bind_result;
+
+  template<typename _Result, typename _Functor, typename... _Bound_args>
+    class _Bind_result<_Result, _Functor(_Bound_args...)>
+    {
+      typedef _Bind_result __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 
+        _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+      // Call unqualified
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as volatile
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+      // Call as const volatile
+      template<typename... _Args, int... _Indexes>
+        _Result
+        __call(const tuple<_Args...>& __args, 
+               _Index_tuple<_Indexes...>) const volatile
+        {
+          return _M_f(_Mu<_Bound_args>()
+                      (tr1::get<_Indexes>(_M_bound_args), __args)...);
+        }
+
+    public:
+      typedef _Result result_type;
+
+      explicit
+      _Bind_result(_Functor __f, _Bound_args... __bound_args)
+      : _M_f(__f), _M_bound_args(__bound_args...) { }
+
+      // Call unqualified
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args)
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+
+      // Call as const
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args) const
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+
+      // Call as volatile
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args) volatile
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+
+      // Call as const volatile
+      template<typename... _Args>
+        result_type
+        operator()(_Args&... __args) const volatile
+        {
+          return this->__call(tr1::tie(__args...), _Bound_indexes());
+        }
+    };
+
+  /// Class template _Bind is always a bind expression.
+  template<typename _Signature>
+    struct is_bind_expression<_Bind<_Signature> >
+    { static const bool value = true; };
+
+  template<typename _Signature>
+    const bool is_bind_expression<_Bind<_Signature> >::value;
+
+  /// Class template _Bind is always a bind expression.
+  template<typename _Signature>
+    struct is_bind_expression<const _Bind<_Signature> >
+    { static const bool value = true; };
+
+  template<typename _Signature>
+    const bool is_bind_expression<const _Bind<_Signature> >::value;
+
+  /// Class template _Bind is always a bind expression.
+  template<typename _Signature>
+    struct is_bind_expression<volatile _Bind<_Signature> >
+    { static const bool value = true; };
+
+  template<typename _Signature>
+    const bool is_bind_expression<volatile _Bind<_Signature> >::value;
+
+  /// Class template _Bind is always a bind expression.
+  template<typename _Signature>
+    struct is_bind_expression<const volatile _Bind<_Signature> >
+    { static const bool value = true; };
+
+  template<typename _Signature>
+    const bool is_bind_expression<const volatile _Bind<_Signature> >::value;
+
+  /// Class template _Bind_result is always a bind expression.
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<_Bind_result<_Result, _Signature> >
+    { static const bool value = true; };
+
+  template<typename _Result, typename _Signature>
+    const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value;
+
+  /// Class template _Bind_result is always a bind expression.
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const _Bind_result<_Result, _Signature> >
+    { static const bool value = true; };
+
+  template<typename _Result, typename _Signature>
+    const bool
+    is_bind_expression<const _Bind_result<_Result, _Signature> >::value;
+
+  /// Class template _Bind_result is always a bind expression.
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile _Bind_result<_Result, _Signature> >
+    { static const bool value = true; };
+
+  template<typename _Result, typename _Signature>
+    const bool
+    is_bind_expression<volatile _Bind_result<_Result, _Signature> >::value;
+
+  /// Class template _Bind_result is always a bind expression.
+  template<typename _Result, typename _Signature>
+    struct
+    is_bind_expression<const volatile _Bind_result<_Result, _Signature> >
+    { static const bool value = true; };
+
+  template<typename _Result, typename _Signature>
+    const bool
+    is_bind_expression<const volatile _Bind_result<_Result,
+                                                   _Signature> >::value;
+
+#if __cplusplus >= 201103L
+  template<typename _Signature>
+    struct is_bind_expression<std::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Signature>
+    struct is_bind_expression<const std::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Signature>
+    struct is_bind_expression<volatile std::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Signature>
+    struct is_bind_expression<const volatile std::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<std::_Bind_result<_Result, _Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const std::_Bind_result<_Result, _Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile std::_Bind_result<_Result, _Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const volatile std::_Bind_result<_Result,
+                                                               _Signature>>
+    : true_type { };
+#endif
+
+  /// bind
+  template<typename _Functor, typename... _ArgTypes>
+    inline
+    _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)>
+    bind(_Functor __f, _ArgTypes... __args)
+    {
+      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
+      typedef typename __maybe_type::type __functor_type;
+      typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
+      return __result_type(__maybe_type::__do_wrap(__f), __args...);
+    } 
+
+  template<typename _Result, typename _Functor, typename... _ArgTypes>
+    inline
+    _Bind_result<_Result,
+		 typename _Maybe_wrap_member_pointer<_Functor>::type
+                            (_ArgTypes...)>
+    bind(_Functor __f, _ArgTypes... __args)
+    {
+      typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
+      typedef typename __maybe_type::type __functor_type;
+      typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
+	__result_type;
+      return __result_type(__maybe_type::__do_wrap(__f), __args...);
+    }
+
+  /**
+   *  @brief Exception class thrown when class template function's
+   *  operator() is called with an empty target.
+   *  @ingroup exceptions
+   */
+  class bad_function_call : public std::exception { };
+
+  /**
+   *  The integral constant expression 0 can be converted into a
+   *  pointer to this type. It is used by the function template to
+   *  accept NULL pointers.
+   */
+  struct _M_clear_type;
+
+  /**
+   *  Trait identifying @a location-invariant types, meaning that the
+   *  address of the object (or any of its members) will not escape.
+   *  Also implies a trivial copy constructor and assignment operator.
+   */
+  template<typename _Tp>
+    struct __is_location_invariant
+    : integral_constant<bool,
+                        (is_pointer<_Tp>::value
+                         || is_member_pointer<_Tp>::value)>
+    {
+    };
+
+  class _Undefined_class;
+
+  union _Nocopy_types
+  {
+    void*       _M_object;
+    const void* _M_const_object;
+    void (*_M_function_pointer)();
+    void (_Undefined_class::*_M_member_pointer)();
+  };
+
+  union _Any_data
+  {
+    void*       _M_access()       { return &_M_pod_data[0]; }
+    const void* _M_access() const { return &_M_pod_data[0]; }
+
+    template<typename _Tp>
+      _Tp&
+      _M_access()
+      { return *static_cast<_Tp*>(_M_access()); }
+
+    template<typename _Tp>
+      const _Tp&
+      _M_access() const
+      { return *static_cast<const _Tp*>(_M_access()); }
+
+    _Nocopy_types _M_unused;
+    char _M_pod_data[sizeof(_Nocopy_types)];
+  };
+
+  enum _Manager_operation
+  {
+    __get_type_info,
+    __get_functor_ptr,
+    __clone_functor,
+    __destroy_functor
+  };
+
+  // Simple type wrapper that helps avoid annoying const problems
+  // when casting between void pointers and pointers-to-pointers.
+  template<typename _Tp>
+    struct _Simple_type_wrapper
+    {
+      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+
+      _Tp __value;
+    };
+
+  template<typename _Tp>
+    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+    : __is_location_invariant<_Tp>
+    {
+    };
+
+  // Converts a reference to a function object into a callable
+  // function object.
+  template<typename _Functor>
+    inline _Functor&
+    __callable_functor(_Functor& __f)
+    { return __f; }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* &__p)
+    { return mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* const &__p)
+    { return mem_fn(__p); }
+
+  template<typename _Signature>
+    class function;
+
+  /// Base class of all polymorphic function object wrappers.
+  class _Function_base
+  {
+  public:
+    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
+    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
+
+    template<typename _Functor>
+      class _Base_manager
+      {
+      protected:
+	static const bool __stored_locally =
+        (__is_location_invariant<_Functor>::value
+         && sizeof(_Functor) <= _M_max_size
+         && __alignof__(_Functor) <= _M_max_align
+         && (_M_max_align % __alignof__(_Functor) == 0));
+	
+	typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+	// Retrieve a pointer to the function object
+	static _Functor*
+	_M_get_pointer(const _Any_data& __source)
+	{
+	  const _Functor* __ptr =
+	    __stored_locally? std::__addressof(__source._M_access<_Functor>())
+	    /* have stored a pointer */ : __source._M_access<_Functor*>();
+	  return const_cast<_Functor*>(__ptr);
+	}
+
+	// Clone a location-invariant function object that fits within
+	// an _Any_data structure.
+	static void
+	_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+	{
+	  new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+	}
+
+	// Clone a function object that is not location-invariant or
+	// that cannot fit into an _Any_data structure.
+	static void
+	_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+	{
+	  __dest._M_access<_Functor*>() =
+	    new _Functor(*__source._M_access<_Functor*>());
+	}
+
+	// Destroying a location-invariant object may still require
+	// destruction.
+	static void
+	_M_destroy(_Any_data& __victim, true_type)
+	{
+	  __victim._M_access<_Functor>().~_Functor();
+	}
+	
+	// Destroying an object located on the heap.
+	static void
+	_M_destroy(_Any_data& __victim, false_type)
+	{
+	  delete __victim._M_access<_Functor*>();
+	}
+	
+      public:
+	static bool
+	_M_manager(_Any_data& __dest, const _Any_data& __source,
+		   _Manager_operation __op)
+	{
+	  switch (__op)
+	    {
+#ifdef __GXX_RTTI
+	    case __get_type_info:
+	      __dest._M_access<const type_info*>() = &typeid(_Functor);
+	      break;
+#endif
+	    case __get_functor_ptr:
+	      __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+	      break;
+	      
+	    case __clone_functor:
+	      _M_clone(__dest, __source, _Local_storage());
+	      break;
+
+	    case __destroy_functor:
+	      _M_destroy(__dest, _Local_storage());
+	      break;
+	    }
+	  return false;
+	}
+
+	static void
+	_M_init_functor(_Any_data& __functor, const _Functor& __f)
+	{ _M_init_functor(__functor, __f, _Local_storage()); }
+	
+	template<typename _Signature>
+	  static bool
+	  _M_not_empty_function(const function<_Signature>& __f)
+          { return static_cast<bool>(__f); }
+
+	template<typename _Tp>
+	  static bool
+	  _M_not_empty_function(const _Tp*& __fp)
+	  { return __fp; }
+
+	template<typename _Class, typename _Tp>
+	  static bool
+	  _M_not_empty_function(_Tp _Class::* const& __mp)
+	  { return __mp; }
+
+	template<typename _Tp>
+	  static bool
+	  _M_not_empty_function(const _Tp&)
+	  { return true; }
+
+      private:
+	static void
+	_M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
+	{ new (__functor._M_access()) _Functor(__f); }
+
+	static void
+	_M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
+	{ __functor._M_access<_Functor*>() = new _Functor(__f); }
+      };
+
+    template<typename _Functor>
+      class _Ref_manager : public _Base_manager<_Functor*>
+      {
+	typedef _Function_base::_Base_manager<_Functor*> _Base;
+
+    public:
+	static bool
+	_M_manager(_Any_data& __dest, const _Any_data& __source,
+		   _Manager_operation __op)
+	{
+	  switch (__op)
+	    {
+#ifdef __GXX_RTTI
+	    case __get_type_info:
+	      __dest._M_access<const type_info*>() = &typeid(_Functor);
+	      break;
+#endif
+	    case __get_functor_ptr:
+	      __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
+	      return is_const<_Functor>::value;
+	      break;
+	      
+	    default:
+	      _Base::_M_manager(__dest, __source, __op);
+	    }
+	  return false;
+	}
+
+	static void
+	_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
+	{
+	  _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
+	}
+      };
+
+    _Function_base() : _M_manager(0) { }
+    
+    ~_Function_base()
+    {
+      if (_M_manager)
+	_M_manager(_M_functor, _M_functor, __destroy_functor);
+    }
+
+
+    bool _M_empty() const { return !_M_manager; }
+
+    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+                                  _Manager_operation);
+
+    _Any_data     _M_functor;
+    _Manager_type _M_manager;
+  };
+
+  template<typename _Signature, typename _Functor>
+    class _Function_handler;
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+    public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        return (*_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        (*_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        return 
+          __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        __callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename _Res, 
+           typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
+    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    {
+      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
+        _Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+        return tr1::
+	  mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    : public _Function_base::_Base_manager<
+                 _Simple_type_wrapper< _Member _Class::* > >
+    {
+      typedef _Member _Class::* _Functor;
+      typedef _Simple_type_wrapper<_Functor> _Wrapper;
+      typedef _Function_base::_Base_manager<_Wrapper> _Base;
+
+     public:
+      static bool
+      _M_manager(_Any_data& __dest, const _Any_data& __source,
+                 _Manager_operation __op)
+      {
+        switch (__op)
+	  {
+#ifdef __GXX_RTTI
+	  case __get_type_info:
+	    __dest._M_access<const type_info*>() = &typeid(_Functor);
+	    break;
+#endif	    
+	  case __get_functor_ptr:
+	    __dest._M_access<_Functor*>() =
+	      &_Base::_M_get_pointer(__source)->__value;
+	    break;
+	    
+	  default:
+	    _Base::_M_manager(__dest, __source, __op);
+	  }
+        return false;
+      }
+
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
+      {
+	tr1::mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+      }
+    };
+
+  /// class function
+  template<typename _Res, typename... _ArgTypes>
+    class function<_Res(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+      private _Function_base
+    {
+#if __cplusplus < 201103L
+      /// This class is used to implement the safe_bool idiom.
+      struct _Hidden_type
+      {
+	_Hidden_type* _M_bool;
+      };
+
+      /// This typedef is used to implement the safe_bool idiom.
+      typedef _Hidden_type* _Hidden_type::* _Safe_bool;
+#endif
+
+      typedef _Res _Signature_type(_ArgTypes...);
+      
+      struct _Useless { };
+      
+    public:
+      typedef _Res result_type;
+      
+      // [3.7.2.1] construct/copy/destroy
+      
+      /**
+       *  @brief Default construct creates an empty function call wrapper.
+       *  @post @c !(bool)*this
+       */
+      function() : _Function_base() { }
+      
+      /**
+       *  @brief Default construct creates an empty function call wrapper.
+       *  @post @c !(bool)*this
+       */
+      function(_M_clear_type*) : _Function_base() { }
+      
+      /**
+       *  @brief %Function copy constructor.
+       *  @param x A %function object with identical call signature.
+       *  @post @c (bool)*this == (bool)x
+       *
+       *  The newly-created %function contains a copy of the target of @a
+       *  x (if it has one).
+       */
+      function(const function& __x);
+
+      /**
+       *  @brief Builds a %function that targets a copy of the incoming
+       *  function object.
+       *  @param f A %function object that is callable with parameters of
+       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
+       *  to @c Res.
+       *
+       *  The newly-created %function object will target a copy of @a
+       *  f. If @a f is @c reference_wrapper<F>, then this function
+       *  object will contain a reference to the function object @c
+       *  f.get(). If @a f is a NULL function pointer or NULL
+       *  pointer-to-member, the newly-created object will be empty.
+       *
+       *  If @a f is a non-NULL function pointer or an object of type @c
+       *  reference_wrapper<F>, this function will not throw.
+       */
+      template<typename _Functor>
+        function(_Functor __f,
+                 typename __gnu_cxx::__enable_if<
+                           !is_integral<_Functor>::value, _Useless>::__type
+                   = _Useless());
+
+      /**
+       *  @brief %Function assignment operator.
+       *  @param x A %function with identical call signature.
+       *  @post @c (bool)*this == (bool)x
+       *  @returns @c *this
+       *
+       *  The target of @a x is copied to @c *this. If @a x has no
+       *  target, then @c *this will be empty.
+       *
+       *  If @a x targets a function pointer or a reference to a function
+       *  object, then this operation will not throw an %exception.
+       */
+      function&
+      operator=(const function& __x)
+      {
+        function(__x).swap(*this);
+        return *this;
+      }
+
+      /**
+       *  @brief %Function assignment to zero.
+       *  @post @c !(bool)*this
+       *  @returns @c *this
+       *
+       *  The target of @c *this is deallocated, leaving it empty.
+       */
+      function&
+      operator=(_M_clear_type*)
+      {
+        if (_M_manager)
+	  {
+	    _M_manager(_M_functor, _M_functor, __destroy_functor);
+	    _M_manager = 0;
+	    _M_invoker = 0;
+	  }
+        return *this;
+      }
+
+      /**
+       *  @brief %Function assignment to a new target.
+       *  @param f A %function object that is callable with parameters of
+       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
+       *  to @c Res.
+       *  @return @c *this
+       *
+       *  This  %function object wrapper will target a copy of @a
+       *  f. If @a f is @c reference_wrapper<F>, then this function
+       *  object will contain a reference to the function object @c
+       *  f.get(). If @a f is a NULL function pointer or NULL
+       *  pointer-to-member, @c this object will be empty.
+       *
+       *  If @a f is a non-NULL function pointer or an object of type @c
+       *  reference_wrapper<F>, this function will not throw.
+       */
+      template<typename _Functor>
+        typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
+	                                function&>::__type
+	operator=(_Functor __f)
+	{
+	  function(__f).swap(*this);
+	  return *this;
+	}
+
+      // [3.7.2.2] function modifiers
+      
+      /**
+       *  @brief Swap the targets of two %function objects.
+       *  @param f A %function with identical call signature.
+       *
+       *  Swap the targets of @c this function object and @a f. This
+       *  function will not throw an %exception.
+       */
+      void swap(function& __x)
+      {
+	std::swap(_M_functor, __x._M_functor);
+	std::swap(_M_manager, __x._M_manager);
+	std::swap(_M_invoker, __x._M_invoker);
+      }
+
+      // [3.7.2.3] function capacity
+
+      /**
+       *  @brief Determine if the %function wrapper has a target.
+       *
+       *  @return @c true when this %function object contains a target,
+       *  or @c false when it is empty.
+       *
+       *  This function will not throw an %exception.
+       */
+#if __cplusplus >= 201103L
+      explicit operator bool() const
+      { return !_M_empty(); }
+#else
+      operator _Safe_bool() const
+      {
+        if (_M_empty())
+	  return 0;
+	else
+	  return &_Hidden_type::_M_bool;
+      }
+#endif
+
+      // [3.7.2.4] function invocation
+
+      /**
+       *  @brief Invokes the function targeted by @c *this.
+       *  @returns the result of the target.
+       *  @throws bad_function_call when @c !(bool)*this
+       *
+       *  The function call operator invokes the target function object
+       *  stored by @c this.
+       */
+      _Res operator()(_ArgTypes... __args) const;
+
+#ifdef __GXX_RTTI
+      // [3.7.2.5] function target access
+      /**
+       *  @brief Determine the type of the target of this function object
+       *  wrapper.
+       *
+       *  @returns the type identifier of the target function object, or
+       *  @c typeid(void) if @c !(bool)*this.
+       *
+       *  This function will not throw an %exception.
+       */
+      const type_info& target_type() const;
+      
+      /**
+       *  @brief Access the stored target function object.
+       *
+       *  @return Returns a pointer to the stored target function object,
+       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
+       *  pointer.
+       *
+       * This function will not throw an %exception.
+       */
+      template<typename _Functor>       _Functor* target();
+      
+      /// @overload
+      template<typename _Functor> const _Functor* target() const;
+#endif
+
+    private:
+      // [3.7.2.6] undefined operators
+      template<typename _Function>
+	void operator==(const function<_Function>&) const;
+      template<typename _Function>
+	void operator!=(const function<_Function>&) const;
+
+      typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
+      _Invoker_type _M_invoker;
+  };
+
+  template<typename _Res, typename... _ArgTypes>
+    function<_Res(_ArgTypes...)>::
+    function(const function& __x)
+    : _Function_base()
+    {
+      if (static_cast<bool>(__x))
+	{
+	  _M_invoker = __x._M_invoker;
+	  _M_manager = __x._M_manager;
+	  __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+	}
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      function<_Res(_ArgTypes...)>::
+      function(_Functor __f,
+	       typename __gnu_cxx::__enable_if<
+                       !is_integral<_Functor>::value, _Useless>::__type)
+      : _Function_base()
+      {
+	typedef _Function_handler<_Signature_type, _Functor> _My_handler;
+
+	if (_My_handler::_M_not_empty_function(__f))
+	  {
+	    _M_invoker = &_My_handler::_M_invoke;
+	    _M_manager = &_My_handler::_M_manager;
+	    _My_handler::_M_init_functor(_M_functor, __f);
+	  }
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    _Res
+    function<_Res(_ArgTypes...)>::
+    operator()(_ArgTypes... __args) const
+    {
+      if (_M_empty())
+	_GLIBCXX_THROW_OR_ABORT(bad_function_call());
+      return _M_invoker(_M_functor, __args...);
+    }
+
+#ifdef __GXX_RTTI
+  template<typename _Res, typename... _ArgTypes>
+    const type_info&
+    function<_Res(_ArgTypes...)>::
+    target_type() const
+    {
+      if (_M_manager)
+        {
+          _Any_data __typeinfo_result;
+          _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+          return *__typeinfo_result._M_access<const type_info*>();
+        }
+      else
+	return typeid(void);
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      _Functor*
+      function<_Res(_ArgTypes...)>::
+      target()
+      {
+	if (typeid(_Functor) == target_type() && _M_manager)
+	  {
+	    _Any_data __ptr;
+	    if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
+		&& !is_const<_Functor>::value)
+	      return 0;
+	    else
+	      return __ptr._M_access<_Functor*>();
+	  }
+	else
+	  return 0;
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      const _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() const
+      {
+	if (typeid(_Functor) == target_type() && _M_manager)
+	  {
+	    _Any_data __ptr;
+	    _M_manager(__ptr, _M_functor, __get_functor_ptr);
+	    return __ptr._M_access<const _Functor*>();
+	  }
+	else
+	  return 0;
+      }
+#endif
+
+  // [3.7.2.7] null pointer comparisons
+
+  /**
+   *  @brief Compares a polymorphic function object wrapper against 0
+   *  (the NULL pointer).
+   *  @returns @c true if the wrapper has no target, @c false otherwise
+   *
+   *  This function will not throw an %exception.
+   */
+  template<typename _Signature>
+    inline bool
+    operator==(const function<_Signature>& __f, _M_clear_type*)
+    { return !static_cast<bool>(__f); }
+
+  /// @overload
+  template<typename _Signature>
+    inline bool
+    operator==(_M_clear_type*, const function<_Signature>& __f)
+    { return !static_cast<bool>(__f); }
+
+  /**
+   *  @brief Compares a polymorphic function object wrapper against 0
+   *  (the NULL pointer).
+   *  @returns @c false if the wrapper has no target, @c true otherwise
+   *
+   *  This function will not throw an %exception.
+   */
+  template<typename _Signature>
+    inline bool
+    operator!=(const function<_Signature>& __f, _M_clear_type*)
+    { return static_cast<bool>(__f); }
+
+  /// @overload
+  template<typename _Signature>
+    inline bool
+    operator!=(_M_clear_type*, const function<_Signature>& __f)
+    { return static_cast<bool>(__f); }
+
+  // [3.7.2.8] specialized algorithms
+
+  /**
+   *  @brief Swap the targets of two polymorphic function object wrappers.
+   *
+   *  This function will not throw an %exception.
+   */
+  template<typename _Signature>
+    inline void
+    swap(function<_Signature>& __x, function<_Signature>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+
+#if __cplusplus >= 201103L
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<typename> struct is_placeholder;
+
+  template<int _Num>
+    struct is_placeholder<tr1::_Placeholder<_Num>>
+    : integral_constant<int, _Num>
+    { };
+
+  template<int _Num>
+    struct is_placeholder<const tr1::_Placeholder<_Num>>
+    : integral_constant<int, _Num>
+    { };
+
+  template<typename> struct is_bind_expression;
+
+  template<typename _Signature>
+    struct is_bind_expression<tr1::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Signature>
+    struct is_bind_expression<const tr1::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Signature>
+    struct is_bind_expression<volatile tr1::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Signature>
+    struct is_bind_expression<const volatile tr1::_Bind<_Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<tr1::_Bind_result<_Result, _Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const tr1::_Bind_result<_Result, _Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile tr1::_Bind_result<_Result, _Signature>>
+    : true_type { };
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const volatile tr1::_Bind_result<_Result,
+                                                               _Signature>>
+    : true_type { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+#endif
+}
+
+#endif // _GLIBCXX_TR1_FUNCTIONAL
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/functional_hash.h b/gcc-4.9/libstdc++-v3/include/tr1/functional_hash.h
new file mode 100644
index 0000000..2f00bf3
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/functional_hash.h
@@ -0,0 +1,196 @@
+// TR1 functional_hash.h header -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/functional_hash.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/functional}
+ */
+
+#ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H
+#define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /// Class template hash.
+  // Declaration of default hash functor std::tr1::hash.  The types for
+  // which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
+  template<typename _Tp>
+    struct hash : public std::unary_function<_Tp, size_t>
+    {
+      size_t
+      operator()(_Tp __val) const;
+    };
+
+  /// Partial specializations for pointer types.
+  template<typename _Tp>
+    struct hash<_Tp*> : public std::unary_function<_Tp*, size_t>
+    {
+      size_t
+      operator()(_Tp* __p) const
+      { return reinterpret_cast<size_t>(__p); }
+    };
+
+  /// Explicit specializations for integer types.
+#define _TR1_hashtable_define_trivial_hash(_Tp) 	\
+  template<>						\
+    inline size_t					\
+    hash<_Tp>::operator()(_Tp __val) const		\
+    { return static_cast<size_t>(__val); }
+
+  _TR1_hashtable_define_trivial_hash(bool);
+  _TR1_hashtable_define_trivial_hash(char);
+  _TR1_hashtable_define_trivial_hash(signed char);
+  _TR1_hashtable_define_trivial_hash(unsigned char);
+  _TR1_hashtable_define_trivial_hash(wchar_t);
+  _TR1_hashtable_define_trivial_hash(short);
+  _TR1_hashtable_define_trivial_hash(int);
+  _TR1_hashtable_define_trivial_hash(long);
+  _TR1_hashtable_define_trivial_hash(long long);
+  _TR1_hashtable_define_trivial_hash(unsigned short);
+  _TR1_hashtable_define_trivial_hash(unsigned int);
+  _TR1_hashtable_define_trivial_hash(unsigned long);
+  _TR1_hashtable_define_trivial_hash(unsigned long long);
+
+#undef _TR1_hashtable_define_trivial_hash
+
+  // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
+  // (Used by the next specializations of std::tr1::hash.)
+
+  /// Dummy generic implementation (for sizeof(size_t) != 4, 8).
+  template<size_t>
+    struct _Fnv_hash_base
+    {
+      template<typename _Tp>
+        static size_t
+        hash(const _Tp* __ptr, size_t __clength)
+        {
+	  size_t __result = 0;
+	  const char* __cptr = reinterpret_cast<const char*>(__ptr);
+	  for (; __clength; --__clength)
+	    __result = (__result * 131) + *__cptr++;
+	  return __result;
+	}
+    };
+
+  template<>
+    struct _Fnv_hash_base<4>
+    {
+      template<typename _Tp>
+        static size_t
+        hash(const _Tp* __ptr, size_t __clength)
+        {
+	  size_t __result = static_cast<size_t>(2166136261UL);
+	  const char* __cptr = reinterpret_cast<const char*>(__ptr);
+	  for (; __clength; --__clength)
+	    {
+	      __result ^= static_cast<size_t>(*__cptr++);
+	      __result *= static_cast<size_t>(16777619UL);
+	    }
+	  return __result;
+	}
+    };
+  
+  template<>
+    struct _Fnv_hash_base<8>
+    {
+      template<typename _Tp>
+        static size_t
+        hash(const _Tp* __ptr, size_t __clength)
+        {
+	  size_t __result
+	    = static_cast<size_t>(14695981039346656037ULL);
+	  const char* __cptr = reinterpret_cast<const char*>(__ptr);
+	  for (; __clength; --__clength)
+	    {
+	      __result ^= static_cast<size_t>(*__cptr++);
+	      __result *= static_cast<size_t>(1099511628211ULL);
+	    }
+	  return __result;
+	}
+    };
+
+  struct _Fnv_hash
+  : public _Fnv_hash_base<sizeof(size_t)>
+  {
+    using _Fnv_hash_base<sizeof(size_t)>::hash;
+
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+  };
+
+  /// Explicit specializations for float.
+  template<>
+    inline size_t
+    hash<float>::operator()(float __val) const
+    {
+      // 0 and -0 both hash to zero.
+      return __val != 0.0f ? std::tr1::_Fnv_hash::hash(__val) : 0;
+    }
+
+  /// Explicit specializations for double.
+  template<>
+    inline size_t
+    hash<double>::operator()(double __val) const
+    {
+      // 0 and -0 both hash to zero.
+      return __val != 0.0 ? std::tr1::_Fnv_hash::hash(__val) : 0;
+    }
+
+  /// Explicit specializations for long double.
+  template<>
+    _GLIBCXX_PURE size_t
+    hash<long double>::operator()(long double __val) const;
+
+  /// Explicit specialization of member operator for non-builtin types.
+  template<>
+    _GLIBCXX_PURE size_t
+    hash<string>::operator()(string) const;
+
+  template<>
+    _GLIBCXX_PURE size_t
+    hash<const string&>::operator()(const string&) const;
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<>
+    _GLIBCXX_PURE size_t
+    hash<wstring>::operator()(wstring) const;
+
+  template<>
+    _GLIBCXX_PURE size_t
+    hash<const wstring&>::operator()(const wstring&) const;
+#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/gamma.tcc b/gcc-4.9/libstdc++-v3/include/tr1/gamma.tcc
new file mode 100644
index 0000000..840e614
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/gamma.tcc
@@ -0,0 +1,469 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/gamma.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 6, pp. 253-266
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 213-216
+//   (4) Gamma, Exploring Euler's Constant, Julian Havil,
+//       Princeton, 2003.
+
+#ifndef _GLIBCXX_TR1_GAMMA_TCC
+#define _GLIBCXX_TR1_GAMMA_TCC 1
+
+#include "special_function_util.h"
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief This returns Bernoulli numbers from a table or by summation
+     *          for larger values.
+     *
+     *   Recursion is unstable.
+     *
+     *   @param __n the order n of the Bernoulli number.
+     *   @return  The Bernoulli number of order n.
+     */
+    template <typename _Tp>
+    _Tp
+    __bernoulli_series(unsigned int __n)
+    {
+
+      static const _Tp __num[28] = {
+        _Tp(1UL),                        -_Tp(1UL) / _Tp(2UL),
+        _Tp(1UL) / _Tp(6UL),             _Tp(0UL),
+        -_Tp(1UL) / _Tp(30UL),           _Tp(0UL),
+        _Tp(1UL) / _Tp(42UL),            _Tp(0UL),
+        -_Tp(1UL) / _Tp(30UL),           _Tp(0UL),
+        _Tp(5UL) / _Tp(66UL),            _Tp(0UL),
+        -_Tp(691UL) / _Tp(2730UL),       _Tp(0UL),
+        _Tp(7UL) / _Tp(6UL),             _Tp(0UL),
+        -_Tp(3617UL) / _Tp(510UL),       _Tp(0UL),
+        _Tp(43867UL) / _Tp(798UL),       _Tp(0UL),
+        -_Tp(174611) / _Tp(330UL),       _Tp(0UL),
+        _Tp(854513UL) / _Tp(138UL),      _Tp(0UL),
+        -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL),
+        _Tp(8553103UL) / _Tp(6UL),       _Tp(0UL)
+      };
+
+      if (__n == 0)
+        return _Tp(1);
+
+      if (__n == 1)
+        return -_Tp(1) / _Tp(2);
+
+      //  Take care of the rest of the odd ones.
+      if (__n % 2 == 1)
+        return _Tp(0);
+
+      //  Take care of some small evens that are painful for the series.
+      if (__n < 28)
+        return __num[__n];
+
+
+      _Tp __fact = _Tp(1);
+      if ((__n / 2) % 2 == 0)
+        __fact *= _Tp(-1);
+      for (unsigned int __k = 1; __k <= __n; ++__k)
+        __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi());
+      __fact *= _Tp(2);
+
+      _Tp __sum = _Tp(0);
+      for (unsigned int __i = 1; __i < 1000; ++__i)
+        {
+          _Tp __term = std::pow(_Tp(__i), -_Tp(__n));
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+
+      return __fact * __sum;
+    }
+
+
+    /**
+     *   @brief This returns Bernoulli number \f$B_n\f$.
+     *
+     *   @param __n the order n of the Bernoulli number.
+     *   @return  The Bernoulli number of order n.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __bernoulli(int __n)
+    { return __bernoulli_series<_Tp>(__n); }
+
+
+    /**
+     *   @brief Return \f$log(\Gamma(x))\f$ by asymptotic expansion
+     *          with Bernoulli number coefficients.  This is like
+     *          Sterling's approximation.
+     *
+     *   @param __x The argument of the log of the gamma function.
+     *   @return  The logarithm of the gamma function.
+     */
+    template<typename _Tp>
+    _Tp
+    __log_gamma_bernoulli(_Tp __x)
+    {
+      _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x
+               + _Tp(0.5L) * std::log(_Tp(2)
+               * __numeric_constants<_Tp>::__pi());
+
+      const _Tp __xx = __x * __x;
+      _Tp __help = _Tp(1) / __x;
+      for ( unsigned int __i = 1; __i < 20; ++__i )
+        {
+          const _Tp __2i = _Tp(2 * __i);
+          __help /= __2i * (__2i - _Tp(1)) * __xx;
+          __lg += __bernoulli<_Tp>(2 * __i) * __help;
+        }
+
+      return __lg;
+    }
+
+
+    /**
+     *   @brief Return \f$log(\Gamma(x))\f$ by the Lanczos method.
+     *          This method dominates all others on the positive axis I think.
+     *
+     *   @param __x The argument of the log of the gamma function.
+     *   @return  The logarithm of the gamma function.
+     */
+    template<typename _Tp>
+    _Tp
+    __log_gamma_lanczos(_Tp __x)
+    {
+      const _Tp __xm1 = __x - _Tp(1);
+
+      static const _Tp __lanczos_cheb_7[9] = {
+       _Tp( 0.99999999999980993227684700473478L),
+       _Tp( 676.520368121885098567009190444019L),
+       _Tp(-1259.13921672240287047156078755283L),
+       _Tp( 771.3234287776530788486528258894L),
+       _Tp(-176.61502916214059906584551354L),
+       _Tp( 12.507343278686904814458936853L),
+       _Tp(-0.13857109526572011689554707L),
+       _Tp( 9.984369578019570859563e-6L),
+       _Tp( 1.50563273514931155834e-7L)
+      };
+
+      static const _Tp __LOGROOT2PI
+          = _Tp(0.9189385332046727417803297364056176L);
+
+      _Tp __sum = __lanczos_cheb_7[0];
+      for(unsigned int __k = 1; __k < 9; ++__k)
+        __sum += __lanczos_cheb_7[__k] / (__xm1 + __k);
+
+      const _Tp __term1 = (__xm1 + _Tp(0.5L))
+                        * std::log((__xm1 + _Tp(7.5L))
+                       / __numeric_constants<_Tp>::__euler());
+      const _Tp __term2 = __LOGROOT2PI + std::log(__sum);
+      const _Tp __result = __term1 + (__term2 - _Tp(7));
+
+      return __result;
+    }
+
+
+    /**
+     *   @brief Return \f$ log(|\Gamma(x)|) \f$.
+     *          This will return values even for \f$ x < 0 \f$.
+     *          To recover the sign of \f$ \Gamma(x) \f$ for
+     *          any argument use @a __log_gamma_sign.
+     *
+     *   @param __x The argument of the log of the gamma function.
+     *   @return  The logarithm of the gamma function.
+     */
+    template<typename _Tp>
+    _Tp
+    __log_gamma(_Tp __x)
+    {
+      if (__x > _Tp(0.5L))
+        return __log_gamma_lanczos(__x);
+      else
+        {
+          const _Tp __sin_fact
+                 = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x));
+          if (__sin_fact == _Tp(0))
+            std::__throw_domain_error(__N("Argument is nonpositive integer "
+                                          "in __log_gamma"));
+          return __numeric_constants<_Tp>::__lnpi()
+                     - std::log(__sin_fact)
+                     - __log_gamma_lanczos(_Tp(1) - __x);
+        }
+    }
+
+
+    /**
+     *   @brief Return the sign of \f$ \Gamma(x) \f$.
+     *          At nonpositive integers zero is returned.
+     *
+     *   @param __x The argument of the gamma function.
+     *   @return  The sign of the gamma function.
+     */
+    template<typename _Tp>
+    _Tp
+    __log_gamma_sign(_Tp __x)
+    {
+      if (__x > _Tp(0))
+        return _Tp(1);
+      else
+        {
+          const _Tp __sin_fact
+                  = std::sin(__numeric_constants<_Tp>::__pi() * __x);
+          if (__sin_fact > _Tp(0))
+            return (1);
+          else if (__sin_fact < _Tp(0))
+            return -_Tp(1);
+          else
+            return _Tp(0);
+        }
+    }
+
+
+    /**
+     *   @brief Return the logarithm of the binomial coefficient.
+     *   The binomial coefficient is given by:
+     *   @f[
+     *   \left(  \right) = \frac{n!}{(n-k)! k!}
+     *   @f]
+     *
+     *   @param __n The first argument of the binomial coefficient.
+     *   @param __k The second argument of the binomial coefficient.
+     *   @return  The binomial coefficient.
+     */
+    template<typename _Tp>
+    _Tp
+    __log_bincoef(unsigned int __n, unsigned int __k)
+    {
+      //  Max e exponent before overflow.
+      static const _Tp __max_bincoeff
+                      = std::numeric_limits<_Tp>::max_exponent10
+                      * std::log(_Tp(10)) - _Tp(1);
+#if _GLIBCXX_USE_C99_MATH_TR1
+      _Tp __coeff =  std::tr1::lgamma(_Tp(1 + __n))
+                  - std::tr1::lgamma(_Tp(1 + __k))
+                  - std::tr1::lgamma(_Tp(1 + __n - __k));
+#else
+      _Tp __coeff =  __log_gamma(_Tp(1 + __n))
+                  - __log_gamma(_Tp(1 + __k))
+                  - __log_gamma(_Tp(1 + __n - __k));
+#endif
+    }
+
+
+    /**
+     *   @brief Return the binomial coefficient.
+     *   The binomial coefficient is given by:
+     *   @f[
+     *   \left(  \right) = \frac{n!}{(n-k)! k!}
+     *   @f]
+     *
+     *   @param __n The first argument of the binomial coefficient.
+     *   @param __k The second argument of the binomial coefficient.
+     *   @return  The binomial coefficient.
+     */
+    template<typename _Tp>
+    _Tp
+    __bincoef(unsigned int __n, unsigned int __k)
+    {
+      //  Max e exponent before overflow.
+      static const _Tp __max_bincoeff
+                      = std::numeric_limits<_Tp>::max_exponent10
+                      * std::log(_Tp(10)) - _Tp(1);
+
+      const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k);
+      if (__log_coeff > __max_bincoeff)
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return std::exp(__log_coeff);
+    }
+
+
+    /**
+     *   @brief Return \f$ \Gamma(x) \f$.
+     *
+     *   @param __x The argument of the gamma function.
+     *   @return  The gamma function.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __gamma(_Tp __x)
+    { return std::exp(__log_gamma(__x)); }
+
+
+    /**
+     *   @brief  Return the digamma function by series expansion.
+     *   The digamma or @f$ \psi(x) @f$ function is defined by
+     *   @f[
+     *     \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)}
+     *   @f]
+     *
+     *   The series is given by:
+     *   @f[
+     *     \psi(x) = -\gamma_E - \frac{1}{x}
+     *              \sum_{k=1}^{\infty} \frac{x}{k(x + k)}
+     *   @f]
+     */
+    template<typename _Tp>
+    _Tp
+    __psi_series(_Tp __x)
+    {
+      _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x;
+      const unsigned int __max_iter = 100000;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          const _Tp __term = __x / (__k * (__k + __x));
+          __sum += __term;
+          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+      return __sum;
+    }
+
+
+    /**
+     *   @brief  Return the digamma function for large argument.
+     *   The digamma or @f$ \psi(x) @f$ function is defined by
+     *   @f[
+     *     \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)}
+     *   @f]
+     *
+     *   The asymptotic series is given by:
+     *   @f[
+     *     \psi(x) = \ln(x) - \frac{1}{2x}
+     *             - \sum_{n=1}^{\infty} \frac{B_{2n}}{2 n x^{2n}}
+     *   @f]
+     */
+    template<typename _Tp>
+    _Tp
+    __psi_asymp(_Tp __x)
+    {
+      _Tp __sum = std::log(__x) - _Tp(0.5L) / __x;
+      const _Tp __xx = __x * __x;
+      _Tp __xp = __xx;
+      const unsigned int __max_iter = 100;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp);
+          __sum -= __term;
+          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __xp *= __xx;
+        }
+      return __sum;
+    }
+
+
+    /**
+     *   @brief  Return the digamma function.
+     *   The digamma or @f$ \psi(x) @f$ function is defined by
+     *   @f[
+     *     \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)}
+     *   @f]
+     *   For negative argument the reflection formula is used:
+     *   @f[
+     *     \psi(x) = \psi(1-x) - \pi \cot(\pi x)
+     *   @f]
+     */
+    template<typename _Tp>
+    _Tp
+    __psi(_Tp __x)
+    {
+      const int __n = static_cast<int>(__x + 0.5L);
+      const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon();
+      if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps)
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x < _Tp(0))
+        {
+          const _Tp __pi = __numeric_constants<_Tp>::__pi();
+          return __psi(_Tp(1) - __x)
+               - __pi * std::cos(__pi * __x) / std::sin(__pi * __x);
+        }
+      else if (__x > _Tp(100))
+        return __psi_asymp(__x);
+      else
+        return __psi_series(__x);
+    }
+
+
+    /**
+     *   @brief  Return the polygamma function @f$ \psi^{(n)}(x) @f$.
+     * 
+     *   The polygamma function is related to the Hurwitz zeta function:
+     *   @f[
+     *     \psi^{(n)}(x) = (-1)^{n+1} m! \zeta(m+1,x)
+     *   @f]
+     */
+    template<typename _Tp>
+    _Tp
+    __psi(unsigned int __n, _Tp __x)
+    {
+      if (__x <= _Tp(0))
+        std::__throw_domain_error(__N("Argument out of range "
+                                      "in __psi"));
+      else if (__n == 0)
+        return __psi(__x);
+      else
+        {
+          const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);
+#if _GLIBCXX_USE_C99_MATH_TR1
+          const _Tp __ln_nfact = std::tr1::lgamma(_Tp(__n + 1));
+#else
+          const _Tp __ln_nfact = __log_gamma(_Tp(__n + 1));
+#endif
+          _Tp __result = std::exp(__ln_nfact) * __hzeta;
+          if (__n % 2 == 1)
+            __result = -__result;
+          return __result;
+        }
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_GAMMA_TCC
+
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/hashtable.h b/gcc-4.9/libstdc++-v3/include/tr1/hashtable.h
new file mode 100644
index 0000000..79a8ce9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/hashtable.h
@@ -0,0 +1,1181 @@
+// TR1 hashtable.h header -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/hashtable.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly.
+ *  @headername{tr1/unordered_set, tr1/unordered_map}
+ */
+
+#ifndef _GLIBCXX_TR1_HASHTABLE_H
+#define _GLIBCXX_TR1_HASHTABLE_H 1
+
+#pragma GCC system_header
+
+#include <tr1/hashtable_policy.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Class template _Hashtable, class definition.
+
+  // Meaning of class template _Hashtable's template parameters
+
+  // _Key and _Value: arbitrary CopyConstructible types.
+
+  // _Allocator: an allocator type ([lib.allocator.requirements]) whose
+  // value type is Value.  As a conforming extension, we allow for
+  // value type != Value.
+
+  // _ExtractKey: function object that takes a object of type Value
+  // and returns a value of type _Key.
+
+  // _Equal: function object that takes two objects of type k and returns
+  // a bool-like value that is true if the two objects are considered equal.
+
+  // _H1: the hash function.  A unary function object with argument type
+  // Key and result type size_t.  Return values should be distributed
+  // over the entire range [0, numeric_limits<size_t>:::max()].
+
+  // _H2: the range-hashing function (in the terminology of Tavori and
+  // Dreizin).  A binary function object whose argument types and result
+  // type are all size_t.  Given arguments r and N, the return value is
+  // in the range [0, N).
+
+  // _Hash: the ranged hash function (Tavori and Dreizin). A binary function
+  // whose argument types are _Key and size_t and whose result type is
+  // size_t.  Given arguments k and N, the return value is in the range
+  // [0, N).  Default: hash(k, N) = h2(h1(k), N).  If _Hash is anything other
+  // than the default, _H1 and _H2 are ignored.
+
+  // _RehashPolicy: Policy class with three members, all of which govern
+  // the bucket count. _M_next_bkt(n) returns a bucket count no smaller
+  // than n.  _M_bkt_for_elements(n) returns a bucket count appropriate
+  // for an element count of n.  _M_need_rehash(n_bkt, n_elt, n_ins)
+  // determines whether, if the current bucket count is n_bkt and the
+  // current element count is n_elt, we need to increase the bucket
+  // count.  If so, returns make_pair(true, n), where n is the new
+  // bucket count.  If not, returns make_pair(false, <anything>).
+
+  // ??? Right now it is hard-wired that the number of buckets never
+  // shrinks.  Should we allow _RehashPolicy to change that?
+
+  // __cache_hash_code: bool.  true if we store the value of the hash
+  // function along with the value.  This is a time-space tradeoff.
+  // Storing it may improve lookup speed by reducing the number of times
+  // we need to call the Equal function.
+
+  // __constant_iterators: bool.  true if iterator and const_iterator are
+  // both constant iterator types.  This is true for unordered_set and
+  // unordered_multiset, false for unordered_map and unordered_multimap.
+
+  // __unique_keys: bool.  true if the return value of _Hashtable::count(k)
+  // is always at most one, false if it may be an arbitrary number.  This
+  // true for unordered_set and unordered_map, false for unordered_multiset
+  // and unordered_multimap.
+
+  template<typename _Key, typename _Value, typename _Allocator,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   typename _RehashPolicy,
+	   bool __cache_hash_code,
+	   bool __constant_iterators,
+	   bool __unique_keys>
+    class _Hashtable
+    : public __detail::_Rehash_base<_RehashPolicy,
+				    _Hashtable<_Key, _Value, _Allocator,
+					       _ExtractKey,
+					       _Equal, _H1, _H2, _Hash,
+					       _RehashPolicy,
+					       __cache_hash_code,
+					       __constant_iterators,
+					       __unique_keys> >,
+      public __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
+				       _H1, _H2, _Hash, __cache_hash_code>,
+      public __detail::_Map_base<_Key, _Value, _ExtractKey, __unique_keys,
+				 _Hashtable<_Key, _Value, _Allocator,
+					    _ExtractKey,
+					    _Equal, _H1, _H2, _Hash,
+					    _RehashPolicy,
+					    __cache_hash_code,
+					    __constant_iterators,
+					    __unique_keys> >
+    {
+    public:
+      typedef _Allocator                                  allocator_type;
+      typedef _Value                                      value_type;
+      typedef _Key                                        key_type;
+      typedef _Equal                                      key_equal;
+      // mapped_type, if present, comes from _Map_base.
+      // hasher, if present, comes from _Hash_code_base.
+      typedef typename _Allocator::difference_type        difference_type;
+      typedef typename _Allocator::size_type              size_type;
+      typedef typename _Allocator::pointer                pointer;
+      typedef typename _Allocator::const_pointer          const_pointer;
+      typedef typename _Allocator::reference              reference;
+      typedef typename _Allocator::const_reference        const_reference;
+
+      typedef __detail::_Node_iterator<value_type, __constant_iterators,
+				       __cache_hash_code>
+							  local_iterator;
+      typedef __detail::_Node_const_iterator<value_type,
+					     __constant_iterators,
+					     __cache_hash_code>
+							  const_local_iterator;
+
+      typedef __detail::_Hashtable_iterator<value_type, __constant_iterators,
+					    __cache_hash_code>
+							  iterator;
+      typedef __detail::_Hashtable_const_iterator<value_type,
+						  __constant_iterators,
+						  __cache_hash_code>
+							  const_iterator;
+
+      template<typename _Key2, typename _Value2, typename _Ex2, bool __unique2,
+	       typename _Hashtable2>
+	friend struct __detail::_Map_base;
+
+    private:
+      typedef __detail::_Hash_node<_Value, __cache_hash_code> _Node;
+      typedef typename _Allocator::template rebind<_Node>::other
+							_Node_allocator_type;
+      typedef typename _Allocator::template rebind<_Node*>::other
+							_Bucket_allocator_type;
+
+      typedef typename _Allocator::template rebind<_Value>::other
+							_Value_allocator_type;
+
+      _Node_allocator_type   _M_node_allocator;
+      _Node**                _M_buckets;
+      size_type              _M_bucket_count;
+      size_type              _M_element_count;
+      _RehashPolicy          _M_rehash_policy;
+
+      _Node*
+      _M_allocate_node(const value_type& __v);
+
+      void
+      _M_deallocate_node(_Node* __n);
+
+      void
+      _M_deallocate_nodes(_Node**, size_type);
+
+      _Node**
+      _M_allocate_buckets(size_type __n);
+
+      void
+      _M_deallocate_buckets(_Node**, size_type __n);
+
+    public:
+      // Constructor, destructor, assignment, swap
+      _Hashtable(size_type __bucket_hint,
+		 const _H1&, const _H2&, const _Hash&,
+		 const _Equal&, const _ExtractKey&,
+		 const allocator_type&);
+
+      template<typename _InputIterator>
+	_Hashtable(_InputIterator __first, _InputIterator __last,
+		   size_type __bucket_hint,
+		   const _H1&, const _H2&, const _Hash&,
+		   const _Equal&, const _ExtractKey&,
+		   const allocator_type&);
+
+      _Hashtable(const _Hashtable&);
+
+      _Hashtable&
+      operator=(const _Hashtable&);
+
+      ~_Hashtable();
+
+      void swap(_Hashtable&);
+
+      // Basic container operations
+      iterator
+      begin()
+      {
+	iterator __i(_M_buckets);
+	if (!__i._M_cur_node)
+	  __i._M_incr_bucket();
+	return __i;
+      }
+
+      const_iterator
+      begin() const
+      {
+	const_iterator __i(_M_buckets);
+	if (!__i._M_cur_node)
+	  __i._M_incr_bucket();
+	return __i;
+      }
+
+      iterator
+      end()
+      { return iterator(_M_buckets + _M_bucket_count); }
+
+      const_iterator
+      end() const
+      { return const_iterator(_M_buckets + _M_bucket_count); }
+
+      size_type
+      size() const
+      { return _M_element_count; }
+
+      bool
+      empty() const
+      { return size() == 0; }
+
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_node_allocator); }
+
+      _Value_allocator_type
+      _M_get_Value_allocator() const
+      { return _Value_allocator_type(_M_node_allocator); }
+
+      size_type
+      max_size() const
+      { return _M_node_allocator.max_size(); }
+
+      // Observers
+      key_equal
+      key_eq() const
+      { return this->_M_eq; }
+
+      // hash_function, if present, comes from _Hash_code_base.
+
+      // Bucket operations
+      size_type
+      bucket_count() const
+      { return _M_bucket_count; }
+
+      size_type
+      max_bucket_count() const
+      { return max_size(); }
+
+      size_type
+      bucket_size(size_type __n) const
+      { return std::distance(begin(__n), end(__n)); }
+
+      size_type
+      bucket(const key_type& __k) const
+      {
+	return this->_M_bucket_index(__k, this->_M_hash_code(__k),
+				     bucket_count());
+      }
+
+      local_iterator
+      begin(size_type __n)
+      { return local_iterator(_M_buckets[__n]); }
+
+      local_iterator
+      end(size_type)
+      { return local_iterator(0); }
+
+      const_local_iterator
+      begin(size_type __n) const
+      { return const_local_iterator(_M_buckets[__n]); }
+
+      const_local_iterator
+      end(size_type) const
+      { return const_local_iterator(0); }
+
+      float
+      load_factor() const
+      {
+	return static_cast<float>(size()) / static_cast<float>(bucket_count());
+      }
+
+      // max_load_factor, if present, comes from _Rehash_base.
+
+      // Generalization of max_load_factor.  Extension, not found in TR1.  Only
+      // useful if _RehashPolicy is something other than the default.
+      const _RehashPolicy&
+      __rehash_policy() const
+      { return _M_rehash_policy; }
+
+      void
+      __rehash_policy(const _RehashPolicy&);
+
+      // Lookup.
+      iterator
+      find(const key_type& __k);
+
+      const_iterator
+      find(const key_type& __k) const;
+
+      size_type
+      count(const key_type& __k) const;
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __k);
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+
+    private:			// Find, insert and erase helper functions
+      // ??? This dispatching is a workaround for the fact that we don't
+      // have partial specialization of member templates; it would be
+      // better to just specialize insert on __unique_keys.  There may be a
+      // cleaner workaround.
+      typedef typename __gnu_cxx::__conditional_type<__unique_keys,
+		       	    std::pair<iterator, bool>, iterator>::__type
+	_Insert_Return_Type;
+
+      typedef typename __gnu_cxx::__conditional_type<__unique_keys,
+					  std::_Select1st<_Insert_Return_Type>,
+				  	  std::_Identity<_Insert_Return_Type>
+				   >::__type
+	_Insert_Conv_Type;
+
+      _Node*
+      _M_find_node(_Node*, const key_type&,
+		   typename _Hashtable::_Hash_code_type) const;
+
+      iterator
+      _M_insert_bucket(const value_type&, size_type,
+		       typename _Hashtable::_Hash_code_type);
+
+      std::pair<iterator, bool>
+      _M_insert(const value_type&, std::tr1::true_type);
+
+      iterator
+      _M_insert(const value_type&, std::tr1::false_type);
+
+      void
+      _M_erase_node(_Node*, _Node**);
+
+    public:
+      // Insert and erase
+      _Insert_Return_Type
+      insert(const value_type& __v)
+      { return _M_insert(__v, std::tr1::integral_constant<bool,
+			 __unique_keys>()); }
+
+      iterator
+      insert(iterator, const value_type& __v)
+      { return iterator(_Insert_Conv_Type()(this->insert(__v))); }
+
+      const_iterator
+      insert(const_iterator, const value_type& __v)
+      { return const_iterator(_Insert_Conv_Type()(this->insert(__v))); }
+
+      template<typename _InputIterator>
+	void
+	insert(_InputIterator __first, _InputIterator __last);
+
+      iterator
+      erase(iterator);
+
+      const_iterator
+      erase(const_iterator);
+
+      size_type
+      erase(const key_type&);
+
+      iterator
+      erase(iterator, iterator);
+
+      const_iterator
+      erase(const_iterator, const_iterator);
+
+      void
+      clear();
+
+      // Set number of buckets to be appropriate for container of n element.
+      void rehash(size_type __n);
+
+    private:
+      // Unconditionally change size of bucket array to n.
+      void _M_rehash(size_type __n);
+    };
+
+
+  // Definitions of class template _Hashtable's out-of-line member functions.
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::_Node*
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_allocate_node(const value_type& __v)
+    {
+      _Node* __n = _M_node_allocator.allocate(1);
+      __try
+	{
+	  _M_get_Value_allocator().construct(&__n->_M_v, __v);
+	  __n->_M_next = 0;
+	  return __n;
+	}
+      __catch(...)
+	{
+	  _M_node_allocator.deallocate(__n, 1);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_deallocate_node(_Node* __n)
+    {
+      _M_get_Value_allocator().destroy(&__n->_M_v);
+      _M_node_allocator.deallocate(__n, 1);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_deallocate_nodes(_Node** __array, size_type __n)
+    {
+      for (size_type __i = 0; __i < __n; ++__i)
+	{
+	  _Node* __p = __array[__i];
+	  while (__p)
+	    {
+	      _Node* __tmp = __p;
+	      __p = __p->_M_next;
+	      _M_deallocate_node(__tmp);
+	    }
+	  __array[__i] = 0;
+	}
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::_Node**
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_allocate_buckets(size_type __n)
+    {
+      _Bucket_allocator_type __alloc(_M_node_allocator);
+
+      // We allocate one extra bucket to hold a sentinel, an arbitrary
+      // non-null pointer.  Iterator increment relies on this.
+      _Node** __p = __alloc.allocate(__n + 1);
+      std::fill(__p, __p + __n, (_Node*) 0);
+      __p[__n] = reinterpret_cast<_Node*>(0x1000);
+      return __p;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_deallocate_buckets(_Node** __p, size_type __n)
+    {
+      _Bucket_allocator_type __alloc(_M_node_allocator);
+      __alloc.deallocate(__p, __n + 1);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _Hashtable(size_type __bucket_hint,
+	       const _H1& __h1, const _H2& __h2, const _Hash& __h,
+	       const _Equal& __eq, const _ExtractKey& __exk,
+	       const allocator_type& __a)
+    : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
+      __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
+				_H1, _H2, _Hash, __chc>(__exk, __eq,
+							__h1, __h2, __h),
+      __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
+      _M_node_allocator(__a),
+      _M_bucket_count(0),
+      _M_element_count(0),
+      _M_rehash_policy()
+    {
+      _M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint);
+      _M_buckets = _M_allocate_buckets(_M_bucket_count);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    template<typename _InputIterator>
+      _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+      _Hashtable(_InputIterator __f, _InputIterator __l,
+		 size_type __bucket_hint,
+		 const _H1& __h1, const _H2& __h2, const _Hash& __h,
+		 const _Equal& __eq, const _ExtractKey& __exk,
+		 const allocator_type& __a)
+      : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(),
+	__detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
+				  _H1, _H2, _Hash, __chc>(__exk, __eq,
+							  __h1, __h2, __h),
+	__detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(),
+	_M_node_allocator(__a),
+	_M_bucket_count(0),
+	_M_element_count(0),
+	_M_rehash_policy()
+      {
+	_M_bucket_count = std::max(_M_rehash_policy._M_next_bkt(__bucket_hint),
+				   _M_rehash_policy.
+				   _M_bkt_for_elements(__detail::
+						       __distance_fw(__f,
+								     __l)));
+	_M_buckets = _M_allocate_buckets(_M_bucket_count);
+	__try
+	  {
+	    for (; __f != __l; ++__f)
+	      this->insert(*__f);
+	  }
+	__catch(...)
+	  {
+	    clear();
+	    _M_deallocate_buckets(_M_buckets, _M_bucket_count);
+	    __throw_exception_again;
+	  }
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _Hashtable(const _Hashtable& __ht)
+    : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(__ht),
+      __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
+				_H1, _H2, _Hash, __chc>(__ht),
+      __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(__ht),
+      _M_node_allocator(__ht._M_node_allocator),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      _M_buckets = _M_allocate_buckets(_M_bucket_count);
+      __try
+	{
+	  for (size_type __i = 0; __i < __ht._M_bucket_count; ++__i)
+	    {
+	      _Node* __n = __ht._M_buckets[__i];
+	      _Node** __tail = _M_buckets + __i;
+	      while (__n)
+		{
+		  *__tail = _M_allocate_node(__n->_M_v);
+		  this->_M_copy_code(*__tail, __n);
+		  __tail = &((*__tail)->_M_next);
+		  __n = __n->_M_next;
+		}
+	    }
+	}
+      __catch(...)
+	{
+	  clear();
+	  _M_deallocate_buckets(_M_buckets, _M_bucket_count);
+	  __throw_exception_again;
+	}
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>&
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    operator=(const _Hashtable& __ht)
+    {
+      _Hashtable __tmp(__ht);
+      this->swap(__tmp);
+      return *this;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    ~_Hashtable()
+    {
+      clear();
+      _M_deallocate_buckets(_M_buckets, _M_bucket_count);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    swap(_Hashtable& __x)
+    {
+      // The only base class with member variables is hash_code_base.  We
+      // define _Hash_code_base::_M_swap because different specializations
+      // have different members.
+      __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal,
+	_H1, _H2, _Hash, __chc>::_M_swap(__x);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 431. Swapping containers with unequal allocators.
+      std::__alloc_swap<_Node_allocator_type>::_S_do_it(_M_node_allocator,
+							__x._M_node_allocator);
+
+      std::swap(_M_rehash_policy, __x._M_rehash_policy);
+      std::swap(_M_buckets, __x._M_buckets);
+      std::swap(_M_bucket_count, __x._M_bucket_count);
+      std::swap(_M_element_count, __x._M_element_count);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    __rehash_policy(const _RehashPolicy& __pol)
+    {
+      _M_rehash_policy = __pol;
+      size_type __n_bkt = __pol._M_bkt_for_elements(_M_element_count);
+      if (__n_bkt > _M_bucket_count)
+	_M_rehash(__n_bkt);
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    find(const key_type& __k)
+    {
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+      _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
+      return __p ? iterator(__p, _M_buckets + __n) : this->end();
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::const_iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    find(const key_type& __k) const
+    {
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+      _Node* __p = _M_find_node(_M_buckets[__n], __k, __code);
+      return __p ? const_iterator(__p, _M_buckets + __n) : this->end();
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::size_type
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    count(const key_type& __k) const
+    {
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+      std::size_t __result = 0;
+      for (_Node* __p = _M_buckets[__n]; __p; __p = __p->_M_next)
+	if (this->_M_compare(__k, __code, __p))
+	  ++__result;
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    std::pair<typename _Hashtable<_Key, _Value, _Allocator,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  __chc, __cit, __uk>::iterator,
+	      typename _Hashtable<_Key, _Value, _Allocator,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  __chc, __cit, __uk>::iterator>
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    equal_range(const key_type& __k)
+    {
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+      _Node** __head = _M_buckets + __n;
+      _Node* __p = _M_find_node(*__head, __k, __code);
+
+      if (__p)
+	{
+	  _Node* __p1 = __p->_M_next;
+	  for (; __p1; __p1 = __p1->_M_next)
+	    if (!this->_M_compare(__k, __code, __p1))
+	      break;
+
+	  iterator __first(__p, __head);
+	  iterator __last(__p1, __head);
+	  if (!__p1)
+	    __last._M_incr_bucket();
+	  return std::make_pair(__first, __last);
+	}
+      else
+	return std::make_pair(this->end(), this->end());
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    std::pair<typename _Hashtable<_Key, _Value, _Allocator,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  __chc, __cit, __uk>::const_iterator,
+	      typename _Hashtable<_Key, _Value, _Allocator,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  __chc, __cit, __uk>::const_iterator>
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    equal_range(const key_type& __k) const
+    {
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+      _Node** __head = _M_buckets + __n;
+      _Node* __p = _M_find_node(*__head, __k, __code);
+
+      if (__p)
+	{
+	  _Node* __p1 = __p->_M_next;
+	  for (; __p1; __p1 = __p1->_M_next)
+	    if (!this->_M_compare(__k, __code, __p1))
+	      break;
+
+	  const_iterator __first(__p, __head);
+	  const_iterator __last(__p1, __head);
+	  if (!__p1)
+	    __last._M_incr_bucket();
+	  return std::make_pair(__first, __last);
+	}
+      else
+	return std::make_pair(this->end(), this->end());
+    }
+
+  // Find the node whose key compares equal to k, beginning the search
+  // at p (usually the head of a bucket).  Return zero if no node is found.
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey,
+			_Equal, _H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::_Node*
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_find_node(_Node* __p, const key_type& __k,
+		typename _Hashtable::_Hash_code_type __code) const
+    {
+      for (; __p; __p = __p->_M_next)
+	if (this->_M_compare(__k, __code, __p))
+	  return __p;
+      return 0;
+    }
+
+  // Insert v in bucket n (assumes no element with its key already present).
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_insert_bucket(const value_type& __v, size_type __n,
+		    typename _Hashtable::_Hash_code_type __code)
+    {
+      std::pair<bool, std::size_t> __do_rehash
+	= _M_rehash_policy._M_need_rehash(_M_bucket_count,
+					  _M_element_count, 1);
+
+      // Allocate the new node before doing the rehash so that we don't
+      // do a rehash if the allocation throws.
+      _Node* __new_node = _M_allocate_node(__v);
+
+      __try
+	{
+	  if (__do_rehash.first)
+	    {
+	      const key_type& __k = this->_M_extract(__v);
+	      __n = this->_M_bucket_index(__k, __code, __do_rehash.second);
+	      _M_rehash(__do_rehash.second);
+	    }
+
+	  __new_node->_M_next = _M_buckets[__n];
+	  this->_M_store_code(__new_node, __code);
+	  _M_buckets[__n] = __new_node;
+	  ++_M_element_count;
+	  return iterator(__new_node, _M_buckets + __n);
+	}
+      __catch(...)
+	{
+	  _M_deallocate_node(__new_node);
+	  __throw_exception_again;
+	}
+    }
+
+  // Insert v if no element with its key is already present.
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    std::pair<typename _Hashtable<_Key, _Value, _Allocator,
+				  _ExtractKey, _Equal, _H1,
+				  _H2, _Hash, _RehashPolicy,
+				  __chc, __cit, __uk>::iterator, bool>
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+  _M_insert(const value_type& __v, std::tr1::true_type)
+    {
+      const key_type& __k = this->_M_extract(__v);
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+
+      if (_Node* __p = _M_find_node(_M_buckets[__n], __k, __code))
+	return std::make_pair(iterator(__p, _M_buckets + __n), false);
+      return std::make_pair(_M_insert_bucket(__v, __n, __code), true);
+    }
+
+  // Insert v unconditionally.
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_insert(const value_type& __v, std::tr1::false_type)
+    {
+      std::pair<bool, std::size_t> __do_rehash
+	= _M_rehash_policy._M_need_rehash(_M_bucket_count,
+					  _M_element_count, 1);
+      if (__do_rehash.first)
+	_M_rehash(__do_rehash.second);
+
+      const key_type& __k = this->_M_extract(__v);
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+
+      // First find the node, avoid leaking new_node if compare throws.
+      _Node* __prev = _M_find_node(_M_buckets[__n], __k, __code);
+      _Node* __new_node = _M_allocate_node(__v);
+
+      if (__prev)
+	{
+	  __new_node->_M_next = __prev->_M_next;
+	  __prev->_M_next = __new_node;
+	}
+      else
+	{
+	  __new_node->_M_next = _M_buckets[__n];
+	  _M_buckets[__n] = __new_node;
+	}
+      this->_M_store_code(__new_node, __code);
+
+      ++_M_element_count;
+      return iterator(__new_node, _M_buckets + __n);
+    }
+
+  // For erase(iterator) and erase(const_iterator).
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_erase_node(_Node* __p, _Node** __b)
+    {
+      _Node* __cur = *__b;
+      if (__cur == __p)
+	*__b = __cur->_M_next;
+      else
+	{
+	  _Node* __next = __cur->_M_next;
+	  while (__next != __p)
+	    {
+	      __cur = __next;
+	      __next = __cur->_M_next;
+	    }
+	  __cur->_M_next = __next->_M_next;
+	}
+
+      _M_deallocate_node(__p);
+      --_M_element_count;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    template<typename _InputIterator>
+      void
+      _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+		 _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+      insert(_InputIterator __first, _InputIterator __last)
+      {
+	size_type __n_elt = __detail::__distance_fw(__first, __last);
+	std::pair<bool, std::size_t> __do_rehash
+	  = _M_rehash_policy._M_need_rehash(_M_bucket_count,
+					    _M_element_count, __n_elt);
+	if (__do_rehash.first)
+	  _M_rehash(__do_rehash.second);
+
+	for (; __first != __last; ++__first)
+	  this->insert(*__first);
+      }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    erase(iterator __it)
+    {
+      iterator __result = __it;
+      ++__result;
+      _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::const_iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    erase(const_iterator __it)
+    {
+      const_iterator __result = __it;
+      ++__result;
+      _M_erase_node(__it._M_cur_node, __it._M_cur_bucket);
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::size_type
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    erase(const key_type& __k)
+    {
+      typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k);
+      std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count);
+      size_type __result = 0;
+
+      _Node** __slot = _M_buckets + __n;
+      while (*__slot && !this->_M_compare(__k, __code, *__slot))
+	__slot = &((*__slot)->_M_next);
+
+      _Node** __saved_slot = 0;
+      while (*__slot && this->_M_compare(__k, __code, *__slot))
+	{
+	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	  // 526. Is it undefined if a function in the standard changes
+	  // in parameters?
+	  if (&this->_M_extract((*__slot)->_M_v) != &__k)
+	    {
+	      _Node* __p = *__slot;
+	      *__slot = __p->_M_next;
+	      _M_deallocate_node(__p);
+	      --_M_element_count;
+	      ++__result;
+	    }
+	  else
+	    {
+	      __saved_slot = __slot;
+	      __slot = &((*__slot)->_M_next);
+	    }
+	}
+
+      if (__saved_slot)
+	{
+	  _Node* __p = *__saved_slot;
+	  *__saved_slot = __p->_M_next;
+	  _M_deallocate_node(__p);
+	  --_M_element_count;
+	  ++__result;
+	}
+
+      return __result;
+    }
+
+  // ??? This could be optimized by taking advantage of the bucket
+  // structure, but it's not clear that it's worth doing.  It probably
+  // wouldn't even be an optimization unless the load factor is large.
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    erase(iterator __first, iterator __last)
+    {
+      while (__first != __last)
+	__first = this->erase(__first);
+      return __last;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+			_H1, _H2, _Hash, _RehashPolicy,
+			__chc, __cit, __uk>::const_iterator
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    erase(const_iterator __first, const_iterator __last)
+    {
+      while (__first != __last)
+	__first = this->erase(__first);
+      return __last;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    clear()
+    {
+      _M_deallocate_nodes(_M_buckets, _M_bucket_count);
+      _M_element_count = 0;
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    rehash(size_type __n)
+    {
+      _M_rehash(std::max(_M_rehash_policy._M_next_bkt(__n),
+			 _M_rehash_policy._M_bkt_for_elements(_M_element_count
+							      + 1)));
+    }
+
+  template<typename _Key, typename _Value,
+	   typename _Allocator, typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+	   bool __chc, bool __cit, bool __uk>
+    void
+    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
+	       _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
+    _M_rehash(size_type __n)
+    {
+      _Node** __new_array = _M_allocate_buckets(__n);
+      __try
+	{
+	  for (size_type __i = 0; __i < _M_bucket_count; ++__i)
+	    while (_Node* __p = _M_buckets[__i])
+	      {
+		std::size_t __new_index = this->_M_bucket_index(__p, __n);
+		_M_buckets[__i] = __p->_M_next;
+		__p->_M_next = __new_array[__new_index];
+		__new_array[__new_index] = __p;
+	      }
+	  _M_deallocate_buckets(_M_buckets, _M_bucket_count);
+	  _M_bucket_count = __n;
+	  _M_buckets = __new_array;
+	}
+      __catch(...)
+	{
+	  // A failure here means that a hash function threw an exception.
+	  // We can't restore the previous state without calling the hash
+	  // function again, so the only sensible recovery is to delete
+	  // everything.
+	  _M_deallocate_nodes(__new_array, __n);
+	  _M_deallocate_buckets(__new_array, __n);
+	  _M_deallocate_nodes(_M_buckets, _M_bucket_count);
+	  _M_element_count = 0;
+	  __throw_exception_again;
+	}
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace tr1
+} // namespace std
+
+#endif // _GLIBCXX_TR1_HASHTABLE_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/hashtable_policy.h b/gcc-4.9/libstdc++-v3/include/tr1/hashtable_policy.h
new file mode 100644
index 0000000..7541f6e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/hashtable_policy.h
@@ -0,0 +1,783 @@
+// Internal policy header for TR1 unordered_set and unordered_map -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/hashtable_policy.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. 
+ *  @headername{tr1/unordered_map, tr1/unordered_set}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{ 
+namespace tr1
+{
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Helper function: return distance(first, last) for forward
+  // iterators, or 0 for input iterators.
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+		  std::input_iterator_tag)
+    { return 0; }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+		  std::forward_iterator_tag)
+    { return std::distance(__first, __last); }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last)
+    {
+      typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag;
+      return __distance_fw(__first, __last, _Tag());
+    }
+
+  // Auxiliary types used for all instantiations of _Hashtable: nodes
+  // and iterators.
+  
+  // Nodes, used to wrap elements stored in the hash table.  A policy
+  // template parameter of class template _Hashtable controls whether
+  // nodes also store a hash code. In some cases (e.g. strings) this
+  // may be a performance win.
+  template<typename _Value, bool __cache_hash_code>
+    struct _Hash_node;
+
+  template<typename _Value>
+    struct _Hash_node<_Value, true>
+    {
+      _Value       _M_v;
+      std::size_t  _M_hash_code;
+      _Hash_node*  _M_next;
+    };
+
+  template<typename _Value>
+    struct _Hash_node<_Value, false>
+    {
+      _Value       _M_v;
+      _Hash_node*  _M_next;
+    };
+
+  // Local iterators, used to iterate within a bucket but not between
+  // buckets.
+  template<typename _Value, bool __cache>
+    struct _Node_iterator_base
+    {
+      _Node_iterator_base(_Hash_node<_Value, __cache>* __p)
+      : _M_cur(__p) { }
+      
+      void
+      _M_incr()
+      { _M_cur = _M_cur->_M_next; }
+
+      _Hash_node<_Value, __cache>*  _M_cur;
+    };
+
+  template<typename _Value, bool __cache>
+    inline bool
+    operator==(const _Node_iterator_base<_Value, __cache>& __x,
+	       const _Node_iterator_base<_Value, __cache>& __y)
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Value, bool __cache>
+    inline bool
+    operator!=(const _Node_iterator_base<_Value, __cache>& __x,
+	       const _Node_iterator_base<_Value, __cache>& __y)
+    { return __x._M_cur != __y._M_cur; }
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+      typedef _Value                                   value_type;
+      typedef typename
+      __gnu_cxx::__conditional_type<__constant_iterators,
+				    const _Value*, _Value*>::__type
+                                                       pointer;
+      typedef typename
+      __gnu_cxx::__conditional_type<__constant_iterators,
+				    const _Value&, _Value&>::__type
+                                                       reference;
+      typedef std::ptrdiff_t                           difference_type;
+      typedef std::forward_iterator_tag                iterator_category;
+
+      _Node_iterator()
+      : _Node_iterator_base<_Value, __cache>(0) { }
+
+      explicit
+      _Node_iterator(_Hash_node<_Value, __cache>* __p)
+      : _Node_iterator_base<_Value, __cache>(__p) { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v; }
+  
+      pointer
+      operator->() const
+      { return std::__addressof(this->_M_cur->_M_v); }
+
+      _Node_iterator&
+      operator++()
+      { 
+	this->_M_incr();
+	return *this; 
+      }
+  
+      _Node_iterator
+      operator++(int)
+      { 
+	_Node_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_const_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+      typedef _Value                                   value_type;
+      typedef const _Value*                            pointer;
+      typedef const _Value&                            reference;
+      typedef std::ptrdiff_t                           difference_type;
+      typedef std::forward_iterator_tag                iterator_category;
+
+      _Node_const_iterator()
+      : _Node_iterator_base<_Value, __cache>(0) { }
+
+      explicit
+      _Node_const_iterator(_Hash_node<_Value, __cache>* __p)
+      : _Node_iterator_base<_Value, __cache>(__p) { }
+
+      _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
+			   __cache>& __x)
+      : _Node_iterator_base<_Value, __cache>(__x._M_cur) { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v; }
+  
+      pointer
+      operator->() const
+      { return std::__addressof(this->_M_cur->_M_v); }
+
+      _Node_const_iterator&
+      operator++()
+      { 
+	this->_M_incr();
+	return *this; 
+      }
+  
+      _Node_const_iterator
+      operator++(int)
+      { 
+	_Node_const_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+  template<typename _Value, bool __cache>
+    struct _Hashtable_iterator_base
+    {
+      _Hashtable_iterator_base(_Hash_node<_Value, __cache>* __node,
+			       _Hash_node<_Value, __cache>** __bucket)
+      : _M_cur_node(__node), _M_cur_bucket(__bucket) { }
+
+      void
+      _M_incr()
+      {
+	_M_cur_node = _M_cur_node->_M_next;
+	if (!_M_cur_node)
+	  _M_incr_bucket();
+      }
+
+      void
+      _M_incr_bucket();
+
+      _Hash_node<_Value, __cache>*   _M_cur_node;
+      _Hash_node<_Value, __cache>**  _M_cur_bucket;
+    };
+
+  // Global iterators, used for arbitrary iteration within a hash
+  // table.  Larger and more expensive than local iterators.
+  template<typename _Value, bool __cache>
+    void
+    _Hashtable_iterator_base<_Value, __cache>::
+    _M_incr_bucket()
+    {
+      ++_M_cur_bucket;
+
+      // This loop requires the bucket array to have a non-null sentinel.
+      while (!*_M_cur_bucket)
+	++_M_cur_bucket;
+      _M_cur_node = *_M_cur_bucket;
+    }
+
+  template<typename _Value, bool __cache>
+    inline bool
+    operator==(const _Hashtable_iterator_base<_Value, __cache>& __x,
+	       const _Hashtable_iterator_base<_Value, __cache>& __y)
+    { return __x._M_cur_node == __y._M_cur_node; }
+
+  template<typename _Value, bool __cache>
+    inline bool
+    operator!=(const _Hashtable_iterator_base<_Value, __cache>& __x,
+	       const _Hashtable_iterator_base<_Value, __cache>& __y)
+    { return __x._M_cur_node != __y._M_cur_node; }
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Hashtable_iterator
+    : public _Hashtable_iterator_base<_Value, __cache>
+    {
+      typedef _Value                                   value_type;
+      typedef typename
+      __gnu_cxx::__conditional_type<__constant_iterators,
+				    const _Value*, _Value*>::__type
+                                                       pointer;
+      typedef typename
+      __gnu_cxx::__conditional_type<__constant_iterators,
+				    const _Value&, _Value&>::__type
+                                                       reference;
+      typedef std::ptrdiff_t                           difference_type;
+      typedef std::forward_iterator_tag                iterator_category;
+
+      _Hashtable_iterator()
+      : _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
+
+      _Hashtable_iterator(_Hash_node<_Value, __cache>* __p,
+			  _Hash_node<_Value, __cache>** __b)
+      : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
+
+      explicit
+      _Hashtable_iterator(_Hash_node<_Value, __cache>** __b)
+      : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
+
+      reference
+      operator*() const
+      { return this->_M_cur_node->_M_v; }
+  
+      pointer
+      operator->() const
+      { return std::__addressof(this->_M_cur_node->_M_v); }
+
+      _Hashtable_iterator&
+      operator++()
+      { 
+	this->_M_incr();
+	return *this;
+      }
+  
+      _Hashtable_iterator
+      operator++(int)
+      { 
+	_Hashtable_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Hashtable_const_iterator
+    : public _Hashtable_iterator_base<_Value, __cache>
+    {
+      typedef _Value                                   value_type;
+      typedef const _Value*                            pointer;
+      typedef const _Value&                            reference;
+      typedef std::ptrdiff_t                           difference_type;
+      typedef std::forward_iterator_tag                iterator_category;
+
+      _Hashtable_const_iterator()
+      : _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
+
+      _Hashtable_const_iterator(_Hash_node<_Value, __cache>* __p,
+				_Hash_node<_Value, __cache>** __b)
+      : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
+
+      explicit
+      _Hashtable_const_iterator(_Hash_node<_Value, __cache>** __b)
+      : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
+
+      _Hashtable_const_iterator(const _Hashtable_iterator<_Value,
+				__constant_iterators, __cache>& __x)
+      : _Hashtable_iterator_base<_Value, __cache>(__x._M_cur_node,
+						  __x._M_cur_bucket) { }
+
+      reference
+      operator*() const
+      { return this->_M_cur_node->_M_v; }
+  
+      pointer
+      operator->() const
+      { return std::__addressof(this->_M_cur_node->_M_v); }
+
+      _Hashtable_const_iterator&
+      operator++()
+      { 
+	this->_M_incr();
+	return *this;
+      }
+  
+      _Hashtable_const_iterator
+      operator++(int)
+      { 
+	_Hashtable_const_iterator __tmp(*this);
+	this->_M_incr();
+	return __tmp;
+      }
+    };
+
+
+  // Many of class template _Hashtable's template parameters are policy
+  // classes.  These are defaults for the policies.
+
+  // Default range hashing function: use division to fold a large number
+  // into the range [0, N).
+  struct _Mod_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+
+    result_type
+    operator()(first_argument_type __num, second_argument_type __den) const
+    { return __num % __den; }
+  };
+
+  // Default ranged hash function H.  In principle it should be a
+  // function object composed from objects of type H1 and H2 such that
+  // h(k, N) = h2(h1(k), N), but that would mean making extra copies of
+  // h1 and h2.  So instead we'll just use a tag to tell class template
+  // hashtable to do that composition.
+  struct _Default_ranged_hash { };
+
+  // Default value for rehash policy.  Bucket size is (usually) the
+  // smallest prime that keeps the load factor small enough.
+  struct _Prime_rehash_policy
+  {
+    _Prime_rehash_policy(float __z = 1.0)
+    : _M_max_load_factor(__z), _M_growth_factor(2.f), _M_next_resize(0) { }
+
+    float
+    max_load_factor() const
+    { return _M_max_load_factor; }      
+
+    // Return a bucket size no smaller than n.
+    std::size_t
+    _M_next_bkt(std::size_t __n) const;
+    
+    // Return a bucket count appropriate for n elements
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const;
+    
+    // __n_bkt is current bucket count, __n_elt is current element count,
+    // and __n_ins is number of elements to be inserted.  Do we need to
+    // increase bucket count?  If so, return make_pair(true, n), where n
+    // is the new bucket count.  If not, return make_pair(false, 0).
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+		   std::size_t __n_ins) const;
+
+    enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 };
+
+    float                _M_max_load_factor;
+    float                _M_growth_factor;
+    mutable std::size_t  _M_next_resize;
+  };
+
+  extern const unsigned long __prime_list[];
+
+  // XXX This is a hack.  There's no good reason for any of
+  // _Prime_rehash_policy's member functions to be inline.  
+
+  // Return a prime no smaller than n.
+  inline std::size_t
+  _Prime_rehash_policy::
+  _M_next_bkt(std::size_t __n) const
+  {
+    const unsigned long* __p = std::lower_bound(__prime_list, __prime_list
+						+ _S_n_primes, __n);
+    _M_next_resize = 
+      static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
+    return *__p;
+  }
+
+  // Return the smallest prime p such that alpha p >= n, where alpha
+  // is the load factor.
+  inline std::size_t
+  _Prime_rehash_policy::
+  _M_bkt_for_elements(std::size_t __n) const
+  {
+    const float __min_bkts = __n / _M_max_load_factor;
+    const unsigned long* __p = std::lower_bound(__prime_list, __prime_list
+						+ _S_n_primes, __min_bkts);
+    _M_next_resize =
+      static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
+    return *__p;
+  }
+
+  // Finds the smallest prime p such that alpha p > __n_elt + __n_ins.
+  // If p > __n_bkt, return make_pair(true, p); otherwise return
+  // make_pair(false, 0).  In principle this isn't very different from 
+  // _M_bkt_for_elements.
+
+  // The only tricky part is that we're caching the element count at
+  // which we need to rehash, so we don't have to do a floating-point
+  // multiply for every insertion.
+
+  inline std::pair<bool, std::size_t>
+  _Prime_rehash_policy::
+  _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+		 std::size_t __n_ins) const
+  {
+    if (__n_elt + __n_ins > _M_next_resize)
+      {
+	float __min_bkts = ((float(__n_ins) + float(__n_elt))
+			    / _M_max_load_factor);
+	if (__min_bkts > __n_bkt)
+	  {
+	    __min_bkts = std::max(__min_bkts, _M_growth_factor * __n_bkt);
+	    const unsigned long* __p =
+	      std::lower_bound(__prime_list, __prime_list + _S_n_primes,
+			       __min_bkts);
+	    _M_next_resize = static_cast<std::size_t>
+	      (__builtin_ceil(*__p * _M_max_load_factor));
+	    return std::make_pair(true, *__p);
+	  }
+	else 
+	  {
+	    _M_next_resize = static_cast<std::size_t>
+	      (__builtin_ceil(__n_bkt * _M_max_load_factor));
+	    return std::make_pair(false, 0);
+	  }
+      }
+    else
+      return std::make_pair(false, 0);
+  }
+
+  // Base classes for std::tr1::_Hashtable.  We define these base
+  // classes because in some cases we want to do different things
+  // depending on the value of a policy class.  In some cases the
+  // policy class affects which member functions and nested typedefs
+  // are defined; we handle that by specializing base class templates.
+  // Several of the base class templates need to access other members
+  // of class template _Hashtable, so we use the "curiously recurring
+  // template pattern" for them.
+
+  // class template _Map_base.  If the hashtable has a value type of the
+  // form pair<T1, T2> and a key extraction policy that returns the
+  // first part of the pair, the hashtable gets a mapped_type typedef.
+  // If it satisfies those criteria and also has unique keys, then it
+  // also gets an operator[].  
+  template<typename _Key, typename _Value, typename _Ex, bool __unique,
+	   typename _Hashtable>
+    struct _Map_base { };
+	  
+  template<typename _Key, typename _Pair, typename _Hashtable>
+    struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, false, _Hashtable>
+    {
+      typedef typename _Pair::second_type mapped_type;
+    };
+
+  template<typename _Key, typename _Pair, typename _Hashtable>
+    struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>
+    {
+      typedef typename _Pair::second_type mapped_type;
+      
+      mapped_type&
+      operator[](const _Key& __k);
+    };
+
+  template<typename _Key, typename _Pair, typename _Hashtable>
+    typename _Map_base<_Key, _Pair, std::_Select1st<_Pair>,
+		       true, _Hashtable>::mapped_type&
+    _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>::
+    operator[](const _Key& __k)
+    {
+      _Hashtable* __h = static_cast<_Hashtable*>(this);
+      typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code,
+					     __h->_M_bucket_count);
+
+      typename _Hashtable::_Node* __p =
+	__h->_M_find_node(__h->_M_buckets[__n], __k, __code);
+      if (!__p)
+	return __h->_M_insert_bucket(std::make_pair(__k, mapped_type()),
+				     __n, __code)->second;
+      return (__p->_M_v).second;
+    }
+
+  // class template _Rehash_base.  Give hashtable the max_load_factor
+  // functions iff the rehash policy is _Prime_rehash_policy.
+  template<typename _RehashPolicy, typename _Hashtable>
+    struct _Rehash_base { };
+
+  template<typename _Hashtable>
+    struct _Rehash_base<_Prime_rehash_policy, _Hashtable>
+    {
+      float
+      max_load_factor() const
+      {
+	const _Hashtable* __this = static_cast<const _Hashtable*>(this);
+	return __this->__rehash_policy().max_load_factor();
+      }
+
+      void
+      max_load_factor(float __z)
+      {
+	_Hashtable* __this = static_cast<_Hashtable*>(this);
+	__this->__rehash_policy(_Prime_rehash_policy(__z));
+      }
+    };
+
+  // Class template _Hash_code_base.  Encapsulates two policy issues that
+  // aren't quite orthogonal.
+  //   (1) the difference between using a ranged hash function and using
+  //       the combination of a hash function and a range-hashing function.
+  //       In the former case we don't have such things as hash codes, so
+  //       we have a dummy type as placeholder.
+  //   (2) Whether or not we cache hash codes.  Caching hash codes is
+  //       meaningless if we have a ranged hash function.
+  // We also put the key extraction and equality comparison function 
+  // objects here, for convenience.
+  
+  // Primary template: unused except as a hook for specializations.  
+  template<typename _Key, typename _Value,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash,
+	   bool __cache_hash_code>
+    struct _Hash_code_base;
+
+  // Specialization: ranged hash function, no caching hash codes.  H1
+  // and H2 are provided but ignored.  We define a dummy hash code type.
+  template<typename _Key, typename _Value,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
+			   _Hash, false>
+    {
+    protected:
+      _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
+		      const _H1&, const _H2&, const _Hash& __h)
+      : _M_extract(__ex), _M_eq(__eq), _M_ranged_hash(__h) { }
+
+      typedef void* _Hash_code_type;
+  
+      _Hash_code_type
+      _M_hash_code(const _Key& __key) const
+      { return 0; }
+  
+      std::size_t
+      _M_bucket_index(const _Key& __k, _Hash_code_type,
+		      std::size_t __n) const
+      { return _M_ranged_hash(__k, __n); }
+
+      std::size_t
+      _M_bucket_index(const _Hash_node<_Value, false>* __p,
+		      std::size_t __n) const
+      { return _M_ranged_hash(_M_extract(__p->_M_v), __n); }
+  
+      bool
+      _M_compare(const _Key& __k, _Hash_code_type,
+		 _Hash_node<_Value, false>* __n) const
+      { return _M_eq(__k, _M_extract(__n->_M_v)); }
+
+      void
+      _M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
+      { }
+
+      void
+      _M_copy_code(_Hash_node<_Value, false>*,
+		   const _Hash_node<_Value, false>*) const
+      { }
+      
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+	std::swap(_M_extract, __x._M_extract);
+	std::swap(_M_eq, __x._M_eq);
+	std::swap(_M_ranged_hash, __x._M_ranged_hash);
+      }
+
+    protected:
+      _ExtractKey  _M_extract;
+      _Equal       _M_eq;
+      _Hash        _M_ranged_hash;
+    };
+
+
+  // No specialization for ranged hash function while caching hash codes.
+  // That combination is meaningless, and trying to do it is an error.
+  
+  
+  // Specialization: ranged hash function, cache hash codes.  This
+  // combination is meaningless, so we provide only a declaration
+  // and no definition.  
+  template<typename _Key, typename _Value,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
+			   _Hash, true>;
+
+  // Specialization: hash function and range-hashing function, no
+  // caching of hash codes.  H is provided but ignored.  Provides
+  // typedef and accessor required by TR1.  
+  template<typename _Key, typename _Value,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
+			   _Default_ranged_hash, false>
+    {
+      typedef _H1 hasher;
+
+      hasher
+      hash_function() const
+      { return _M_h1; }
+
+    protected:
+      _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
+		      const _H1& __h1, const _H2& __h2,
+		      const _Default_ranged_hash&)
+      : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
+
+      typedef std::size_t _Hash_code_type;
+
+      _Hash_code_type
+      _M_hash_code(const _Key& __k) const
+      { return _M_h1(__k); }
+      
+      std::size_t
+      _M_bucket_index(const _Key&, _Hash_code_type __c,
+		      std::size_t __n) const
+      { return _M_h2(__c, __n); }
+
+      std::size_t
+      _M_bucket_index(const _Hash_node<_Value, false>* __p,
+		      std::size_t __n) const
+      { return _M_h2(_M_h1(_M_extract(__p->_M_v)), __n); }
+
+      bool
+      _M_compare(const _Key& __k, _Hash_code_type,
+		 _Hash_node<_Value, false>* __n) const
+      { return _M_eq(__k, _M_extract(__n->_M_v)); }
+
+      void
+      _M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
+      { }
+
+      void
+      _M_copy_code(_Hash_node<_Value, false>*,
+		   const _Hash_node<_Value, false>*) const
+      { }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+	std::swap(_M_extract, __x._M_extract);
+	std::swap(_M_eq, __x._M_eq);
+	std::swap(_M_h1, __x._M_h1);
+	std::swap(_M_h2, __x._M_h2);
+      }
+
+    protected:
+      _ExtractKey  _M_extract;
+      _Equal       _M_eq;
+      _H1          _M_h1;
+      _H2          _M_h2;
+    };
+
+  // Specialization: hash function and range-hashing function, 
+  // caching hash codes.  H is provided but ignored.  Provides
+  // typedef and accessor required by TR1.
+  template<typename _Key, typename _Value,
+	   typename _ExtractKey, typename _Equal,
+	   typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
+			   _Default_ranged_hash, true>
+    {
+      typedef _H1 hasher;
+      
+      hasher
+      hash_function() const
+      { return _M_h1; }
+
+    protected:
+      _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
+		      const _H1& __h1, const _H2& __h2,
+		      const _Default_ranged_hash&)
+      : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
+
+      typedef std::size_t _Hash_code_type;
+  
+      _Hash_code_type
+      _M_hash_code(const _Key& __k) const
+      { return _M_h1(__k); }
+  
+      std::size_t
+      _M_bucket_index(const _Key&, _Hash_code_type __c,
+		      std::size_t __n) const
+      { return _M_h2(__c, __n); }
+
+      std::size_t
+      _M_bucket_index(const _Hash_node<_Value, true>* __p,
+		      std::size_t __n) const
+      { return _M_h2(__p->_M_hash_code, __n); }
+
+      bool
+      _M_compare(const _Key& __k, _Hash_code_type __c,
+		 _Hash_node<_Value, true>* __n) const
+      { return __c == __n->_M_hash_code && _M_eq(__k, _M_extract(__n->_M_v)); }
+
+      void
+      _M_store_code(_Hash_node<_Value, true>* __n, _Hash_code_type __c) const
+      { __n->_M_hash_code = __c; }
+
+      void
+      _M_copy_code(_Hash_node<_Value, true>* __to,
+		   const _Hash_node<_Value, true>* __from) const
+      { __to->_M_hash_code = __from->_M_hash_code; }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+	std::swap(_M_extract, __x._M_extract);
+	std::swap(_M_eq, __x._M_eq);
+	std::swap(_M_h1, __x._M_h1);
+	std::swap(_M_h2, __x._M_h2);
+      }
+      
+    protected:
+      _ExtractKey  _M_extract;
+      _Equal       _M_eq;
+      _H1          _M_h1;
+      _H2          _M_h2;
+    };
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+}
+}
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/hypergeometric.tcc b/gcc-4.9/libstdc++-v3/include/tr1/hypergeometric.tcc
new file mode 100644
index 0000000..9b768fd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/hypergeometric.tcc
@@ -0,0 +1,775 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/hypergeometric.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based:
+//   (1) Handbook of Mathematical Functions,
+//       ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 6, pp. 555-566
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+
+#ifndef _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
+#define _GLIBCXX_TR1_HYPERGEOMETRIC_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief This routine returns the confluent hypergeometric function
+     *          by series expansion.
+     * 
+     *   @f[
+     *     _1F_1(a;c;x) = \frac{\Gamma(c)}{\Gamma(a)}
+     *                      \sum_{n=0}^{\infty}
+     *                      \frac{\Gamma(a+n)}{\Gamma(c+n)}
+     *                      \frac{x^n}{n!}
+     *   @f]
+     * 
+     *   If a and b are integers and a < 0 and either b > 0 or b < a
+     *   then the series is a polynomial with a finite number of
+     *   terms.  If b is an integer and b <= 0 the confluent
+     *   hypergeometric function is undefined.
+     *
+     *   @param  __a  The "numerator" parameter.
+     *   @param  __c  The "denominator" parameter.
+     *   @param  __x  The argument of the confluent hypergeometric function.
+     *   @return  The confluent hypergeometric function.
+     */
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+      _Tp __term = _Tp(1);
+      _Tp __Fac = _Tp(1);
+      const unsigned int __max_iter = 100000;
+      unsigned int __i;
+      for (__i = 0; __i < __max_iter; ++__i)
+        {
+          __term *= (__a + _Tp(__i)) * __x
+                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
+          if (std::abs(__term) < __eps)
+            {
+              break;
+            }
+          __Fac += __term;
+        }
+      if (__i == __max_iter)
+        std::__throw_runtime_error(__N("Series failed to converge "
+                                       "in __conf_hyperg_series."));
+
+      return __Fac;
+    }
+
+
+    /**
+     *  @brief  Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$
+     *          by an iterative procedure described in
+     *          Luke, Algorithms for the Computation of Mathematical Functions.
+     *
+     *  Like the case of the 2F1 rational approximations, these are 
+     *  probably guaranteed to converge for x < 0, barring gross    
+     *  numerical instability in the pre-asymptotic regime.         
+     */
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin)
+    {
+      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
+      const int __nmax = 20000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __x  = -__xin;
+      const _Tp __x3 = __x * __x * __x;
+      const _Tp __t0 = __a / __c;
+      const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c);
+      const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1)));
+      _Tp __F = _Tp(1);
+      _Tp __prec;
+
+      _Tp __Bnm3 = _Tp(1);
+      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
+      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
+
+      _Tp __Anm3 = _Tp(1);
+      _Tp __Anm2 = __Bnm2 - __t0 * __x;
+      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
+
+      int __n = 3;
+      while(1)
+        {
+          _Tp __npam1 = _Tp(__n - 1) + __a;
+          _Tp __npcm1 = _Tp(__n - 1) + __c;
+          _Tp __npam2 = _Tp(__n - 2) + __a;
+          _Tp __npcm2 = _Tp(__n - 2) + __c;
+          _Tp __tnm1  = _Tp(2 * __n - 1);
+          _Tp __tnm3  = _Tp(2 * __n - 3);
+          _Tp __tnm5  = _Tp(2 * __n - 5);
+          _Tp __F1 =  (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1);
+          _Tp __F2 =  (_Tp(__n) + __a) * __npam1
+                   / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
+          _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a)
+                   / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
+                   * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
+          _Tp __E  = -__npam1 * (_Tp(__n - 1) - __c)
+                   / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
+
+          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
+          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
+          _Tp __r = __An / __Bn;
+
+          __prec = std::abs((__F - __r) / __F);
+          __F = __r;
+
+          if (__prec < __eps || __n > __nmax)
+            break;
+
+          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
+            {
+              __An   /= __big;
+              __Bn   /= __big;
+              __Anm1 /= __big;
+              __Bnm1 /= __big;
+              __Anm2 /= __big;
+              __Bnm2 /= __big;
+              __Anm3 /= __big;
+              __Bnm3 /= __big;
+            }
+          else if (std::abs(__An) < _Tp(1) / __big
+                || std::abs(__Bn) < _Tp(1) / __big)
+            {
+              __An   *= __big;
+              __Bn   *= __big;
+              __Anm1 *= __big;
+              __Bnm1 *= __big;
+              __Anm2 *= __big;
+              __Bnm2 *= __big;
+              __Anm3 *= __big;
+              __Bnm3 *= __big;
+            }
+
+          ++__n;
+          __Bnm3 = __Bnm2;
+          __Bnm2 = __Bnm1;
+          __Bnm1 = __Bn;
+          __Anm3 = __Anm2;
+          __Anm2 = __Anm1;
+          __Anm1 = __An;
+        }
+
+      if (__n >= __nmax)
+        std::__throw_runtime_error(__N("Iteration failed to converge "
+                                       "in __conf_hyperg_luke."));
+
+      return __F;
+    }
+
+
+    /**
+     *   @brief  Return the confluent hypogeometric function
+     *           @f$ _1F_1(a;c;x) @f$.
+     * 
+     *   @todo  Handle b == nonpositive integer blowup - return NaN.
+     *
+     *   @param  __a  The @a numerator parameter.
+     *   @param  __c  The @a denominator parameter.
+     *   @param  __x  The argument of the confluent hypergeometric function.
+     *   @return  The confluent hypergeometric function.
+     */
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg(_Tp __a, _Tp __c, _Tp __x)
+    {
+#if _GLIBCXX_USE_C99_MATH_TR1
+      const _Tp __c_nint = std::tr1::nearbyint(__c);
+#else
+      const _Tp __c_nint = static_cast<int>(__c + _Tp(0.5L));
+#endif
+      if (__isnan(__a) || __isnan(__c) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__c_nint == __c && __c_nint <= 0)
+        return std::numeric_limits<_Tp>::infinity();
+      else if (__a == _Tp(0))
+        return _Tp(1);
+      else if (__c == __a)
+        return std::exp(__x);
+      else if (__x < _Tp(0))
+        return __conf_hyperg_luke(__a, __c, __x);
+      else
+        return __conf_hyperg_series(__a, __c, __x);
+    }
+
+
+    /**
+     *   @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$
+     *   by series expansion.
+     * 
+     *   The hypogeometric function is defined by
+     *   @f[
+     *     _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)}
+     *                      \sum_{n=0}^{\infty}
+     *                      \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)}
+     *                      \frac{x^n}{n!}
+     *   @f]
+     * 
+     *   This works and it's pretty fast.
+     *
+     *   @param  __a  The first @a numerator parameter.
+     *   @param  __a  The second @a numerator parameter.
+     *   @param  __c  The @a denominator parameter.
+     *   @param  __x  The argument of the confluent hypergeometric function.
+     *   @return  The confluent hypergeometric function.
+     */
+    template<typename _Tp>
+    _Tp
+    __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+      _Tp __term = _Tp(1);
+      _Tp __Fabc = _Tp(1);
+      const unsigned int __max_iter = 100000;
+      unsigned int __i;
+      for (__i = 0; __i < __max_iter; ++__i)
+        {
+          __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x
+                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
+          if (std::abs(__term) < __eps)
+            {
+              break;
+            }
+          __Fabc += __term;
+        }
+      if (__i == __max_iter)
+        std::__throw_runtime_error(__N("Series failed to converge "
+                                       "in __hyperg_series."));
+
+      return __Fabc;
+    }
+
+
+    /**
+     *   @brief  Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$
+     *           by an iterative procedure described in
+     *           Luke, Algorithms for the Computation of Mathematical Functions.
+     */
+    template<typename _Tp>
+    _Tp
+    __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin)
+    {
+      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
+      const int __nmax = 20000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __x  = -__xin;
+      const _Tp __x3 = __x * __x * __x;
+      const _Tp __t0 = __a * __b / __c;
+      const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c);
+      const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2))
+                     / (_Tp(2) * (__c + _Tp(1)));
+
+      _Tp __F = _Tp(1);
+
+      _Tp __Bnm3 = _Tp(1);
+      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
+      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
+
+      _Tp __Anm3 = _Tp(1);
+      _Tp __Anm2 = __Bnm2 - __t0 * __x;
+      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
+
+      int __n = 3;
+      while (1)
+        {
+          const _Tp __npam1 = _Tp(__n - 1) + __a;
+          const _Tp __npbm1 = _Tp(__n - 1) + __b;
+          const _Tp __npcm1 = _Tp(__n - 1) + __c;
+          const _Tp __npam2 = _Tp(__n - 2) + __a;
+          const _Tp __npbm2 = _Tp(__n - 2) + __b;
+          const _Tp __npcm2 = _Tp(__n - 2) + __c;
+          const _Tp __tnm1  = _Tp(2 * __n - 1);
+          const _Tp __tnm3  = _Tp(2 * __n - 3);
+          const _Tp __tnm5  = _Tp(2 * __n - 5);
+          const _Tp __n2 = __n * __n;
+          const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n
+                         + _Tp(2) - __a * __b - _Tp(2) * (__a + __b))
+                         / (_Tp(2) * __tnm3 * __npcm1);
+          const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n
+                         + _Tp(2) - __a * __b) * __npam1 * __npbm1
+                         / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
+          const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1
+                         * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b))
+                         / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
+                         * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
+          const _Tp __E  = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c)
+                         / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
+
+          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
+          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
+          const _Tp __r = __An / __Bn;
+
+          const _Tp __prec = std::abs((__F - __r) / __F);
+          __F = __r;
+
+          if (__prec < __eps || __n > __nmax)
+            break;
+
+          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
+            {
+              __An   /= __big;
+              __Bn   /= __big;
+              __Anm1 /= __big;
+              __Bnm1 /= __big;
+              __Anm2 /= __big;
+              __Bnm2 /= __big;
+              __Anm3 /= __big;
+              __Bnm3 /= __big;
+            }
+          else if (std::abs(__An) < _Tp(1) / __big
+                || std::abs(__Bn) < _Tp(1) / __big)
+            {
+              __An   *= __big;
+              __Bn   *= __big;
+              __Anm1 *= __big;
+              __Bnm1 *= __big;
+              __Anm2 *= __big;
+              __Bnm2 *= __big;
+              __Anm3 *= __big;
+              __Bnm3 *= __big;
+            }
+
+          ++__n;
+          __Bnm3 = __Bnm2;
+          __Bnm2 = __Bnm1;
+          __Bnm1 = __Bn;
+          __Anm3 = __Anm2;
+          __Anm2 = __Anm1;
+          __Anm1 = __An;
+        }
+
+      if (__n >= __nmax)
+        std::__throw_runtime_error(__N("Iteration failed to converge "
+                                       "in __hyperg_luke."));
+
+      return __F;
+    }
+
+
+    /**
+     *  @brief  Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$ 
+     *  by the reflection formulae in Abramowitz & Stegun formula
+     *  15.3.6 for d = c - a - b not integral and formula 15.3.11 for
+     *  d = c - a - b integral.  This assumes a, b, c != negative
+     *  integer.
+     *
+     *   The hypogeometric function is defined by
+     *   @f[
+     *     _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)}
+     *                      \sum_{n=0}^{\infty}
+     *                      \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)}
+     *                      \frac{x^n}{n!}
+     *   @f]
+     *
+     *   The reflection formula for nonintegral @f$ d = c - a - b @f$ is:
+     *   @f[
+     *     _2F_1(a,b;c;x) = \frac{\Gamma(c)\Gamma(d)}{\Gamma(c-a)\Gamma(c-b)}
+     *                            _2F_1(a,b;1-d;1-x)
+     *                    + \frac{\Gamma(c)\Gamma(-d)}{\Gamma(a)\Gamma(b)}
+     *                            _2F_1(c-a,c-b;1+d;1-x)
+     *   @f]
+     *
+     *   The reflection formula for integral @f$ m = c - a - b @f$ is:
+     *   @f[
+     *     _2F_1(a,b;a+b+m;x) = \frac{\Gamma(m)\Gamma(a+b+m)}{\Gamma(a+m)\Gamma(b+m)}
+     *                        \sum_{k=0}^{m-1} \frac{(m+a)_k(m+b)_k}{k!(1-m)_k}
+     *                      - 
+     *   @f]
+     */
+    template<typename _Tp>
+    _Tp
+    __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+      const _Tp __d = __c - __a - __b;
+      const int __intd  = std::floor(__d + _Tp(0.5L));
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __toler = _Tp(1000) * __eps;
+      const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max());
+      const bool __d_integer = (std::abs(__d - __intd) < __toler);
+
+      if (__d_integer)
+        {
+          const _Tp __ln_omx = std::log(_Tp(1) - __x);
+          const _Tp __ad = std::abs(__d);
+          _Tp __F1, __F2;
+
+          _Tp __d1, __d2;
+          if (__d >= _Tp(0))
+            {
+              __d1 = __d;
+              __d2 = _Tp(0);
+            }
+          else
+            {
+              __d1 = _Tp(0);
+              __d2 = __d;
+            }
+
+          const _Tp __lng_c = __log_gamma(__c);
+
+          //  Evaluate F1.
+          if (__ad < __eps)
+            {
+              //  d = c - a - b = 0.
+              __F1 = _Tp(0);
+            }
+          else
+            {
+
+              bool __ok_d1 = true;
+              _Tp __lng_ad, __lng_ad1, __lng_bd1;
+              __try
+                {
+                  __lng_ad = __log_gamma(__ad);
+                  __lng_ad1 = __log_gamma(__a + __d1);
+                  __lng_bd1 = __log_gamma(__b + __d1);
+                }
+              __catch(...)
+                {
+                  __ok_d1 = false;
+                }
+
+              if (__ok_d1)
+                {
+                  /* Gamma functions in the denominator are ok.
+                   * Proceed with evaluation.
+                   */
+                  _Tp __sum1 = _Tp(1);
+                  _Tp __term = _Tp(1);
+                  _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx
+                                - __lng_ad1 - __lng_bd1;
+
+                  /* Do F1 sum.
+                   */
+                  for (int __i = 1; __i < __ad; ++__i)
+                    {
+                      const int __j = __i - 1;
+                      __term *= (__a + __d2 + __j) * (__b + __d2 + __j)
+                              / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x);
+                      __sum1 += __term;
+                    }
+
+                  if (__ln_pre1 > __log_max)
+                    std::__throw_runtime_error(__N("Overflow of gamma functions"
+                                                   " in __hyperg_luke."));
+                  else
+                    __F1 = std::exp(__ln_pre1) * __sum1;
+                }
+              else
+                {
+                  //  Gamma functions in the denominator were not ok.
+                  //  So the F1 term is zero.
+                  __F1 = _Tp(0);
+                }
+            } // end F1 evaluation
+
+          // Evaluate F2.
+          bool __ok_d2 = true;
+          _Tp __lng_ad2, __lng_bd2;
+          __try
+            {
+              __lng_ad2 = __log_gamma(__a + __d2);
+              __lng_bd2 = __log_gamma(__b + __d2);
+            }
+          __catch(...)
+            {
+              __ok_d2 = false;
+            }
+
+          if (__ok_d2)
+            {
+              //  Gamma functions in the denominator are ok.
+              //  Proceed with evaluation.
+              const int __maxiter = 2000;
+              const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e();
+              const _Tp __psi_1pd = __psi(_Tp(1) + __ad);
+              const _Tp __psi_apd1 = __psi(__a + __d1);
+              const _Tp __psi_bpd1 = __psi(__b + __d1);
+
+              _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1
+                             - __psi_bpd1 - __ln_omx;
+              _Tp __fact = _Tp(1);
+              _Tp __sum2 = __psi_term;
+              _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx
+                            - __lng_ad2 - __lng_bd2;
+
+              // Do F2 sum.
+              int __j;
+              for (__j = 1; __j < __maxiter; ++__j)
+                {
+                  //  Values for psi functions use recurrence;
+                  //  Abramowitz & Stegun 6.3.5
+                  const _Tp __term1 = _Tp(1) / _Tp(__j)
+                                    + _Tp(1) / (__ad + __j);
+                  const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1))
+                                    + _Tp(1) / (__b + __d1 + _Tp(__j - 1));
+                  __psi_term += __term1 - __term2;
+                  __fact *= (__a + __d1 + _Tp(__j - 1))
+                          * (__b + __d1 + _Tp(__j - 1))
+                          / ((__ad + __j) * __j) * (_Tp(1) - __x);
+                  const _Tp __delta = __fact * __psi_term;
+                  __sum2 += __delta;
+                  if (std::abs(__delta) < __eps * std::abs(__sum2))
+                    break;
+                }
+              if (__j == __maxiter)
+                std::__throw_runtime_error(__N("Sum F2 failed to converge "
+                                               "in __hyperg_reflect"));
+
+              if (__sum2 == _Tp(0))
+                __F2 = _Tp(0);
+              else
+                __F2 = std::exp(__ln_pre2) * __sum2;
+            }
+          else
+            {
+              // Gamma functions in the denominator not ok.
+              // So the F2 term is zero.
+              __F2 = _Tp(0);
+            } // end F2 evaluation
+
+          const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1));
+          const _Tp __F = __F1 + __sgn_2 * __F2;
+
+          return __F;
+        }
+      else
+        {
+          //  d = c - a - b not an integer.
+
+          //  These gamma functions appear in the denominator, so we
+          //  catch their harmless domain errors and set the terms to zero.
+          bool __ok1 = true;
+          _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0);
+          _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0);
+          __try
+            {
+              __sgn_g1ca = __log_gamma_sign(__c - __a);
+              __ln_g1ca = __log_gamma(__c - __a);
+              __sgn_g1cb = __log_gamma_sign(__c - __b);
+              __ln_g1cb = __log_gamma(__c - __b);
+            }
+          __catch(...)
+            {
+              __ok1 = false;
+            }
+
+          bool __ok2 = true;
+          _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0);
+          _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0);
+          __try
+            {
+              __sgn_g2a = __log_gamma_sign(__a);
+              __ln_g2a = __log_gamma(__a);
+              __sgn_g2b = __log_gamma_sign(__b);
+              __ln_g2b = __log_gamma(__b);
+            }
+          __catch(...)
+            {
+              __ok2 = false;
+            }
+
+          const _Tp __sgn_gc = __log_gamma_sign(__c);
+          const _Tp __ln_gc = __log_gamma(__c);
+          const _Tp __sgn_gd = __log_gamma_sign(__d);
+          const _Tp __ln_gd = __log_gamma(__d);
+          const _Tp __sgn_gmd = __log_gamma_sign(-__d);
+          const _Tp __ln_gmd = __log_gamma(-__d);
+
+          const _Tp __sgn1 = __sgn_gc * __sgn_gd  * __sgn_g1ca * __sgn_g1cb;
+          const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a  * __sgn_g2b;
+
+          _Tp __pre1, __pre2;
+          if (__ok1 && __ok2)
+            {
+              _Tp __ln_pre1 = __ln_gc + __ln_gd  - __ln_g1ca - __ln_g1cb;
+              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a  - __ln_g2b
+                            + __d * std::log(_Tp(1) - __x);
+              if (__ln_pre1 < __log_max && __ln_pre2 < __log_max)
+                {
+                  __pre1 = std::exp(__ln_pre1);
+                  __pre2 = std::exp(__ln_pre2);
+                  __pre1 *= __sgn1;
+                  __pre2 *= __sgn2;
+                }
+              else
+                {
+                  std::__throw_runtime_error(__N("Overflow of gamma functions "
+                                                 "in __hyperg_reflect"));
+                }
+            }
+          else if (__ok1 && !__ok2)
+            {
+              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
+              if (__ln_pre1 < __log_max)
+                {
+                  __pre1 = std::exp(__ln_pre1);
+                  __pre1 *= __sgn1;
+                  __pre2 = _Tp(0);
+                }
+              else
+                {
+                  std::__throw_runtime_error(__N("Overflow of gamma functions "
+                                                 "in __hyperg_reflect"));
+                }
+            }
+          else if (!__ok1 && __ok2)
+            {
+              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
+                            + __d * std::log(_Tp(1) - __x);
+              if (__ln_pre2 < __log_max)
+                {
+                  __pre1 = _Tp(0);
+                  __pre2 = std::exp(__ln_pre2);
+                  __pre2 *= __sgn2;
+                }
+              else
+                {
+                  std::__throw_runtime_error(__N("Overflow of gamma functions "
+                                                 "in __hyperg_reflect"));
+                }
+            }
+          else
+            {
+              __pre1 = _Tp(0);
+              __pre2 = _Tp(0);
+              std::__throw_runtime_error(__N("Underflow of gamma functions "
+                                             "in __hyperg_reflect"));
+            }
+
+          const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d,
+                                           _Tp(1) - __x);
+          const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d,
+                                           _Tp(1) - __x);
+
+          const _Tp __F = __pre1 * __F1 + __pre2 * __F2;
+
+          return __F;
+        }
+    }
+
+
+    /**
+     *   @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$.
+     *
+     *   The hypogeometric function is defined by
+     *   @f[
+     *     _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)}
+     *                      \sum_{n=0}^{\infty}
+     *                      \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)}
+     *                      \frac{x^n}{n!}
+     *   @f]
+     *
+     *   @param  __a  The first @a numerator parameter.
+     *   @param  __a  The second @a numerator parameter.
+     *   @param  __c  The @a denominator parameter.
+     *   @param  __x  The argument of the confluent hypergeometric function.
+     *   @return  The confluent hypergeometric function.
+     */
+    template<typename _Tp>
+    _Tp
+    __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+#if _GLIBCXX_USE_C99_MATH_TR1
+      const _Tp __a_nint = std::tr1::nearbyint(__a);
+      const _Tp __b_nint = std::tr1::nearbyint(__b);
+      const _Tp __c_nint = std::tr1::nearbyint(__c);
+#else
+      const _Tp __a_nint = static_cast<int>(__a + _Tp(0.5L));
+      const _Tp __b_nint = static_cast<int>(__b + _Tp(0.5L));
+      const _Tp __c_nint = static_cast<int>(__c + _Tp(0.5L));
+#endif
+      const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon();
+      if (std::abs(__x) >= _Tp(1))
+        std::__throw_domain_error(__N("Argument outside unit circle "
+                                      "in __hyperg."));
+      else if (__isnan(__a) || __isnan(__b)
+            || __isnan(__c) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__c_nint == __c && __c_nint <= _Tp(0))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler)
+        return std::pow(_Tp(1) - __x, __c - __a - __b);
+      else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0)
+            && __x >= _Tp(0) && __x < _Tp(0.995L))
+        return __hyperg_series(__a, __b, __c, __x);
+      else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10))
+        {
+          //  For integer a and b the hypergeometric function is a
+          //  finite polynomial.
+          if (__a < _Tp(0)  &&  std::abs(__a - __a_nint) < __toler)
+            return __hyperg_series(__a_nint, __b, __c, __x);
+          else if (__b < _Tp(0)  &&  std::abs(__b - __b_nint) < __toler)
+            return __hyperg_series(__a, __b_nint, __c, __x);
+          else if (__x < -_Tp(0.25L))
+            return __hyperg_luke(__a, __b, __c, __x);
+          else if (__x < _Tp(0.5L))
+            return __hyperg_series(__a, __b, __c, __x);
+          else
+            if (std::abs(__c) > _Tp(10))
+              return __hyperg_series(__a, __b, __c, __x);
+            else
+              return __hyperg_reflect(__a, __b, __c, __x);
+        }
+      else
+        return __hyperg_luke(__a, __b, __c, __x);
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/inttypes.h b/gcc-4.9/libstdc++-v3/include/tr1/inttypes.h
new file mode 100644
index 0000000..480c992
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/inttypes.h
@@ -0,0 +1,34 @@
+// TR1 inttypes.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/inttypes.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_INTTYPES_H
+#define _GLIBCXX_TR1_INTTYPES_H 1
+
+#include <tr1/cinttypes>
+
+#endif // _GLIBCXX_TR1_INTTYPES_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/legendre_function.tcc b/gcc-4.9/libstdc++-v3/include/tr1/legendre_function.tcc
new file mode 100644
index 0000000..ba53fbc
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/legendre_function.tcc
@@ -0,0 +1,303 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/legendre_function.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 8, pp. 331-341
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 252-254
+
+#ifndef _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
+#define _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC 1
+
+#include "special_function_util.h"
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief  Return the Legendre polynomial by recursion on order
+     *           @f$ l @f$.
+     * 
+     *   The Legendre function of @f$ l @f$ and @f$ x @f$,
+     *   @f$ P_l(x) @f$, is defined by:
+     *   @f[
+     *     P_l(x) = \frac{1}{2^l l!}\frac{d^l}{dx^l}(x^2 - 1)^{l}
+     *   @f]
+     * 
+     *   @param  l  The order of the Legendre polynomial.  @f$l >= 0@f$.
+     *   @param  x  The argument of the Legendre polynomial.  @f$|x| <= 1@f$.
+     */
+    template<typename _Tp>
+    _Tp
+    __poly_legendre_p(unsigned int __l, _Tp __x)
+    {
+
+      if ((__x < _Tp(-1)) || (__x > _Tp(+1)))
+        std::__throw_domain_error(__N("Argument out of range"
+                                      " in __poly_legendre_p."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == +_Tp(1))
+        return +_Tp(1);
+      else if (__x == -_Tp(1))
+        return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1));
+      else
+        {
+          _Tp __p_lm2 = _Tp(1);
+          if (__l == 0)
+            return __p_lm2;
+
+          _Tp __p_lm1 = __x;
+          if (__l == 1)
+            return __p_lm1;
+
+          _Tp __p_l = 0;
+          for (unsigned int __ll = 2; __ll <= __l; ++__ll)
+            {
+              //  This arrangement is supposed to be better for roundoff
+              //  protection, Arfken, 2nd Ed, Eq 12.17a.
+              __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2
+                    - (__x * __p_lm1 - __p_lm2) / _Tp(__ll);
+              __p_lm2 = __p_lm1;
+              __p_lm1 = __p_l;
+            }
+
+          return __p_l;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the associated Legendre function by recursion
+     *           on @f$ l @f$.
+     * 
+     *   The associated Legendre function is derived from the Legendre function
+     *   @f$ P_l(x) @f$ by the Rodrigues formula:
+     *   @f[
+     *     P_l^m(x) = (1 - x^2)^{m/2}\frac{d^m}{dx^m}P_l(x)
+     *   @f]
+     * 
+     *   @param  l  The order of the associated Legendre function.
+     *              @f$ l >= 0 @f$.
+     *   @param  m  The order of the associated Legendre function.
+     *              @f$ m <= l @f$.
+     *   @param  x  The argument of the associated Legendre function.
+     *              @f$ |x| <= 1 @f$.
+     */
+    template<typename _Tp>
+    _Tp
+    __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x)
+    {
+
+      if (__x < _Tp(-1) || __x > _Tp(+1))
+        std::__throw_domain_error(__N("Argument out of range"
+                                      " in __assoc_legendre_p."));
+      else if (__m > __l)
+        std::__throw_domain_error(__N("Degree out of range"
+                                      " in __assoc_legendre_p."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__m == 0)
+        return __poly_legendre_p(__l, __x);
+      else
+        {
+          _Tp __p_mm = _Tp(1);
+          if (__m > 0)
+            {
+              //  Two square roots seem more accurate more of the time
+              //  than just one.
+              _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x);
+              _Tp __fact = _Tp(1);
+              for (unsigned int __i = 1; __i <= __m; ++__i)
+                {
+                  __p_mm *= -__fact * __root;
+                  __fact += _Tp(2);
+                }
+            }
+          if (__l == __m)
+            return __p_mm;
+
+          _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm;
+          if (__l == __m + 1)
+            return __p_mp1m;
+
+          _Tp __p_lm2m = __p_mm;
+          _Tp __P_lm1m = __p_mp1m;
+          _Tp __p_lm = _Tp(0);
+          for (unsigned int __j = __m + 2; __j <= __l; ++__j)
+            {
+              __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m
+                      - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m);
+              __p_lm2m = __P_lm1m;
+              __P_lm1m = __p_lm;
+            }
+
+          return __p_lm;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the spherical associated Legendre function.
+     * 
+     *   The spherical associated Legendre function of @f$ l @f$, @f$ m @f$,
+     *   and @f$ \theta @f$ is defined as @f$ Y_l^m(\theta,0) @f$ where
+     *   @f[
+     *      Y_l^m(\theta,\phi) = (-1)^m[\frac{(2l+1)}{4\pi}
+     *                                  \frac{(l-m)!}{(l+m)!}]
+     *                     P_l^m(\cos\theta) \exp^{im\phi}
+     *   @f]
+     *   is the spherical harmonic function and @f$ P_l^m(x) @f$ is the
+     *   associated Legendre function.
+     * 
+     *   This function differs from the associated Legendre function by
+     *   argument (@f$x = \cos(\theta)@f$) and by a normalization factor
+     *   but this factor is rather large for large @f$ l @f$ and @f$ m @f$
+     *   and so this function is stable for larger differences of @f$ l @f$
+     *   and @f$ m @f$.
+     * 
+     *   @param  l  The order of the spherical associated Legendre function.
+     *              @f$ l >= 0 @f$.
+     *   @param  m  The order of the spherical associated Legendre function.
+     *              @f$ m <= l @f$.
+     *   @param  theta  The radian angle argument of the spherical associated
+     *                  Legendre function.
+     */
+    template <typename _Tp>
+    _Tp
+    __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
+    {
+      if (__isnan(__theta))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+
+      const _Tp __x = std::cos(__theta);
+
+      if (__l < __m)
+        {
+          std::__throw_domain_error(__N("Bad argument "
+                                        "in __sph_legendre."));
+        }
+      else if (__m == 0)
+        {
+          _Tp __P = __poly_legendre_p(__l, __x);
+          _Tp __fact = std::sqrt(_Tp(2 * __l + 1)
+                     / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          __P *= __fact;
+          return __P;
+        }
+      else if (__x == _Tp(1) || __x == -_Tp(1))
+        {
+          //  m > 0 here
+          return _Tp(0);
+        }
+      else
+        {
+          // m > 0 and |x| < 1 here
+
+          // Starting value for recursion.
+          // Y_m^m(x) = sqrt( (2m+1)/(4pi m) gamma(m+1/2)/gamma(m) )
+          //             (-1)^m (1-x^2)^(m/2) / pi^(1/4)
+          const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
+          const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));
+#if _GLIBCXX_USE_C99_MATH_TR1
+          const _Tp __lncirc = std::tr1::log1p(-__x * __x);
+#else
+          const _Tp __lncirc = std::log(_Tp(1) - __x * __x);
+#endif
+          //  Gamma(m+1/2) / Gamma(m)
+#if _GLIBCXX_USE_C99_MATH_TR1
+          const _Tp __lnpoch = std::tr1::lgamma(_Tp(__m + _Tp(0.5L)))
+                             - std::tr1::lgamma(_Tp(__m));
+#else
+          const _Tp __lnpoch = __log_gamma(_Tp(__m + _Tp(0.5L)))
+                             - __log_gamma(_Tp(__m));
+#endif
+          const _Tp __lnpre_val =
+                    -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
+                    + _Tp(0.5L) * (__lnpoch + __m * __lncirc);
+          _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
+                   / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
+          _Tp __y_mp1m = __y_mp1m_factor * __y_mm;
+
+          if (__l == __m)
+            {
+              return __y_mm;
+            }
+          else if (__l == __m + 1)
+            {
+              return __y_mp1m;
+            }
+          else
+            {
+              _Tp __y_lm = _Tp(0);
+
+              // Compute Y_l^m, l > m+1, upward recursion on l.
+              for ( int __ll = __m + 2; __ll <= __l; ++__ll)
+                {
+                  const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
+                  const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
+                  const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
+                                                       * _Tp(2 * __ll - 1));
+                  const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
+                                                                / _Tp(2 * __ll - 3));
+                  __y_lm = (__x * __y_mp1m * __fact1
+                         - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
+                  __y_mm = __y_mp1m;
+                  __y_mp1m = __y_lm;
+                }
+
+              return __y_lm;
+            }
+        }
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/limits.h b/gcc-4.9/libstdc++-v3/include/tr1/limits.h
new file mode 100644
index 0000000..0c5a74d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/limits.h
@@ -0,0 +1,34 @@
+// TR1 limits.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/limits.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_LIMITS_H
+#define _TR1_LIMITS_H 1
+
+#include <tr1/climits>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/math.h b/gcc-4.9/libstdc++-v3/include/tr1/math.h
new file mode 100644
index 0000000..3f2a67c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/math.h
@@ -0,0 +1,186 @@
+// TR1 math.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/math.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_MATH_H
+#define _GLIBCXX_TR1_MATH_H 1
+
+#include <tr1/cmath>
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+using std::tr1::acos;
+using std::tr1::acosh;
+using std::tr1::asin;
+using std::tr1::asinh;
+using std::tr1::atan;
+using std::tr1::atan2;
+using std::tr1::atanh;
+using std::tr1::cbrt;
+using std::tr1::ceil;
+using std::tr1::copysign;
+using std::tr1::cos;
+using std::tr1::cosh;
+using std::tr1::erf;
+using std::tr1::erfc;
+using std::tr1::exp;
+using std::tr1::exp2;
+using std::tr1::expm1;
+using std::tr1::fabs;
+using std::tr1::fdim;
+using std::tr1::floor;
+using std::tr1::fma;
+using std::tr1::fmax;
+using std::tr1::fmin;
+using std::tr1::fmod;
+using std::tr1::frexp;
+using std::tr1::hypot;
+using std::tr1::ilogb;
+using std::tr1::ldexp;
+using std::tr1::lgamma;
+using std::tr1::llrint;
+using std::tr1::llround;
+using std::tr1::log;
+using std::tr1::log10;
+using std::tr1::log1p;
+using std::tr1::log2;
+using std::tr1::logb;
+using std::tr1::lrint;
+using std::tr1::lround;
+using std::tr1::nearbyint;
+using std::tr1::nextafter;
+using std::tr1::nexttoward;
+using std::tr1::pow;
+using std::tr1::remainder;
+using std::tr1::remquo;
+using std::tr1::rint;
+using std::tr1::round;
+using std::tr1::scalbln;
+using std::tr1::scalbn;
+using std::tr1::sin;
+using std::tr1::sinh;
+using std::tr1::sqrt;
+using std::tr1::tan;
+using std::tr1::tanh;
+using std::tr1::tgamma;
+using std::tr1::trunc;
+
+#endif
+
+using std::tr1::assoc_laguerref;
+using std::tr1::assoc_laguerre;
+using std::tr1::assoc_laguerrel;
+
+using std::tr1::assoc_legendref;
+using std::tr1::assoc_legendre;
+using std::tr1::assoc_legendrel;
+
+using std::tr1::betaf;
+using std::tr1::beta;
+using std::tr1::betal;
+
+using std::tr1::comp_ellint_1f;
+using std::tr1::comp_ellint_1;
+using std::tr1::comp_ellint_1l;
+
+using std::tr1::comp_ellint_2f;
+using std::tr1::comp_ellint_2;
+using std::tr1::comp_ellint_2l;
+
+using std::tr1::comp_ellint_3f;
+using std::tr1::comp_ellint_3;
+using std::tr1::comp_ellint_3l;
+
+using std::tr1::conf_hypergf;
+using std::tr1::conf_hyperg;
+using std::tr1::conf_hypergl;
+
+using std::tr1::cyl_bessel_if;
+using std::tr1::cyl_bessel_i;
+using std::tr1::cyl_bessel_il;
+
+using std::tr1::cyl_bessel_jf;
+using std::tr1::cyl_bessel_j;
+using std::tr1::cyl_bessel_jl;
+
+using std::tr1::cyl_bessel_kf;
+using std::tr1::cyl_bessel_k;
+using std::tr1::cyl_bessel_kl;
+
+using std::tr1::cyl_neumannf;
+using std::tr1::cyl_neumann;
+using std::tr1::cyl_neumannl;
+
+using std::tr1::ellint_1f;
+using std::tr1::ellint_1;
+using std::tr1::ellint_1l;
+
+using std::tr1::ellint_2f;
+using std::tr1::ellint_2;
+using std::tr1::ellint_2l;
+
+using std::tr1::ellint_3f;
+using std::tr1::ellint_3;
+using std::tr1::ellint_3l;
+
+using std::tr1::expintf;
+using std::tr1::expint;
+using std::tr1::expintl;
+
+using std::tr1::hermitef;
+using std::tr1::hermite;
+using std::tr1::hermitel;
+
+using std::tr1::hypergf;
+using std::tr1::hyperg;
+using std::tr1::hypergl;
+
+using std::tr1::laguerref;
+using std::tr1::laguerre;
+using std::tr1::laguerrel;
+
+using std::tr1::legendref;
+using std::tr1::legendre;
+using std::tr1::legendrel;
+
+using std::tr1::riemann_zetaf;
+using std::tr1::riemann_zeta;
+using std::tr1::riemann_zetal;
+
+using std::tr1::sph_besself;
+using std::tr1::sph_bessel;
+using std::tr1::sph_bessell;
+
+using std::tr1::sph_legendref;
+using std::tr1::sph_legendre;
+using std::tr1::sph_legendrel;
+
+using std::tr1::sph_neumannf;
+using std::tr1::sph_neumann;
+using std::tr1::sph_neumannl;
+
+#endif // _GLIBCXX_TR1_MATH_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/memory b/gcc-4.9/libstdc++-v3/include/tr1/memory
new file mode 100644
index 0000000..d356d98
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/memory
@@ -0,0 +1,52 @@
+// <tr1/memory> -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file tr1/memory
+ * This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_MEMORY
+#define _GLIBCXX_TR1_MEMORY 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX11)
+#  error TR1 header cannot be included from C++11 header
+#endif
+
+#include <memory>
+#include <exception>        	// std::exception
+#include <typeinfo>         	// std::type_info in get_deleter
+#include <bits/stl_algobase.h>  // std::swap
+#include <iosfwd>           	// std::basic_ostream
+#include <ext/atomicity.h>
+#include <ext/concurrence.h>
+#include <bits/functexcept.h>
+#include <bits/stl_function.h> 	// std::less
+#include <debug/debug.h>
+#include <tr1/type_traits>
+#include <tr1/shared_ptr.h>
+
+#endif // _GLIBCXX_TR1_MEMORY
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/modified_bessel_func.tcc b/gcc-4.9/libstdc++-v3/include/tr1/modified_bessel_func.tcc
new file mode 100644
index 0000000..74ece8e
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/modified_bessel_func.tcc
@@ -0,0 +1,434 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/modified_bessel_func.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland.
+//
+// References:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 9, pp. 355-434, Section 10 pp. 435-478
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 246-249.
+
+#ifndef _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
+#define _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC 1
+
+#include "special_function_util.h"
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief  Compute the modified Bessel functions @f$ I_\nu(x) @f$ and
+     *           @f$ K_\nu(x) @f$ and their first derivatives
+     *           @f$ I'_\nu(x) @f$ and @f$ K'_\nu(x) @f$ respectively.
+     *           These four functions are computed together for numerical
+     *           stability.
+     *
+     *   @param  __nu  The order of the Bessel functions.
+     *   @param  __x   The argument of the Bessel functions.
+     *   @param  __Inu  The output regular modified Bessel function.
+     *   @param  __Knu  The output irregular modified Bessel function.
+     *   @param  __Ipnu  The output derivative of the regular
+     *                   modified Bessel function.
+     *   @param  __Kpnu  The output derivative of the irregular
+     *                   modified Bessel function.
+     */
+    template <typename _Tp>
+    void
+    __bessel_ik(_Tp __nu, _Tp __x,
+                _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
+    {
+      if (__x == _Tp(0))
+        {
+          if (__nu == _Tp(0))
+            {
+              __Inu = _Tp(1);
+              __Ipnu = _Tp(0);
+            }
+          else if (__nu == _Tp(1))
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0.5L);
+            }
+          else
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0);
+            }
+          __Knu = std::numeric_limits<_Tp>::infinity();
+          __Kpnu = -std::numeric_limits<_Tp>::infinity();
+          return;
+        }
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
+      const int __max_iter = 15000;
+      const _Tp __x_min = _Tp(2);
+
+      const int __nl = static_cast<int>(__nu + _Tp(0.5L));
+
+      const _Tp __mu = __nu - __nl;
+      const _Tp __mu2 = __mu * __mu;
+      const _Tp __xi = _Tp(1) / __x;
+      const _Tp __xi2 = _Tp(2) * __xi;
+      _Tp __h = __nu * __xi;
+      if ( __h < __fp_min )
+        __h = __fp_min;
+      _Tp __b = __xi2 * __nu;
+      _Tp __d = _Tp(0);
+      _Tp __c = __h;
+      int __i;
+      for ( __i = 1; __i <= __max_iter; ++__i )
+        {
+          __b += __xi2;
+          __d = _Tp(1) / (__b + __d);
+          __c = __b + _Tp(1) / __c;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            break;
+        }
+      if (__i > __max_iter)
+        std::__throw_runtime_error(__N("Argument x too large "
+                                       "in __bessel_ik; "
+                                       "try asymptotic expansion."));
+      _Tp __Inul = __fp_min;
+      _Tp __Ipnul = __h * __Inul;
+      _Tp __Inul1 = __Inul;
+      _Tp __Ipnu1 = __Ipnul;
+      _Tp __fact = __nu * __xi;
+      for (int __l = __nl; __l >= 1; --__l)
+        {
+          const _Tp __Inutemp = __fact * __Inul + __Ipnul;
+          __fact -= __xi;
+          __Ipnul = __fact * __Inutemp + __Inul;
+          __Inul = __Inutemp;
+        }
+      _Tp __f = __Ipnul / __Inul;
+      _Tp __Kmu, __Knu1;
+      if (__x < __x_min)
+        {
+          const _Tp __x2 = __x / _Tp(2);
+          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
+          const _Tp __fact = (std::abs(__pimu) < __eps
+                            ? _Tp(1) : __pimu / std::sin(__pimu));
+          _Tp __d = -std::log(__x2);
+          _Tp __e = __mu * __d;
+          const _Tp __fact2 = (std::abs(__e) < __eps
+                            ? _Tp(1) : std::sinh(__e) / __e);
+          _Tp __gam1, __gam2, __gampl, __gammi;
+          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
+          _Tp __ff = __fact
+                   * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
+          _Tp __sum = __ff;
+          __e = std::exp(__e);
+          _Tp __p = __e / (_Tp(2) * __gampl);
+          _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
+          _Tp __c = _Tp(1);
+          __d = __x2 * __x2;
+          _Tp __sum1 = __p;
+          int __i;
+          for (__i = 1; __i <= __max_iter; ++__i)
+            {
+              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
+              __c *= __d / __i;
+              __p /= __i - __mu;
+              __q /= __i + __mu;
+              const _Tp __del = __c * __ff;
+              __sum += __del; 
+              const _Tp __del1 = __c * (__p - __i * __ff);
+              __sum1 += __del1;
+              if (std::abs(__del) < __eps * std::abs(__sum))
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(__N("Bessel k series failed to converge "
+                                           "in __bessel_ik."));
+          __Kmu = __sum;
+          __Knu1 = __sum1 * __xi2;
+        }
+      else
+        {
+          _Tp __b = _Tp(2) * (_Tp(1) + __x);
+          _Tp __d = _Tp(1) / __b;
+          _Tp __delh = __d;
+          _Tp __h = __delh;
+          _Tp __q1 = _Tp(0);
+          _Tp __q2 = _Tp(1);
+          _Tp __a1 = _Tp(0.25L) - __mu2;
+          _Tp __q = __c = __a1;
+          _Tp __a = -__a1;
+          _Tp __s = _Tp(1) + __q * __delh;
+          int __i;
+          for (__i = 2; __i <= __max_iter; ++__i)
+            {
+              __a -= 2 * (__i - 1);
+              __c = -__a * __c / __i;
+              const _Tp __qnew = (__q1 - __b * __q2) / __a;
+              __q1 = __q2;
+              __q2 = __qnew;
+              __q += __c * __qnew;
+              __b += _Tp(2);
+              __d = _Tp(1) / (__b + __a * __d);
+              __delh = (__b * __d - _Tp(1)) * __delh;
+              __h += __delh;
+              const _Tp __dels = __q * __delh;
+              __s += __dels;
+              if ( std::abs(__dels / __s) < __eps )
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(__N("Steed's method failed "
+                                           "in __bessel_ik."));
+          __h = __a1 * __h;
+          __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
+                * std::exp(-__x) / __s;
+          __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
+        }
+
+      _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
+      _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
+      __Inu = __Inumu * __Inul1 / __Inul;
+      __Ipnu = __Inumu * __Ipnu1 / __Inul;
+      for ( __i = 1; __i <= __nl; ++__i )
+        {
+          const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
+          __Kmu = __Knu1;
+          __Knu1 = __Knutemp;
+        }
+      __Knu = __Kmu;
+      __Kpnu = __nu * __xi * __Kmu - __Knu1;
+  
+      return;
+    }
+
+
+    /**
+     *   @brief  Return the regular modified Bessel function of order
+     *           \f$ \nu \f$: \f$ I_{\nu}(x) \f$.
+     *
+     *   The regular modified cylindrical Bessel function is:
+     *   @f[
+     *    I_{\nu}(x) = \sum_{k=0}^{\infty}
+     *              \frac{(x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
+     *   @f]
+     *
+     *   @param  __nu  The order of the regular modified Bessel function.
+     *   @param  __x   The argument of the regular modified Bessel function.
+     *   @return  The output regular modified Bessel function.
+     */
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_i(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __cyl_bessel_i."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
+        return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __I_nu;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the irregular modified Bessel function
+     *           \f$ K_{\nu}(x) \f$ of order \f$ \nu \f$.
+     *
+     *   The irregular modified Bessel function is defined by:
+     *   @f[
+     *      K_{\nu}(x) = \frac{\pi}{2}
+     *                   \frac{I_{-\nu}(x) - I_{\nu}(x)}{\sin \nu\pi}
+     *   @f]
+     *   where for integral \f$ \nu = n \f$ a limit is taken:
+     *   \f$ lim_{\nu \to n} \f$.
+     *
+     *   @param  __nu  The order of the irregular modified Bessel function.
+     *   @param  __x   The argument of the irregular modified Bessel function.
+     *   @return  The output irregular modified Bessel function.
+     */
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_k(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __cyl_bessel_k."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __K_nu;
+        }
+    }
+
+
+    /**
+     *   @brief  Compute the spherical modified Bessel functions
+     *           @f$ i_n(x) @f$ and @f$ k_n(x) @f$ and their first
+     *           derivatives @f$ i'_n(x) @f$ and @f$ k'_n(x) @f$
+     *           respectively.
+     *
+     *   @param  __n  The order of the modified spherical Bessel function.
+     *   @param  __x  The argument of the modified spherical Bessel function.
+     *   @param  __i_n  The output regular modified spherical Bessel function.
+     *   @param  __k_n  The output irregular modified spherical
+     *                  Bessel function.
+     *   @param  __ip_n  The output derivative of the regular modified
+     *                   spherical Bessel function.
+     *   @param  __kp_n  The output derivative of the irregular modified
+     *                   spherical Bessel function.
+     */
+    template <typename _Tp>
+    void
+    __sph_bessel_ik(unsigned int __n, _Tp __x,
+                    _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
+    {
+      const _Tp __nu = _Tp(__n) + _Tp(0.5L);
+
+      _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+      __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+
+      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
+                         / std::sqrt(__x);
+
+      __i_n = __factor * __I_nu;
+      __k_n = __factor * __K_nu;
+      __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
+      __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);
+
+      return;
+    }
+
+
+    /**
+     *   @brief  Compute the Airy functions
+     *           @f$ Ai(x) @f$ and @f$ Bi(x) @f$ and their first
+     *           derivatives @f$ Ai'(x) @f$ and @f$ Bi(x) @f$
+     *           respectively.
+     *
+     *   @param  __x  The argument of the Airy functions.
+     *   @param  __Ai  The output Airy function of the first kind.
+     *   @param  __Bi  The output Airy function of the second kind.
+     *   @param  __Aip  The output derivative of the Airy function
+     *                  of the first kind.
+     *   @param  __Bip  The output derivative of the Airy function
+     *                  of the second kind.
+     */
+    template <typename _Tp>
+    void
+    __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
+    {
+      const _Tp __absx = std::abs(__x);
+      const _Tp __rootx = std::sqrt(__absx);
+      const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
+
+      if (__x > _Tp(0))
+        {
+          _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+
+          __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Ai = __rootx * __K_nu
+               / (__numeric_constants<_Tp>::__sqrt3()
+                * __numeric_constants<_Tp>::__pi());
+          __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
+                 + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());
+
+          __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Aip = -__x * __K_nu
+                / (__numeric_constants<_Tp>::__sqrt3()
+                 * __numeric_constants<_Tp>::__pi());
+          __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
+                      + _Tp(2) * __I_nu
+                      / __numeric_constants<_Tp>::__sqrt3());
+        }
+      else if (__x < _Tp(0))
+        {
+          _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;
+
+          __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Ai = __rootx * (__J_nu
+                    - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+          __Bi = -__rootx * (__N_nu
+                    + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+
+          __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
+                          + __J_nu) / _Tp(2);
+          __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
+                          - __N_nu) / _Tp(2);
+        }
+      else
+        {
+          //  Reference:
+          //    Abramowitz & Stegun, page 446 section 10.4.4 on Airy functions.
+          //  The number is Ai(0) = 3^{-2/3}/\Gamma(2/3).
+          __Ai = _Tp(0.35502805388781723926L);
+          __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();
+
+          //  Reference:
+          //    Abramowitz & Stegun, page 446 section 10.4.5 on Airy functions.
+          //  The number is Ai'(0) = -3^{-1/3}/\Gamma(1/3).
+          __Aip = -_Tp(0.25881940379280679840L);
+          __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
+        }
+
+      return;
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/poly_hermite.tcc b/gcc-4.9/libstdc++-v3/include/tr1/poly_hermite.tcc
new file mode 100644
index 0000000..e8626a7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/poly_hermite.tcc
@@ -0,0 +1,124 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/poly_hermite.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications, Section 22 pp. 773-802
+
+#ifndef _GLIBCXX_TR1_POLY_HERMITE_TCC
+#define _GLIBCXX_TR1_POLY_HERMITE_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief This routine returns the Hermite polynomial
+     *          of order n: \f$ H_n(x) \f$ by recursion on n.
+     * 
+     *   The Hermite polynomial is defined by:
+     *   @f[
+     *     H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2}
+     *   @f]
+     *
+     *   @param __n The order of the Hermite polynomial.
+     *   @param __x The argument of the Hermite polynomial.
+     *   @return The value of the Hermite polynomial of order n
+     *           and argument x.
+     */
+    template<typename _Tp>
+    _Tp
+    __poly_hermite_recursion(unsigned int __n, _Tp __x)
+    {
+      //  Compute H_0.
+      _Tp __H_0 = 1;
+      if (__n == 0)
+        return __H_0;
+
+      //  Compute H_1.
+      _Tp __H_1 = 2 * __x;
+      if (__n == 1)
+        return __H_1;
+
+      //  Compute H_n.
+      _Tp __H_n, __H_nm1, __H_nm2;
+      unsigned int __i;
+      for  (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
+        {
+          __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2);
+          __H_nm2 = __H_nm1;
+          __H_nm1 = __H_n;
+        }
+
+      return __H_n;
+    }
+
+
+    /**
+     *   @brief This routine returns the Hermite polynomial
+     *          of order n: \f$ H_n(x) \f$.
+     * 
+     *   The Hermite polynomial is defined by:
+     *   @f[
+     *     H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2}
+     *   @f]
+     *
+     *   @param __n The order of the Hermite polynomial.
+     *   @param __x The argument of the Hermite polynomial.
+     *   @return The value of the Hermite polynomial of order n
+     *           and argument x.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __poly_hermite(unsigned int __n, _Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __poly_hermite_recursion(__n, __x);
+    }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_POLY_HERMITE_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/poly_laguerre.tcc b/gcc-4.9/libstdc++-v3/include/tr1/poly_laguerre.tcc
new file mode 100644
index 0000000..f04fa68
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/poly_laguerre.tcc
@@ -0,0 +1,319 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/poly_laguerre.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 13, pp. 509-510, Section 22 pp. 773-802
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+
+#ifndef _GLIBCXX_TR1_POLY_LAGUERRE_TCC
+#define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial 
+     *          of order @f$ n @f$, degree @f$ \alpha @f$ for large n.
+     *   Abramowitz & Stegun, 13.5.21
+     *
+     *   @param __n The order of the Laguerre function.
+     *   @param __alpha The degree of the Laguerre function.
+     *   @param __x The argument of the Laguerre function.
+     *   @return The value of the Laguerre function of order n,
+     *           degree @f$ \alpha @f$, and argument x.
+     *
+     *  This is from the GNU Scientific Library.
+     */
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x)
+    {
+      const _Tp __a = -_Tp(__n);
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
+      const _Tp __cos2th = __x / __eta;
+      const _Tp __sin2th = _Tp(1) - __cos2th;
+      const _Tp __th = std::acos(std::sqrt(__cos2th));
+      const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
+                        * __numeric_constants<_Tp>::__pi_2()
+                        * __eta * __eta * __cos2th * __sin2th;
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+      const _Tp __lg_b = std::tr1::lgamma(_Tp(__n) + __b);
+      const _Tp __lnfact = std::tr1::lgamma(_Tp(__n + 1));
+#else
+      const _Tp __lg_b = __log_gamma(_Tp(__n) + __b);
+      const _Tp __lnfact = __log_gamma(_Tp(__n + 1));
+#endif
+
+      _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
+                      * std::log(_Tp(0.25L) * __x * __eta);
+      _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
+      _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
+                      + __pre_term1 - __pre_term2;
+      _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
+      _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
+                              * (_Tp(2) * __th
+                               - std::sin(_Tp(2) * __th))
+                               + __numeric_constants<_Tp>::__pi_4());
+      _Tp __ser = __ser_term1 + __ser_term2;
+
+      return std::exp(__lnpre) * __ser;
+    }
+
+
+    /**
+     *  @brief  Evaluate the polynomial based on the confluent hypergeometric
+     *          function in a safe way, with no restriction on the arguments.
+     *
+     *   The associated Laguerre function is defined by
+     *   @f[
+     *       L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
+     *                       _1F_1(-n; \alpha + 1; x)
+     *   @f]
+     *   where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
+     *   @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
+     *
+     *  This function assumes x != 0.
+     *
+     *  This is from the GNU Scientific Library.
+     */
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __mx = -__x;
+      const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
+                         : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));
+      //  Get |x|^n/n!
+      _Tp __tc = _Tp(1);
+      const _Tp __ax = std::abs(__x);
+      for (unsigned int __k = 1; __k <= __n; ++__k)
+        __tc *= (__ax / __k);
+
+      _Tp __term = __tc * __tc_sgn;
+      _Tp __sum = __term;
+      for (int __k = int(__n) - 1; __k >= 0; --__k)
+        {
+          __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
+                  * _Tp(__k + 1) / __mx;
+          __sum += __term;
+        }
+
+      return __sum;
+    }
+
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial 
+     *          of order @f$ n @f$, degree @f$ \alpha @f$: @f$ L_n^\alpha(x) @f$
+     *          by recursion.
+     *
+     *   The associated Laguerre function is defined by
+     *   @f[
+     *       L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
+     *                       _1F_1(-n; \alpha + 1; x)
+     *   @f]
+     *   where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
+     *   @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
+     *
+     *   The associated Laguerre polynomial is defined for integral
+     *   @f$ \alpha = m @f$ by:
+     *   @f[
+     *       L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
+     *   @f]
+     *   where the Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre function.
+     *   @param __alpha The degree of the Laguerre function.
+     *   @param __x The argument of the Laguerre function.
+     *   @return The value of the Laguerre function of order n,
+     *           degree @f$ \alpha @f$, and argument x.
+     */
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      //   Compute l_0.
+      _Tp __l_0 = _Tp(1);
+      if  (__n == 0)
+        return __l_0;
+
+      //  Compute l_1^alpha.
+      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
+      if  (__n == 1)
+        return __l_1;
+
+      //  Compute l_n^alpha by recursion on n.
+      _Tp __l_n2 = __l_0;
+      _Tp __l_n1 = __l_1;
+      _Tp __l_n = _Tp(0);
+      for  (unsigned int __nn = 2; __nn <= __n; ++__nn)
+        {
+            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
+                  * __l_n1 / _Tp(__nn)
+                  - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
+            __l_n2 = __l_n1;
+            __l_n1 = __l_n;
+        }
+
+      return __l_n;
+    }
+
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial
+     *          of order n, degree @f$ \alpha @f$: @f$ L_n^alpha(x) @f$.
+     *
+     *   The associated Laguerre function is defined by
+     *   @f[
+     *       L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
+     *                       _1F_1(-n; \alpha + 1; x)
+     *   @f]
+     *   where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
+     *   @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
+     *
+     *   The associated Laguerre polynomial is defined for integral
+     *   @f$ \alpha = m @f$ by:
+     *   @f[
+     *       L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
+     *   @f]
+     *   where the Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre function.
+     *   @param __alpha The degree of the Laguerre function.
+     *   @param __x The argument of the Laguerre function.
+     *   @return The value of the Laguerre function of order n,
+     *           degree @f$ \alpha @f$, and argument x.
+     */
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(__N("Negative argument "
+                                      "in __poly_laguerre."));
+      //  Return NaN on NaN input.
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__n == 0)
+        return _Tp(1);
+      else if (__n == 1)
+        return _Tp(1) + _Tp(__alpha1) - __x;
+      else if (__x == _Tp(0))
+        {
+          _Tp __prod = _Tp(__alpha1) + _Tp(1);
+          for (unsigned int __k = 2; __k <= __n; ++__k)
+            __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
+          return __prod;
+        }
+      else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
+            && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
+        return __poly_laguerre_large_n(__n, __alpha1, __x);
+      else if (_Tp(__alpha1) >= _Tp(0)
+           || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
+        return __poly_laguerre_recursion(__n, __alpha1, __x);
+      else
+        return __poly_laguerre_hyperg(__n, __alpha1, __x);
+    }
+
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial
+     *          of order n, degree m: @f$ L_n^m(x) @f$.
+     *
+     *   The associated Laguerre polynomial is defined for integral
+     *   @f$ \alpha = m @f$ by:
+     *   @f[
+     *       L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
+     *   @f]
+     *   where the Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre polynomial.
+     *   @param __m The degree of the Laguerre polynomial.
+     *   @param __x The argument of the Laguerre polynomial.
+     *   @return The value of the associated Laguerre polynomial of order n,
+     *           degree m, and argument x.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
+    { return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x); }
+
+
+    /**
+     *   @brief This routine returns the Laguerre polynomial
+     *          of order n: @f$ L_n(x) @f$.
+     *
+     *   The Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre polynomial.
+     *   @param __x The argument of the Laguerre polynomial.
+     *   @return The value of the Laguerre polynomial of order n
+     *           and argument x.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __laguerre(unsigned int __n, _Tp __x)
+    { return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_POLY_LAGUERRE_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/random b/gcc-4.9/libstdc++-v3/include/tr1/random
new file mode 100644
index 0000000..3165ccd
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/random
@@ -0,0 +1,50 @@
+// random number generation -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file tr1/random
+ * This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_RANDOM
+#define _GLIBCXX_TR1_RANDOM 1
+
+#pragma GCC system_header
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <iosfwd>
+#include <limits>
+#include <ext/type_traits.h>
+#include <ext/numeric_traits.h>
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+#include <tr1/type_traits>
+#include <tr1/cmath>
+#include <tr1/random.h>
+#include <tr1/random.tcc>
+
+#endif // _GLIBCXX_TR1_RANDOM
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/random.h b/gcc-4.9/libstdc++-v3/include/tr1/random.h
new file mode 100644
index 0000000..086572a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/random.h
@@ -0,0 +1,2417 @@
+// random number generation -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file tr1/random.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/random}
+ */
+
+#ifndef _GLIBCXX_TR1_RANDOM_H
+#define _GLIBCXX_TR1_RANDOM_H 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.1] Random number generation
+
+  /**
+   * @addtogroup tr1_random Random Number Generation
+   * A facility for generating random numbers on selected distributions.
+   * @{
+   */
+
+  /*
+   * Implementation-space details.
+   */
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    template<typename _UIntType, int __w, 
+	     bool = __w < std::numeric_limits<_UIntType>::digits>
+      struct _Shift
+      { static const _UIntType __value = 0; };
+
+    template<typename _UIntType, int __w>
+      struct _Shift<_UIntType, __w, true>
+      { static const _UIntType __value = _UIntType(1) << __w; };
+
+    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
+      struct _Mod;
+
+    // Dispatch based on modulus value to prevent divide-by-zero compile-time
+    // errors when m == 0.
+    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
+      inline _Tp
+      __mod(_Tp __x)
+      { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); }
+
+    typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
+		    unsigned, unsigned long>::__type _UInt32Type;
+
+    /*
+     * An adaptor class for converting the output of any Generator into
+     * the input for a specific Distribution.
+     */
+    template<typename _Engine, typename _Distribution>
+      struct _Adaptor
+      { 
+	typedef typename remove_reference<_Engine>::type _BEngine;
+	typedef typename _BEngine::result_type           _Engine_result_type;
+	typedef typename _Distribution::input_type       result_type;
+
+      public:
+	_Adaptor(const _Engine& __g)
+	: _M_g(__g) { }
+
+	result_type
+	min() const
+	{
+	  result_type __return_value;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = _M_g.min();
+	  else
+	    __return_value = result_type(0);
+	  return __return_value;
+	}
+
+	result_type
+	max() const
+	{
+	  result_type __return_value;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = _M_g.max();
+	  else if (!is_integral<result_type>::value)
+	    __return_value = result_type(1);
+	  else
+	    __return_value = std::numeric_limits<result_type>::max() - 1;
+	  return __return_value;
+	}
+
+	/*
+	 * Converts a value generated by the adapted random number generator
+	 * into a value in the input domain for the dependent random number
+	 * distribution.
+	 *
+	 * Because the type traits are compile time constants only the
+	 * appropriate clause of the if statements will actually be emitted
+	 * by the compiler.
+	 */
+	result_type
+	operator()()
+	{
+	  result_type __return_value;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = _M_g();
+	  else if (!is_integral<_Engine_result_type>::value
+		   && !is_integral<result_type>::value)
+	    __return_value = result_type(_M_g() - _M_g.min())
+	      / result_type(_M_g.max() - _M_g.min());
+	  else if (is_integral<_Engine_result_type>::value
+		   && !is_integral<result_type>::value)
+	    __return_value = result_type(_M_g() - _M_g.min())
+	      / result_type(_M_g.max() - _M_g.min() + result_type(1));
+	  else
+	    __return_value = (((_M_g() - _M_g.min()) 
+			       / (_M_g.max() - _M_g.min()))
+			      * std::numeric_limits<result_type>::max());
+	  return __return_value;
+	}
+
+      private:
+	_Engine _M_g;
+      };
+
+    // Specialization for _Engine*.
+    template<typename _Engine, typename _Distribution>
+      struct _Adaptor<_Engine*, _Distribution>
+      {
+	typedef typename _Engine::result_type      _Engine_result_type;
+	typedef typename _Distribution::input_type result_type;
+
+      public:
+	_Adaptor(_Engine* __g)
+	: _M_g(__g) { }
+
+	result_type
+	min() const
+	{
+	  result_type __return_value;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = _M_g->min();
+	  else
+	    __return_value = result_type(0);
+	  return __return_value;
+	}
+
+	result_type
+	max() const
+	{
+	  result_type __return_value;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = _M_g->max();
+	  else if (!is_integral<result_type>::value)
+	    __return_value = result_type(1);
+	  else
+	    __return_value = std::numeric_limits<result_type>::max() - 1;
+	  return __return_value;
+	}
+
+	result_type
+	operator()()
+	{
+	  result_type __return_value;
+	  if (is_integral<_Engine_result_type>::value
+	      && is_integral<result_type>::value)
+	    __return_value = (*_M_g)();
+	  else if (!is_integral<_Engine_result_type>::value
+		   && !is_integral<result_type>::value)
+	    __return_value = result_type((*_M_g)() - _M_g->min())
+	      / result_type(_M_g->max() - _M_g->min());
+	  else if (is_integral<_Engine_result_type>::value
+		   && !is_integral<result_type>::value)
+	    __return_value = result_type((*_M_g)() - _M_g->min())
+	      / result_type(_M_g->max() - _M_g->min() + result_type(1));
+	  else
+	    __return_value = ((((*_M_g)() - _M_g->min()) 
+			       / (_M_g->max() - _M_g->min()))
+			      * std::numeric_limits<result_type>::max());
+	  return __return_value;
+	}
+
+      private:
+	_Engine* _M_g;
+      };
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace __detail
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * Produces random numbers on a given distribution function using a
+   * non-uniform random number generation engine.
+   *
+   * @todo the engine_value_type needs to be studied more carefully.
+   */
+  template<typename _Engine, typename _Dist>
+    class variate_generator
+    {
+      // Concept requirements.
+      __glibcxx_class_requires(_Engine, _CopyConstructibleConcept)
+      //  __glibcxx_class_requires(_Engine, _EngineConcept)
+      //  __glibcxx_class_requires(_Dist, _EngineConcept)
+
+    public:
+      typedef _Engine                                engine_type;
+      typedef __detail::_Adaptor<_Engine, _Dist>     engine_value_type;
+      typedef _Dist                                  distribution_type;
+      typedef typename _Dist::result_type            result_type;
+
+      // tr1:5.1.1 table 5.1 requirement
+      typedef typename __gnu_cxx::__enable_if<
+	is_arithmetic<result_type>::value, result_type>::__type _IsValidType;
+
+      /**
+       * Constructs a variate generator with the uniform random number
+       * generator @p __eng for the random distribution @p __dist.
+       *
+       * @throws Any exceptions which may thrown by the copy constructors of
+       * the @p _Engine or @p _Dist objects.
+       */
+      variate_generator(engine_type __eng, distribution_type __dist)
+      : _M_engine(__eng), _M_dist(__dist) { }
+
+      /**
+       * Gets the next generated value on the distribution.
+       */
+      result_type
+      operator()()
+      { return _M_dist(_M_engine); }
+
+      /**
+       * WTF?
+       */
+      template<typename _Tp>
+        result_type
+        operator()(_Tp __value)
+        { return _M_dist(_M_engine, __value); }
+
+      /**
+       * Gets a reference to the underlying uniform random number generator
+       * object.
+       */
+      engine_value_type&
+      engine()
+      { return _M_engine; }
+
+      /**
+       * Gets a const reference to the underlying uniform random number
+       * generator object.
+       */
+      const engine_value_type&
+      engine() const
+      { return _M_engine; }
+
+      /**
+       * Gets a reference to the underlying random distribution.
+       */
+      distribution_type&
+      distribution()
+      { return _M_dist; }
+
+      /**
+       * Gets a const reference to the underlying random distribution.
+       */
+      const distribution_type&
+      distribution() const
+      { return _M_dist; }
+
+      /**
+       * Gets the closed lower bound of the distribution interval.
+       */
+      result_type
+      min() const
+      { return this->distribution().min(); }
+
+      /**
+       * Gets the closed upper bound of the distribution interval.
+       */
+      result_type
+      max() const
+      { return this->distribution().max(); }
+
+    private:
+      engine_value_type _M_engine;
+      distribution_type _M_dist;
+    };
+
+
+  /**
+   * @addtogroup tr1_random_generators Random Number Generators
+   * @ingroup tr1_random
+   *
+   * These classes define objects which provide random or pseudorandom
+   * numbers, either from a discrete or a continuous interval.  The
+   * random number generator supplied as a part of this library are
+   * all uniform random number generators which provide a sequence of
+   * random number uniformly distributed over their range.
+   *
+   * A number generator is a function object with an operator() that
+   * takes zero arguments and returns a number.
+   *
+   * A compliant random number generator must satisfy the following
+   * requirements.  <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Random Number Generator Requirements</caption>
+   * <tr><td>To be documented.</td></tr> </table>
+   * 
+   * @{
+   */
+
+  /**
+   * @brief A model of a linear congruential random number generator.
+   *
+   * A random number generator that produces pseudorandom numbers using the
+   * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$.
+   *
+   * The template parameter @p _UIntType must be an unsigned integral type
+   * large enough to store values up to (__m-1). If the template parameter
+   * @p __m is 0, the modulus @p __m used is
+   * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
+   * parameters @p __a and @p __c must be less than @p __m.
+   *
+   * The size of the state is @f$ 1 @f$.
+   */
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    class linear_congruential
+    {
+      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
+      //  __glibcpp_class_requires(__a < __m && __c < __m)
+
+    public:
+      /** The type of the generated random value. */
+      typedef _UIntType result_type;
+
+      /** The multiplier. */
+      static const _UIntType multiplier = __a;
+      /** An increment. */
+      static const _UIntType increment = __c;
+      /** The modulus. */
+      static const _UIntType modulus = __m;
+
+      /**
+       * Constructs a %linear_congruential random number generator engine with
+       * seed @p __s.  The default seed value is 1.
+       *
+       * @param __s The initial seed value.
+       */
+      explicit
+      linear_congruential(unsigned long __x0 = 1)
+      { this->seed(__x0); }
+
+      /**
+       * Constructs a %linear_congruential random number generator engine
+       * seeded from the generator function @p __g.
+       *
+       * @param __g The seed generator function.
+       */
+      template<class _Gen>
+        linear_congruential(_Gen& __g)
+        { this->seed(__g); }
+
+      /**
+       * Reseeds the %linear_congruential random number generator engine
+       * sequence to the seed @g __s.
+       *
+       * @param __s The new seed.
+       */
+      void
+      seed(unsigned long __s = 1);
+
+      /**
+       * Reseeds the %linear_congruential random number generator engine
+       * sequence using values from the generator function @p __g.
+       *
+       * @param __g the seed generator function.
+       */
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      /**
+       * Gets the smallest possible value in the output range.
+       *
+       * The minimum depends on the @p __c parameter: if it is zero, the
+       * minimum generated must be > 0, otherwise 0 is allowed.
+       */
+      result_type
+      min() const
+      { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
+
+      /**
+       * Gets the largest possible value in the output range.
+       */
+      result_type
+      max() const
+      { return __m - 1; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two linear congruential random number generator
+       * objects of the same type for equality.
+       *  
+       * @param __lhs A linear congruential random number generator object.
+       * @param __rhs Another linear congruential random number generator obj.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const linear_congruential& __lhs,
+		 const linear_congruential& __rhs)
+      { return __lhs._M_x == __rhs._M_x; }
+
+      /**
+       * Compares two linear congruential random number generator
+       * objects of the same type for inequality.
+       *
+       * @param __lhs A linear congruential random number generator object.
+       * @param __rhs Another linear congruential random number generator obj.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const linear_congruential& __lhs,
+		 const linear_congruential& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Writes the textual representation of the state x(i) of x to @p __os.
+       *
+       * @param __os  The output stream.
+       * @param __lcr A % linear_congruential random number generator.
+       * @returns __os.
+       */
+      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+	       _UIntType1 __m1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const linear_congruential<_UIntType1, __a1, __c1,
+		   __m1>& __lcr);
+
+      /**
+       * Sets the state of the engine by reading its textual
+       * representation from @p __is.
+       *
+       * The textual representation must have been previously written using an
+       * output stream whose imbued locale and whose type's template
+       * specialization arguments _CharT and _Traits were the same as those of
+       * @p __is.
+       *
+       * @param __is  The input stream.
+       * @param __lcr A % linear_congruential random number generator.
+       * @returns __is.
+       */
+      template<class _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+	       _UIntType1 __m1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      _UIntType _M_x;
+    };
+
+  /**
+   * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
+   */
+  typedef linear_congruential<unsigned long, 16807, 0, 2147483647> minstd_rand0;
+
+  /**
+   * An alternative LCR (Lehmer Generator function) .
+   */
+  typedef linear_congruential<unsigned long, 48271, 0, 2147483647> minstd_rand;
+
+
+  /**
+   * A generalized feedback shift register discrete random number generator.
+   *
+   * This algorithm avoids multiplication and division and is designed to be
+   * friendly to a pipelined architecture.  If the parameters are chosen
+   * correctly, this generator will produce numbers with a very long period and
+   * fairly good apparent entropy, although still not cryptographically strong.
+   *
+   * The best way to use this generator is with the predefined mt19937 class.
+   *
+   * This algorithm was originally invented by Makoto Matsumoto and
+   * Takuji Nishimura.
+   *
+   * @var word_size   The number of bits in each element of the state vector.
+   * @var state_size  The degree of recursion.
+   * @var shift_size  The period parameter.
+   * @var mask_bits   The separation point bit index.
+   * @var parameter_a The last row of the twist matrix.
+   * @var output_u    The first right-shift tempering matrix parameter.
+   * @var output_s    The first left-shift tempering matrix parameter.
+   * @var output_b    The first left-shift tempering matrix mask.
+   * @var output_t    The second left-shift tempering matrix parameter.
+   * @var output_c    The second left-shift tempering matrix mask.
+   * @var output_l    The second right-shift tempering matrix parameter.
+   */
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
+	   _UIntType __c, int __l>
+    class mersenne_twister
+    {
+      __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
+
+    public:
+      // types
+      typedef _UIntType result_type;
+
+      // parameter values
+      static const int       word_size   = __w;
+      static const int       state_size  = __n;
+      static const int       shift_size  = __m;
+      static const int       mask_bits   = __r;
+      static const _UIntType parameter_a = __a;
+      static const int       output_u    = __u;
+      static const int       output_s    = __s;
+      static const _UIntType output_b    = __b;
+      static const int       output_t    = __t;
+      static const _UIntType output_c    = __c;
+      static const int       output_l    = __l;
+
+      // constructors and member function
+      mersenne_twister()
+      { seed(); }
+
+      explicit
+      mersenne_twister(unsigned long __value)
+      { seed(__value); }
+
+      template<class _Gen>
+        mersenne_twister(_Gen& __g)
+        { seed(__g); }
+
+      void
+      seed()
+      { seed(5489UL); }
+
+      void
+      seed(unsigned long __value);
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      result_type
+      min() const
+      { return 0; };
+
+      result_type
+      max() const
+      { return __detail::_Shift<_UIntType, __w>::__value - 1; }
+
+      result_type
+      operator()();
+
+      /**
+       * Compares two % mersenne_twister random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A % mersenne_twister random number generator object.
+       * @param __rhs Another % mersenne_twister random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const mersenne_twister& __lhs,
+		 const mersenne_twister& __rhs)
+      { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); }
+
+      /**
+       * Compares two % mersenne_twister random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A % mersenne_twister random number generator object.
+       * @param __rhs Another % mersenne_twister random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const mersenne_twister& __lhs,
+		 const mersenne_twister& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a % mersenne_twister random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % mersenne_twister random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
+	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
+	       _UIntType1 __c1, int __l1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
+		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
+
+      /**
+       * Extracts the current state of a % mersenne_twister random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % mersenne_twister random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<class _UIntType1, int __w1, int __n1, int __m1, int __r1,
+	       _UIntType1 __a1, int __u1, int __s1, _UIntType1 __b1, int __t1,
+	       _UIntType1 __c1, int __l1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1,
+		   __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      _UIntType _M_x[state_size];
+      int       _M_p;
+    };
+
+  /**
+   * The classic Mersenne Twister.
+   *
+   * Reference:
+   * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
+   * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
+   * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
+   */
+  typedef mersenne_twister<
+    unsigned long, 32, 624, 397, 31,
+    0x9908b0dful, 11, 7,
+    0x9d2c5680ul, 15,
+    0xefc60000ul, 18
+    > mt19937;
+
+
+  /**
+   * @brief The Marsaglia-Zaman generator.
+   * 
+   * This is a model of a Generalized Fibonacci discrete random number
+   * generator, sometimes referred to as the SWC generator.
+   *
+   * A discrete random number generator that produces pseudorandom
+   * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} -
+   * carry_{i-1}) \bmod m @f$.
+   *
+   * The size of the state is @f$ r @f$
+   * and the maximum period of the generator is @f$ m^r - m^s -1 @f$.
+   *
+   * N1688[4.13] says <em>the template parameter _IntType shall denote
+   * an integral type large enough to store values up to m</em>.
+   *
+   * @var _M_x     The state of the generator.  This is a ring buffer.
+   * @var _M_carry The carry.
+   * @var _M_p     Current index of x(i - r).
+   */
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    class subtract_with_carry
+    {
+      __glibcxx_class_requires(_IntType, _IntegerConcept)
+
+    public:
+      /** The type of the generated random value. */
+      typedef _IntType result_type;
+      
+      // parameter values
+      static const _IntType modulus   = __m;
+      static const int      long_lag  = __r;
+      static const int      short_lag = __s;
+
+      /**
+       * Constructs a default-initialized % subtract_with_carry random number
+       * generator.
+       */
+      subtract_with_carry()
+      { this->seed(); }
+
+      /**
+       * Constructs an explicitly seeded % subtract_with_carry random number
+       * generator.
+       */
+      explicit
+      subtract_with_carry(unsigned long __value)
+      { this->seed(__value); }
+
+      /**
+       * Constructs a %subtract_with_carry random number generator engine
+       * seeded from the generator function @p __g.
+       *
+       * @param __g The seed generator function.
+       */
+      template<class _Gen>
+        subtract_with_carry(_Gen& __g)
+        { this->seed(__g); }
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
+       *
+       * N1688[4.19] modifies this as follows.  If @p __value == 0,
+       * sets value to 19780503.  In any case, with a linear
+       * congruential generator lcg(i) having parameters @f$ m_{lcg} =
+       * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
+       * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
+       * \dots lcg(r) \bmod m @f$ respectively.  If @f$ x_{-1} = 0 @f$
+       * set carry to 1, otherwise sets carry to 0.
+       */
+      void
+      seed(unsigned long __value = 19780503);
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry
+       * random number generator.
+       */
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      /**
+       * Gets the inclusive minimum value of the range of random integers
+       * returned by this generator.
+       */
+      result_type
+      min() const
+      { return 0; }
+
+      /**
+       * Gets the inclusive maximum value of the range of random integers
+       * returned by this generator.
+       */
+      result_type
+      max() const
+      { return this->modulus - 1; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two % subtract_with_carry random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A % subtract_with_carry random number generator object.
+       * @param __rhs Another % subtract_with_carry random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const subtract_with_carry& __lhs,
+		 const subtract_with_carry& __rhs)
+      { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); }
+
+      /**
+       * Compares two % subtract_with_carry random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A % subtract_with_carry random number generator object.
+       * @param __rhs Another % subtract_with_carry random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const subtract_with_carry& __lhs,
+		 const subtract_with_carry& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a % subtract_with_carry random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % subtract_with_carry random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const subtract_with_carry<_IntType1, __m1, __s1,
+		   __r1>& __x);
+
+      /**
+       * Extracts the current state of a % subtract_with_carry random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % subtract_with_carry random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _IntType1, _IntType1 __m1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType;
+
+      _UIntType  _M_x[long_lag];
+      _UIntType  _M_carry;
+      int        _M_p;
+    };
+
+
+  /**
+   * @brief The Marsaglia-Zaman generator (floats version).
+   *
+   * @var _M_x     The state of the generator.  This is a ring buffer.
+   * @var _M_carry The carry.
+   * @var _M_p     Current index of x(i - r).
+   * @var _M_npows Precomputed negative powers of 2.   
+   */
+  template<typename _RealType, int __w, int __s, int __r>
+    class subtract_with_carry_01
+    {
+    public:
+      /** The type of the generated random value. */
+      typedef _RealType result_type;
+      
+      // parameter values
+      static const int      word_size = __w;
+      static const int      long_lag  = __r;
+      static const int      short_lag = __s;
+
+      /**
+       * Constructs a default-initialized % subtract_with_carry_01 random
+       * number generator.
+       */
+      subtract_with_carry_01()
+      {
+	this->seed();
+	_M_initialize_npows();
+      }
+
+      /**
+       * Constructs an explicitly seeded % subtract_with_carry_01 random number
+       * generator.
+       */
+      explicit
+      subtract_with_carry_01(unsigned long __value)
+      {
+	this->seed(__value);
+	_M_initialize_npows();
+      }
+
+      /**
+       * Constructs a % subtract_with_carry_01 random number generator engine
+       * seeded from the generator function @p __g.
+       *
+       * @param __g The seed generator function.
+       */
+      template<class _Gen>
+        subtract_with_carry_01(_Gen& __g)
+        {
+	  this->seed(__g);
+	  _M_initialize_npows();	  
+	}
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the random number generator.
+       */
+      void
+      seed(unsigned long __value = 19780503);
+
+      /**
+       * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry_01
+       * random number generator.
+       */
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        { seed(__g, typename is_fundamental<_Gen>::type()); }
+
+      /**
+       * Gets the minimum value of the range of random floats
+       * returned by this generator.
+       */
+      result_type
+      min() const
+      { return 0.0; }
+
+      /**
+       * Gets the maximum value of the range of random floats
+       * returned by this generator.
+       */
+      result_type
+      max() const
+      { return 1.0; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two % subtract_with_carry_01 random number generator objects
+       * of the same type for equality.
+       *
+       * @param __lhs A % subtract_with_carry_01 random number
+       *              generator object.
+       * @param __rhs Another % subtract_with_carry_01 random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const subtract_with_carry_01& __lhs,
+		 const subtract_with_carry_01& __rhs)
+      {
+	for (int __i = 0; __i < long_lag; ++__i)
+	  if (!std::equal(__lhs._M_x[__i], __lhs._M_x[__i] + __n,
+			  __rhs._M_x[__i]))
+	    return false;
+	return true;
+      }
+
+      /**
+       * Compares two % subtract_with_carry_01 random number generator objects
+       * of the same type for inequality.
+       *
+       * @param __lhs A % subtract_with_carry_01 random number
+       *              generator object.
+       *
+       * @param __rhs Another % subtract_with_carry_01 random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const subtract_with_carry_01& __lhs,
+		 const subtract_with_carry_01& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a % subtract_with_carry_01 random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A % subtract_with_carry_01 random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, int __w1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const subtract_with_carry_01<_RealType1, __w1, __s1,
+		   __r1>& __x);
+
+      /**
+       * Extracts the current state of a % subtract_with_carry_01 random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A % subtract_with_carry_01 random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<typename _RealType1, int __w1, int __s1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x);
+
+    private:
+      template<class _Gen>
+        void
+        seed(_Gen& __g, true_type)
+        { return seed(static_cast<unsigned long>(__g)); }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g, false_type);
+
+      void
+      _M_initialize_npows();
+
+      static const int __n = (__w + 31) / 32;
+
+      typedef __detail::_UInt32Type _UInt32Type;
+      _UInt32Type  _M_x[long_lag][__n];
+      _RealType    _M_npows[__n];
+      _UInt32Type  _M_carry;
+      int          _M_p;
+    };
+
+  typedef subtract_with_carry_01<float, 24, 10, 24>   ranlux_base_01;
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 508. Bad parameters for ranlux64_base_01.
+  typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;  
+
+
+  /**
+   * Produces random numbers from some base engine by discarding blocks of
+   * data.
+   *
+   * 0 <= @p __r <= @p __p
+   */
+  template<class _UniformRandomNumberGenerator, int __p, int __r>
+    class discard_block
+    {
+      // __glibcxx_class_requires(typename base_type::result_type,
+      //                          ArithmeticTypeConcept)
+
+    public:
+      /** The type of the underlying generator engine. */
+      typedef _UniformRandomNumberGenerator   base_type;
+      /** The type of the generated random value. */
+      typedef typename base_type::result_type result_type;
+
+      // parameter values
+      static const int block_size = __p;
+      static const int used_block = __r;
+
+      /**
+       * Constructs a default %discard_block engine.
+       *
+       * The underlying engine is default constructed as well.
+       */
+      discard_block()
+      : _M_n(0) { }
+
+      /**
+       * Copy constructs a %discard_block engine.
+       *
+       * Copies an existing base class random number generator.
+       * @param rng An existing (base class) engine object.
+       */
+      explicit
+      discard_block(const base_type& __rng)
+      : _M_b(__rng), _M_n(0) { }
+
+      /**
+       * Seed constructs a %discard_block engine.
+       *
+       * Constructs the underlying generator engine seeded with @p __s.
+       * @param __s A seed value for the base class engine.
+       */
+      explicit
+      discard_block(unsigned long __s)
+      : _M_b(__s), _M_n(0) { }
+
+      /**
+       * Generator construct a %discard_block engine.
+       *
+       * @param __g A seed generator function.
+       */
+      template<class _Gen>
+        discard_block(_Gen& __g)
+	: _M_b(__g), _M_n(0) { }
+
+      /**
+       * Reseeds the %discard_block object with the default seed for the
+       * underlying base class generator engine.
+       */
+      void seed()
+      {
+	_M_b.seed();
+	_M_n = 0;
+      }
+
+      /**
+       * Reseeds the %discard_block object with the given seed generator
+       * function.
+       * @param __g A seed generator function.
+       */
+      template<class _Gen>
+        void seed(_Gen& __g)
+        {
+	  _M_b.seed(__g);
+	  _M_n = 0;
+	}
+
+      /**
+       * Gets a const reference to the underlying generator engine object.
+       */
+      const base_type&
+      base() const
+      { return _M_b; }
+
+      /**
+       * Gets the minimum value in the generated random number range.
+       */
+      result_type
+      min() const
+      { return _M_b.min(); }
+
+      /**
+       * Gets the maximum value in the generated random number range.
+       */
+      result_type
+      max() const
+      { return _M_b.max(); }
+
+      /**
+       * Gets the next value in the generated random number sequence.
+       */
+      result_type
+      operator()();
+
+      /**
+       * Compares two %discard_block random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A %discard_block random number generator object.
+       * @param __rhs Another %discard_block random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const discard_block& __lhs, const discard_block& __rhs)
+      { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
+
+      /**
+       * Compares two %discard_block random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A %discard_block random number generator object.
+       * @param __rhs Another %discard_block random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const discard_block& __lhs, const discard_block& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a %discard_block random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %discard_block random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const discard_block<_UniformRandomNumberGenerator1,
+		   __p1, __r1>& __x);
+
+      /**
+       * Extracts the current state of a % subtract_with_carry random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %discard_block random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator1, int __p1, int __r1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   discard_block<_UniformRandomNumberGenerator1,
+		   __p1, __r1>& __x);
+
+    private:
+      base_type _M_b;
+      int       _M_n;
+    };
+
+
+  /**
+   * James's luxury-level-3 integer adaptation of Luescher's generator.
+   */
+  typedef discard_block<
+    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
+      223,
+      24
+      > ranlux3;
+
+  /**
+   * James's luxury-level-4 integer adaptation of Luescher's generator.
+   */
+  typedef discard_block<
+    subtract_with_carry<unsigned long, (1UL << 24), 10, 24>,
+      389,
+      24
+      > ranlux4;
+
+  typedef discard_block<
+    subtract_with_carry_01<float, 24, 10, 24>,
+      223,
+      24
+      > ranlux3_01;
+
+  typedef discard_block<
+    subtract_with_carry_01<float, 24, 10, 24>,
+      389,
+      24
+      > ranlux4_01;
+
+
+  /**
+   * A random number generator adaptor class that combines two random number
+   * generator engines into a single output sequence.
+   */
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2>
+    class xor_combine
+    {
+      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator1::
+      //                          result_type, ArithmeticTypeConcept)
+      // __glibcxx_class_requires(typename _UniformRandomNumberGenerator2::
+      //                          result_type, ArithmeticTypeConcept)
+
+    public:
+      /** The type of the first underlying generator engine. */
+      typedef _UniformRandomNumberGenerator1   base1_type;
+      /** The type of the second underlying generator engine. */
+      typedef _UniformRandomNumberGenerator2   base2_type;
+
+    private:
+      typedef typename base1_type::result_type _Result_type1;
+      typedef typename base2_type::result_type _Result_type2;
+
+    public:
+      /** The type of the generated random value. */
+      typedef typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1)
+						      > sizeof(_Result_type2)),
+	_Result_type1, _Result_type2>::__type result_type;
+
+      // parameter values
+      static const int shift1 = __s1;
+      static const int shift2 = __s2;
+
+      // constructors and member function
+      xor_combine()
+      : _M_b1(), _M_b2()	
+      { _M_initialize_max(); }
+
+      xor_combine(const base1_type& __rng1, const base2_type& __rng2)
+      : _M_b1(__rng1), _M_b2(__rng2)
+      { _M_initialize_max(); }
+
+      xor_combine(unsigned long __s)
+      : _M_b1(__s), _M_b2(__s + 1)
+      { _M_initialize_max(); }
+
+      template<class _Gen>
+        xor_combine(_Gen& __g)
+	: _M_b1(__g), _M_b2(__g)
+        { _M_initialize_max(); }
+
+      void
+      seed()
+      {
+	_M_b1.seed();
+	_M_b2.seed();
+      }
+
+      template<class _Gen>
+        void
+        seed(_Gen& __g)
+        {
+	  _M_b1.seed(__g);
+	  _M_b2.seed(__g);
+	}
+
+      const base1_type&
+      base1() const
+      { return _M_b1; }
+
+      const base2_type&
+      base2() const
+      { return _M_b2; }
+
+      result_type
+      min() const
+      { return 0; }
+
+      result_type
+      max() const
+      { return _M_max; }
+
+      /**
+       * Gets the next random number in the sequence.
+       */
+      // NB: Not exactly the TR1 formula, per N2079 instead.
+      result_type
+      operator()()
+      {
+	return ((result_type(_M_b1() - _M_b1.min()) << shift1)
+		^ (result_type(_M_b2() - _M_b2.min()) << shift2));
+      }
+
+      /**
+       * Compares two %xor_combine random number generator objects of
+       * the same type for equality.
+       *
+       * @param __lhs A %xor_combine random number generator object.
+       * @param __rhs Another %xor_combine random number generator
+       *              object.
+       *
+       * @returns true if the two objects are equal, false otherwise.
+       */
+      friend bool
+      operator==(const xor_combine& __lhs, const xor_combine& __rhs)
+      {
+	return (__lhs.base1() == __rhs.base1())
+	        && (__lhs.base2() == __rhs.base2());
+      }
+
+      /**
+       * Compares two %xor_combine random number generator objects of
+       * the same type for inequality.
+       *
+       * @param __lhs A %xor_combine random number generator object.
+       * @param __rhs Another %xor_combine random number generator
+       *              object.
+       *
+       * @returns true if the two objects are not equal, false otherwise.
+       */
+      friend bool
+      operator!=(const xor_combine& __lhs, const xor_combine& __rhs)
+      { return !(__lhs == __rhs); }
+
+      /**
+       * Inserts the current state of a %xor_combine random number
+       * generator engine @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %xor_combine random number generator engine.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator11, int __s11,
+	       class _UniformRandomNumberGenerator21, int __s21,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const xor_combine<_UniformRandomNumberGenerator11, __s11,
+		   _UniformRandomNumberGenerator21, __s21>& __x);
+
+      /**
+       * Extracts the current state of a %xor_combine random number
+       * generator engine @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %xor_combine random number generator engine.
+       *
+       * @returns The input stream with the state of @p __x extracted or in
+       * an error state.
+       */
+      template<class _UniformRandomNumberGenerator11, int __s11,
+	       class _UniformRandomNumberGenerator21, int __s21,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   xor_combine<_UniformRandomNumberGenerator11, __s11,
+		   _UniformRandomNumberGenerator21, __s21>& __x);
+
+    private:
+      void
+      _M_initialize_max();
+
+      result_type
+      _M_initialize_max_aux(result_type, result_type, int);
+
+      base1_type  _M_b1;
+      base2_type  _M_b2;
+      result_type _M_max;
+    };
+
+
+  /**
+   * A standard interface to a platform-specific non-deterministic
+   * random number generator (if any are available).
+   */
+  class random_device
+  {
+  public:
+    // types
+    typedef unsigned int result_type;
+
+    // constructors, destructors and member functions
+
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+
+    explicit
+    random_device(const std::string& __token = "/dev/urandom")
+    {
+      if ((__token != "/dev/urandom" && __token != "/dev/random")
+	  || !(_M_file = std::fopen(__token.c_str(), "rb")))
+	std::__throw_runtime_error(__N("random_device::"
+				       "random_device(const std::string&)"));
+    }
+
+    ~random_device()
+    { std::fclose(_M_file); }
+
+#else
+
+    explicit
+    random_device(const std::string& __token = "mt19937")
+    : _M_mt(_M_strtoul(__token)) { }
+
+  private:
+    static unsigned long
+    _M_strtoul(const std::string& __str)
+    {
+      unsigned long __ret = 5489UL;
+      if (__str != "mt19937")
+	{
+	  const char* __nptr = __str.c_str();
+	  char* __endptr;
+	  __ret = std::strtoul(__nptr, &__endptr, 0);
+	  if (*__nptr == '\0' || *__endptr != '\0')
+	    std::__throw_runtime_error(__N("random_device::_M_strtoul"
+					   "(const std::string&)"));
+	}
+      return __ret;
+    }
+
+  public:
+
+#endif
+
+    result_type
+    min() const
+    { return std::numeric_limits<result_type>::min(); }
+
+    result_type
+    max() const
+    { return std::numeric_limits<result_type>::max(); }
+
+    double
+    entropy() const
+    { return 0.0; }
+
+    result_type
+    operator()()
+    {
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+      result_type __ret;
+      std::fread(reinterpret_cast<void*>(&__ret), sizeof(result_type),
+		 1, _M_file);
+      return __ret;
+#else
+      return _M_mt();
+#endif
+    }
+
+  private:
+    random_device(const random_device&);
+    void operator=(const random_device&);
+
+#ifdef _GLIBCXX_USE_RANDOM_TR1
+    FILE*        _M_file;
+#else
+    mt19937      _M_mt;
+#endif
+  };
+
+  /* @} */ // group tr1_random_generators
+
+  /**
+   * @addtogroup tr1_random_distributions Random Number Distributions
+   * @ingroup tr1_random
+   * @{
+   */
+
+  /**
+   * @addtogroup tr1_random_distributions_discrete Discrete Distributions
+   * @ingroup tr1_random_distributions
+   * @{
+   */
+
+  /**
+   * @brief Uniform discrete distribution for random numbers.
+   * A discrete random distribution on the range @f$[min, max]@f$ with equal
+   * probability throughout the range.
+   */
+  template<typename _IntType = int>
+    class uniform_int
+    {
+      __glibcxx_class_requires(_IntType, _IntegerConcept)
+ 
+    public:
+      /** The type of the parameters of the distribution. */
+      typedef _IntType input_type;
+      /** The type of the range of the distribution. */
+      typedef _IntType result_type;
+
+    public:
+      /**
+       * Constructs a uniform distribution object.
+       */
+      explicit
+      uniform_int(_IntType __min = 0, _IntType __max = 9)
+      : _M_min(__min), _M_max(__max)
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
+      }
+
+      /**
+       * Gets the inclusive lower bound of the distribution range.
+       */
+      result_type
+      min() const
+      { return _M_min; }
+
+      /**
+       * Gets the inclusive upper bound of the distribution range.
+       */
+      result_type
+      max() const
+      { return _M_max; }
+
+      /**
+       * Resets the distribution state.
+       *
+       * Does nothing for the uniform integer distribution.
+       */
+      void
+      reset() { }
+
+      /**
+       * Gets a uniformly distributed random number in the range
+       * @f$(min, max)@f$.
+       */
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng)
+        {
+	  typedef typename _UniformRandomNumberGenerator::result_type
+	    _UResult_type;
+	  return _M_call(__urng, _M_min, _M_max,
+			 typename is_integral<_UResult_type>::type());
+	}
+
+      /**
+       * Gets a uniform random number in the range @f$[0, n)@f$.
+       *
+       * This function is aimed at use with std::random_shuffle.
+       */
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng, result_type __n)
+        {
+	  typedef typename _UniformRandomNumberGenerator::result_type
+	    _UResult_type;
+	  return _M_call(__urng, 0, __n - 1,
+			 typename is_integral<_UResult_type>::type());
+	}
+
+      /**
+       * Inserts a %uniform_int random number distribution @p __x into the
+       * output stream @p os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %uniform_int random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const uniform_int<_IntType1>& __x);
+
+      /**
+       * Extracts a %uniform_int random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %uniform_int random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _IntType1, typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   uniform_int<_IntType1>& __x);
+
+    private:
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        _M_call(_UniformRandomNumberGenerator& __urng,
+		result_type __min, result_type __max, true_type);
+
+      template<typename _UniformRandomNumberGenerator>
+        result_type
+        _M_call(_UniformRandomNumberGenerator& __urng,
+		result_type __min, result_type __max, false_type)
+        {
+	  return result_type((__urng() - __urng.min())
+			     / (__urng.max() - __urng.min())
+			     * (__max - __min + 1)) + __min;
+	}
+
+      _IntType _M_min;
+      _IntType _M_max;
+    };
+
+
+  /**
+   * @brief A Bernoulli random number distribution.
+   *
+   * Generates a sequence of true and false values with likelihood @f$ p @f$
+   * that true will come up and @f$ (1 - p) @f$ that false will appear.
+   */
+  class bernoulli_distribution
+  {
+  public:
+    typedef int  input_type;
+    typedef bool result_type;
+
+  public:
+    /**
+     * Constructs a Bernoulli distribution with likelihood @p p.
+     *
+     * @param __p  [IN]  The likelihood of a true result being returned.  Must
+     * be in the interval @f$ [0, 1] @f$.
+     */
+    explicit
+    bernoulli_distribution(double __p = 0.5)
+    : _M_p(__p)
+    { 
+      _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
+    }
+
+    /**
+     * Gets the @p p parameter of the distribution.
+     */
+    double
+    p() const
+    { return _M_p; }
+
+    /**
+     * Resets the distribution state.
+     *
+     * Does nothing for a Bernoulli distribution.
+     */
+    void
+    reset() { }
+
+    /**
+     * Gets the next value in the Bernoullian sequence.
+     */
+    template<class _UniformRandomNumberGenerator>
+      result_type
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	if ((__urng() - __urng.min()) < _M_p * (__urng.max() - __urng.min()))
+	  return true;
+	return false;
+      }
+
+    /**
+     * Inserts a %bernoulli_distribution random number distribution
+     * @p __x into the output stream @p __os.
+     *
+     * @param __os An output stream.
+     * @param __x  A %bernoulli_distribution random number distribution.
+     *
+     * @returns The output stream with the state of @p __x inserted or in
+     * an error state.
+     */
+    template<typename _CharT, typename _Traits>
+      friend std::basic_ostream<_CharT, _Traits>&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		 const bernoulli_distribution& __x);
+
+    /**
+     * Extracts a %bernoulli_distribution random number distribution
+     * @p __x from the input stream @p __is.
+     *
+     * @param __is An input stream.
+     * @param __x  A %bernoulli_distribution random number generator engine.
+     *
+     * @returns The input stream with @p __x extracted or in an error state.
+     */
+    template<typename _CharT, typename _Traits>
+      friend std::basic_istream<_CharT, _Traits>&
+      operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		 bernoulli_distribution& __x)
+      { return __is >> __x._M_p; }
+
+  private:
+    double _M_p;
+  };
+
+
+  /**
+   * @brief A discrete geometric random number distribution.
+   *
+   * The formula for the geometric probability mass function is 
+   * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
+   * distribution.
+   */
+  template<typename _IntType = int, typename _RealType = double>
+    class geometric_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _IntType  result_type;
+
+      // constructors and member function
+      explicit
+      geometric_distribution(const _RealType& __p = _RealType(0.5))
+      : _M_p(__p)
+      {
+	_GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
+	_M_initialize();
+      }
+
+      /**
+       * Gets the distribution parameter @p p.
+       */
+      _RealType
+      p() const
+      { return _M_p; }
+
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %geometric_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %geometric_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const geometric_distribution<_IntType1, _RealType1>& __x);
+
+      /**
+       * Extracts a %geometric_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %geometric_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   geometric_distribution& __x)
+        {
+	  __is >> __x._M_p;
+	  __x._M_initialize();
+	  return __is;
+	}
+
+    private:
+      void
+      _M_initialize()
+      { _M_log_p = std::log(_M_p); }
+
+      _RealType _M_p;
+      _RealType _M_log_p;
+    };
+
+
+  template<typename _RealType>
+    class normal_distribution;
+
+  /**
+   * @brief A discrete Poisson random number distribution.
+   *
+   * The formula for the Poisson probability mass function is
+   * @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the
+   * parameter of the distribution.
+   */
+  template<typename _IntType = int, typename _RealType = double>
+    class poisson_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _IntType  result_type;
+
+      // constructors and member function
+      explicit
+      poisson_distribution(const _RealType& __mean = _RealType(1))
+      : _M_mean(__mean), _M_nd()
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
+	_M_initialize();
+      }
+
+      /**
+       * Gets the distribution parameter @p mean.
+       */
+      _RealType
+      mean() const
+      { return _M_mean; }
+
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %poisson_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %poisson_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const poisson_distribution<_IntType1, _RealType1>& __x);
+
+      /**
+       * Extracts a %poisson_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %poisson_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   poisson_distribution<_IntType1, _RealType1>& __x);
+
+    private:
+      void
+      _M_initialize();
+
+      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+      normal_distribution<_RealType> _M_nd;
+
+      _RealType _M_mean;
+
+      // Hosts either log(mean) or the threshold of the simple method.
+      _RealType _M_lm_thr;
+#if _GLIBCXX_USE_C99_MATH_TR1
+      _RealType _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
+#endif
+    };
+
+
+  /**
+   * @brief A discrete binomial random number distribution.
+   *
+   * The formula for the binomial probability mass function is 
+   * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
+   * and @f$ p @f$ are the parameters of the distribution.
+   */
+  template<typename _IntType = int, typename _RealType = double>
+    class binomial_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _IntType  result_type;
+
+      // constructors and member function
+      explicit
+      binomial_distribution(_IntType __t = 1,
+			    const _RealType& __p = _RealType(0.5))
+      : _M_t(__t), _M_p(__p), _M_nd()
+      {
+	_GLIBCXX_DEBUG_ASSERT((_M_t >= 0) && (_M_p >= 0.0) && (_M_p <= 1.0));
+	_M_initialize();
+      }
+
+      /**
+       * Gets the distribution @p t parameter.
+       */
+      _IntType
+      t() const
+      { return _M_t; }
+      
+      /**
+       * Gets the distribution @p p parameter.
+       */
+      _RealType
+      p() const
+      { return _M_p; }
+
+      void
+      reset()
+      { _M_nd.reset(); }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %binomial_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %binomial_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const binomial_distribution<_IntType1, _RealType1>& __x);
+
+      /**
+       * Extracts a %binomial_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %binomial_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _IntType1, typename _RealType1,
+	       typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   binomial_distribution<_IntType1, _RealType1>& __x);
+
+    private:
+      void
+      _M_initialize();
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
+
+      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+      normal_distribution<_RealType> _M_nd;
+
+      _RealType _M_q;
+#if _GLIBCXX_USE_C99_MATH_TR1
+      _RealType _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
+	        _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
+#endif
+      _RealType _M_p;
+      _IntType  _M_t;
+
+      bool      _M_easy;
+    };
+
+  /* @} */ // group tr1_random_distributions_discrete
+
+  /**
+   * @addtogroup tr1_random_distributions_continuous Continuous Distributions
+   * @ingroup tr1_random_distributions
+   * @{
+   */
+
+  /**
+   * @brief Uniform continuous distribution for random numbers.
+   *
+   * A continuous random distribution on the range [min, max) with equal
+   * probability throughout the range.  The URNG should be real-valued and
+   * deliver number in the range [0, 1).
+   */
+  template<typename _RealType = double>
+    class uniform_real
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs a uniform_real object.
+       *
+       * @param __min [IN]  The lower bound of the distribution.
+       * @param __max [IN]  The upper bound of the distribution.
+       */
+      explicit
+      uniform_real(_RealType __min = _RealType(0),
+		   _RealType __max = _RealType(1))
+      : _M_min(__min), _M_max(__max)
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max);
+      }
+
+      result_type
+      min() const
+      { return _M_min; }
+
+      result_type
+      max() const
+      { return _M_max; }
+
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng)
+        { return (__urng() * (_M_max - _M_min)) + _M_min; }
+
+      /**
+       * Inserts a %uniform_real random number distribution @p __x into the
+       * output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %uniform_real random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const uniform_real<_RealType1>& __x);
+
+      /**
+       * Extracts a %uniform_real random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %uniform_real random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   uniform_real<_RealType1>& __x);
+
+    private:
+      _RealType _M_min;
+      _RealType _M_max;
+    };
+
+
+  /**
+   * @brief An exponential continuous distribution for random numbers.
+   *
+   * The formula for the exponential probability mass function is 
+   * @f$ p(x) = \lambda e^{-\lambda x} @f$.
+   *
+   * <table border=1 cellpadding=10 cellspacing=0>
+   * <caption align=top>Distribution Statistics</caption>
+   * <tr><td>Mean</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
+   * <tr><td>Median</td><td>@f$ \frac{\ln 2}{\lambda} @f$</td></tr>
+   * <tr><td>Mode</td><td>@f$ zero @f$</td></tr>
+   * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
+   * <tr><td>Standard Deviation</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
+   * </table>
+   */
+  template<typename _RealType = double>
+    class exponential_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs an exponential distribution with inverse scale parameter
+       * @f$ \lambda @f$.
+       */
+      explicit
+      exponential_distribution(const result_type& __lambda = result_type(1))
+      : _M_lambda(__lambda)
+      { 
+	_GLIBCXX_DEBUG_ASSERT(_M_lambda > 0);
+      }
+
+      /**
+       * Gets the inverse scale parameter of the distribution.
+       */
+      _RealType
+      lambda() const
+      { return _M_lambda; }
+
+      /**
+       * Resets the distribution.
+       *
+       * Has no effect on exponential distributions.
+       */
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng)
+        { return -std::log(__urng()) / _M_lambda; }
+
+      /**
+       * Inserts a %exponential_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %exponential_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const exponential_distribution<_RealType1>& __x);
+
+      /**
+       * Extracts a %exponential_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x A %exponential_distribution random number
+       *            generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   exponential_distribution& __x)
+        { return __is >> __x._M_lambda; }
+
+    private:
+      result_type _M_lambda;
+    };
+
+
+  /**
+   * @brief A normal continuous distribution for random numbers.
+   *
+   * The formula for the normal probability mass function is 
+   * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}} 
+   *            e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$.
+   */
+  template<typename _RealType = double>
+    class normal_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs a normal distribution with parameters @f$ mean @f$ and
+       * @f$ \sigma @f$.
+       */
+      explicit
+      normal_distribution(const result_type& __mean = result_type(0),
+			  const result_type& __sigma = result_type(1))
+      : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false)
+      { 
+	_GLIBCXX_DEBUG_ASSERT(_M_sigma > 0);
+      }
+
+      /**
+       * Gets the mean of the distribution.
+       */
+      _RealType
+      mean() const
+      { return _M_mean; }
+
+      /**
+       * Gets the @f$ \sigma @f$ of the distribution.
+       */
+      _RealType
+      sigma() const
+      { return _M_sigma; }
+
+      /**
+       * Resets the distribution.
+       */
+      void
+      reset()
+      { _M_saved_available = false; }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %normal_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %normal_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const normal_distribution<_RealType1>& __x);
+
+      /**
+       * Extracts a %normal_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %normal_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   normal_distribution<_RealType1>& __x);
+
+    private:
+      result_type _M_mean;
+      result_type _M_sigma;
+      result_type _M_saved;
+      bool        _M_saved_available;     
+    };
+
+
+  /**
+   * @brief A gamma continuous distribution for random numbers.
+   *
+   * The formula for the gamma probability mass function is 
+   * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$.
+   */
+  template<typename _RealType = double>
+    class gamma_distribution
+    {
+    public:
+      // types
+      typedef _RealType input_type;
+      typedef _RealType result_type;
+
+    public:
+      /**
+       * Constructs a gamma distribution with parameters @f$ \alpha @f$.
+       */
+      explicit
+      gamma_distribution(const result_type& __alpha_val = result_type(1))
+      : _M_alpha(__alpha_val)
+      { 
+	_GLIBCXX_DEBUG_ASSERT(_M_alpha > 0);
+	_M_initialize();
+      }
+
+      /**
+       * Gets the @f$ \alpha @f$ of the distribution.
+       */
+      _RealType
+      alpha() const
+      { return _M_alpha; }
+
+      /**
+       * Resets the distribution.
+       */
+      void
+      reset() { }
+
+      template<class _UniformRandomNumberGenerator>
+        result_type
+        operator()(_UniformRandomNumberGenerator& __urng);
+
+      /**
+       * Inserts a %gamma_distribution random number distribution
+       * @p __x into the output stream @p __os.
+       *
+       * @param __os An output stream.
+       * @param __x  A %gamma_distribution random number distribution.
+       *
+       * @returns The output stream with the state of @p __x inserted or in
+       * an error state.
+       */
+      template<typename _RealType1, typename _CharT, typename _Traits>
+        friend std::basic_ostream<_CharT, _Traits>&
+        operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+		   const gamma_distribution<_RealType1>& __x);
+
+      /**
+       * Extracts a %gamma_distribution random number distribution
+       * @p __x from the input stream @p __is.
+       *
+       * @param __is An input stream.
+       * @param __x  A %gamma_distribution random number generator engine.
+       *
+       * @returns The input stream with @p __x extracted or in an error state.
+       */
+      template<typename _CharT, typename _Traits>
+        friend std::basic_istream<_CharT, _Traits>&
+        operator>>(std::basic_istream<_CharT, _Traits>& __is,
+		   gamma_distribution& __x)
+        {
+	  __is >> __x._M_alpha;
+	  __x._M_initialize();
+	  return __is;
+	}
+
+    private:
+      void
+      _M_initialize();
+
+      result_type _M_alpha;
+
+      // Hosts either lambda of GB or d of modified Vaduva's.
+      result_type _M_l_d;
+    };
+
+  /* @} */ // group tr1_random_distributions_continuous
+  /* @} */ // group tr1_random_distributions
+  /* @} */ // group tr1_random
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_RANDOM_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/random.tcc b/gcc-4.9/libstdc++-v3/include/tr1/random.tcc
new file mode 100644
index 0000000..057a3c4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/random.tcc
@@ -0,0 +1,1721 @@
+// random number generation (out of line) -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+
+/** @file tr1/random.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/random}
+ */
+
+#ifndef _GLIBCXX_TR1_RANDOM_TCC
+#define _GLIBCXX_TR1_RANDOM_TCC 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  /*
+   * (Further) implementation-space details.
+   */
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    // General case for x = (ax + c) mod m -- use Schrage's algorithm to avoid
+    // integer overflow.
+    //
+    // Because a and c are compile-time integral constants the compiler kindly
+    // elides any unreachable paths.
+    //
+    // Preconditions:  a > 0, m > 0.
+    //
+    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
+      struct _Mod
+      {
+	static _Tp
+	__calc(_Tp __x)
+	{
+	  if (__a == 1)
+	    __x %= __m;
+	  else
+	    {
+	      static const _Tp __q = __m / __a;
+	      static const _Tp __r = __m % __a;
+	      
+	      _Tp __t1 = __a * (__x % __q);
+	      _Tp __t2 = __r * (__x / __q);
+	      if (__t1 >= __t2)
+		__x = __t1 - __t2;
+	      else
+		__x = __m - __t2 + __t1;
+	    }
+
+	  if (__c != 0)
+	    {
+	      const _Tp __d = __m - __x;
+	      if (__d > __c)
+		__x += __c;
+	      else
+		__x = __c - __d;
+	    }
+	  return __x;
+	}
+      };
+
+    // Special case for m == 0 -- use unsigned integer overflow as modulo
+    // operator.
+    template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
+      struct _Mod<_Tp, __a, __c, __m, true>
+      {
+	static _Tp
+	__calc(_Tp __x)
+	{ return __a * __x + __c; }
+      };
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace __detail
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    const _UIntType
+    linear_congruential<_UIntType, __a, __c, __m>::multiplier;
+
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    const _UIntType
+    linear_congruential<_UIntType, __a, __c, __m>::increment;
+
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    const _UIntType
+    linear_congruential<_UIntType, __a, __c, __m>::modulus;
+
+  /**
+   * Seeds the LCR with integral value @p __x0, adjusted so that the 
+   * ring identity is never a member of the convergence set.
+   */
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    void
+    linear_congruential<_UIntType, __a, __c, __m>::
+    seed(unsigned long __x0)
+    {
+      if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0)
+	  && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0))
+	_M_x = __detail::__mod<_UIntType, 1, 0, __m>(1);
+      else
+	_M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0);
+    }
+
+  /**
+   * Seeds the LCR engine with a value generated by @p __g.
+   */
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    template<class _Gen>
+      void
+      linear_congruential<_UIntType, __a, __c, __m>::
+      seed(_Gen& __g, false_type)
+      {
+	_UIntType __x0 = __g();
+	if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0)
+	    && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0))
+	  _M_x = __detail::__mod<_UIntType, 1, 0, __m>(1);
+	else
+	  _M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0);
+      }
+
+  /**
+   * Gets the next generated value in sequence.
+   */
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    typename linear_congruential<_UIntType, __a, __c, __m>::result_type
+    linear_congruential<_UIntType, __a, __c, __m>::
+    operator()()
+    {
+      _M_x = __detail::__mod<_UIntType, __a, __c, __m>(_M_x);
+      return _M_x;
+    }
+
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const linear_congruential<_UIntType, __a, __c, __m>& __lcr)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__os.widen(' '));
+
+      __os << __lcr._M_x;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       linear_congruential<_UIntType, __a, __c, __m>& __lcr)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec);
+
+      __is >> __lcr._M_x;
+
+      __is.flags(__flags);
+      return __is;
+    } 
+
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::word_size;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::state_size;
+    
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::shift_size;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::mask_bits;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const _UIntType
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::parameter_a;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::output_u;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::output_s;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const _UIntType
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::output_b;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::output_t;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const _UIntType
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::output_c;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    const int
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::output_l;
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    void
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::
+    seed(unsigned long __value)
+    {
+      _M_x[0] = __detail::__mod<_UIntType, 1, 0,
+	__detail::_Shift<_UIntType, __w>::__value>(__value);
+
+      for (int __i = 1; __i < state_size; ++__i)
+	{
+	  _UIntType __x = _M_x[__i - 1];
+	  __x ^= __x >> (__w - 2);
+	  __x *= 1812433253ul;
+	  __x += __i;
+	  _M_x[__i] = __detail::__mod<_UIntType, 1, 0,
+	    __detail::_Shift<_UIntType, __w>::__value>(__x);	  
+	}
+      _M_p = state_size;
+    }
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    template<class _Gen>
+      void
+      mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		       __b, __t, __c, __l>::
+      seed(_Gen& __gen, false_type)
+      {
+	for (int __i = 0; __i < state_size; ++__i)
+	  _M_x[__i] = __detail::__mod<_UIntType, 1, 0,
+	    __detail::_Shift<_UIntType, __w>::__value>(__gen());
+	_M_p = state_size;
+      }
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s,
+	   _UIntType __b, int __t, _UIntType __c, int __l>
+    typename
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::result_type
+    mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s,
+		     __b, __t, __c, __l>::
+    operator()()
+    {
+      // Reload the vector - cost is O(n) amortized over n calls.
+      if (_M_p >= state_size)
+	{
+	  const _UIntType __upper_mask = (~_UIntType()) << __r;
+	  const _UIntType __lower_mask = ~__upper_mask;
+
+	  for (int __k = 0; __k < (__n - __m); ++__k)
+	    {
+	      _UIntType __y = ((_M_x[__k] & __upper_mask)
+			       | (_M_x[__k + 1] & __lower_mask));
+	      _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
+			   ^ ((__y & 0x01) ? __a : 0));
+	    }
+
+	  for (int __k = (__n - __m); __k < (__n - 1); ++__k)
+	    {
+	      _UIntType __y = ((_M_x[__k] & __upper_mask)
+			       | (_M_x[__k + 1] & __lower_mask));
+	      _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
+			   ^ ((__y & 0x01) ? __a : 0));
+	    }
+
+	  _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
+			   | (_M_x[0] & __lower_mask));
+	  _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
+			   ^ ((__y & 0x01) ? __a : 0));
+	  _M_p = 0;
+	}
+
+      // Calculate o(x(i)).
+      result_type __z = _M_x[_M_p++];
+      __z ^= (__z >> __u);
+      __z ^= (__z << __s) & __b;
+      __z ^= (__z << __t) & __c;
+      __z ^= (__z >> __l);
+
+      return __z;
+    }
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
+	   _UIntType __c, int __l,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const mersenne_twister<_UIntType, __w, __n, __m,
+	       __r, __a, __u, __s, __b, __t, __c, __l>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      for (int __i = 0; __i < __n - 1; ++__i)
+	__os << __x._M_x[__i] << __space;
+      __os << __x._M_x[__n - 1];
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<class _UIntType, int __w, int __n, int __m, int __r,
+	   _UIntType __a, int __u, int __s, _UIntType __b, int __t,
+	   _UIntType __c, int __l,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       mersenne_twister<_UIntType, __w, __n, __m,
+	       __r, __a, __u, __s, __b, __t, __c, __l>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      for (int __i = 0; __i < __n; ++__i)
+	__is >> __x._M_x[__i];
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    const _IntType
+    subtract_with_carry<_IntType, __m, __s, __r>::modulus;
+
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    const int
+    subtract_with_carry<_IntType, __m, __s, __r>::long_lag;
+
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    const int
+    subtract_with_carry<_IntType, __m, __s, __r>::short_lag;
+
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    void
+    subtract_with_carry<_IntType, __m, __s, __r>::
+    seed(unsigned long __value)
+    {
+      if (__value == 0)
+	__value = 19780503;
+
+      std::tr1::linear_congruential<unsigned long, 40014, 0, 2147483563>
+	__lcg(__value);
+
+      for (int __i = 0; __i < long_lag; ++__i)
+	_M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__lcg());
+
+      _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
+      _M_p = 0;
+    }
+
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    template<class _Gen>
+      void
+      subtract_with_carry<_IntType, __m, __s, __r>::
+      seed(_Gen& __gen, false_type)
+      {
+	const int __n = (std::numeric_limits<_UIntType>::digits + 31) / 32;
+
+	for (int __i = 0; __i < long_lag; ++__i)
+	  {
+	    _UIntType __tmp = 0;
+	    _UIntType __factor = 1;
+	    for (int __j = 0; __j < __n; ++__j)
+	      {
+		__tmp += __detail::__mod<__detail::_UInt32Type, 1, 0, 0>
+		         (__gen()) * __factor;
+		__factor *= __detail::_Shift<_UIntType, 32>::__value;
+	      }
+	    _M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__tmp);
+	  }
+	_M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
+	_M_p = 0;
+      }
+
+  template<typename _IntType, _IntType __m, int __s, int __r>
+    typename subtract_with_carry<_IntType, __m, __s, __r>::result_type
+    subtract_with_carry<_IntType, __m, __s, __r>::
+    operator()()
+    {
+      // Derive short lag index from current index.
+      int __ps = _M_p - short_lag;
+      if (__ps < 0)
+	__ps += long_lag;
+
+      // Calculate new x(i) without overflow or division.
+      // NB: Thanks to the requirements for _IntType, _M_x[_M_p] + _M_carry
+      // cannot overflow.
+      _UIntType __xi;
+      if (_M_x[__ps] >= _M_x[_M_p] + _M_carry)
+	{
+	  __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry;
+	  _M_carry = 0;
+	}
+      else
+	{
+	  __xi = modulus - _M_x[_M_p] - _M_carry + _M_x[__ps];
+	  _M_carry = 1;
+	}
+      _M_x[_M_p] = __xi;
+
+      // Adjust current index to loop around in ring buffer.
+      if (++_M_p >= long_lag)
+	_M_p = 0;
+
+      return __xi;
+    }
+
+  template<typename _IntType, _IntType __m, int __s, int __r,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const subtract_with_carry<_IntType, __m, __s, __r>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      for (int __i = 0; __i < __r; ++__i)
+	__os << __x._M_x[__i] << __space;
+      __os << __x._M_carry;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _IntType, _IntType __m, int __s, int __r,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       subtract_with_carry<_IntType, __m, __s, __r>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      for (int __i = 0; __i < __r; ++__i)
+	__is >> __x._M_x[__i];
+      __is >> __x._M_carry;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType, int __w, int __s, int __r>
+    const int
+    subtract_with_carry_01<_RealType, __w, __s, __r>::word_size;
+
+  template<typename _RealType, int __w, int __s, int __r>
+    const int
+    subtract_with_carry_01<_RealType, __w, __s, __r>::long_lag;
+
+  template<typename _RealType, int __w, int __s, int __r>
+    const int
+    subtract_with_carry_01<_RealType, __w, __s, __r>::short_lag;
+
+  template<typename _RealType, int __w, int __s, int __r>
+    void
+    subtract_with_carry_01<_RealType, __w, __s, __r>::
+    _M_initialize_npows()
+    {
+      for (int __j = 0; __j < __n; ++__j)
+#if _GLIBCXX_USE_C99_MATH_TR1
+	_M_npows[__j] = std::tr1::ldexp(_RealType(1), -__w + __j * 32);
+#else
+        _M_npows[__j] = std::pow(_RealType(2), -__w + __j * 32);
+#endif
+    }
+
+  template<typename _RealType, int __w, int __s, int __r>
+    void
+    subtract_with_carry_01<_RealType, __w, __s, __r>::
+    seed(unsigned long __value)
+    {
+      if (__value == 0)
+	__value = 19780503;
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 512. Seeding subtract_with_carry_01 from a single unsigned long.
+      std::tr1::linear_congruential<unsigned long, 40014, 0, 2147483563>
+	__lcg(__value);
+
+      this->seed(__lcg);
+    }
+
+  template<typename _RealType, int __w, int __s, int __r>
+    template<class _Gen>
+      void
+      subtract_with_carry_01<_RealType, __w, __s, __r>::
+      seed(_Gen& __gen, false_type)
+      {
+	for (int __i = 0; __i < long_lag; ++__i)
+	  {
+	    for (int __j = 0; __j < __n - 1; ++__j)
+	      _M_x[__i][__j] = __detail::__mod<_UInt32Type, 1, 0, 0>(__gen());
+	    _M_x[__i][__n - 1] = __detail::__mod<_UInt32Type, 1, 0,
+	      __detail::_Shift<_UInt32Type, __w % 32>::__value>(__gen());
+	  }
+
+	_M_carry = 1;
+	for (int __j = 0; __j < __n; ++__j)
+	  if (_M_x[long_lag - 1][__j] != 0)
+	    {
+	      _M_carry = 0;
+	      break;
+	    }
+
+	_M_p = 0;
+      }
+
+  template<typename _RealType, int __w, int __s, int __r>
+    typename subtract_with_carry_01<_RealType, __w, __s, __r>::result_type
+    subtract_with_carry_01<_RealType, __w, __s, __r>::
+    operator()()
+    {
+      // Derive short lag index from current index.
+      int __ps = _M_p - short_lag;
+      if (__ps < 0)
+	__ps += long_lag;
+
+      _UInt32Type __new_carry;
+      for (int __j = 0; __j < __n - 1; ++__j)
+	{
+	  if (_M_x[__ps][__j] > _M_x[_M_p][__j]
+	      || (_M_x[__ps][__j] == _M_x[_M_p][__j] && _M_carry == 0))
+	    __new_carry = 0;
+	  else
+	    __new_carry = 1;
+
+	  _M_x[_M_p][__j] = _M_x[__ps][__j] - _M_x[_M_p][__j] - _M_carry;
+	  _M_carry = __new_carry;
+	}
+
+      if (_M_x[__ps][__n - 1] > _M_x[_M_p][__n - 1]
+	  || (_M_x[__ps][__n - 1] == _M_x[_M_p][__n - 1] && _M_carry == 0))
+	__new_carry = 0;
+      else
+	__new_carry = 1;
+      
+      _M_x[_M_p][__n - 1] = __detail::__mod<_UInt32Type, 1, 0,
+	__detail::_Shift<_UInt32Type, __w % 32>::__value>
+	(_M_x[__ps][__n - 1] - _M_x[_M_p][__n - 1] - _M_carry);
+      _M_carry = __new_carry;
+
+      result_type __ret = 0.0;
+      for (int __j = 0; __j < __n; ++__j)
+	__ret += _M_x[_M_p][__j] * _M_npows[__j];
+
+      // Adjust current index to loop around in ring buffer.
+      if (++_M_p >= long_lag)
+	_M_p = 0;
+
+      return __ret;
+    }
+
+  template<typename _RealType, int __w, int __s, int __r,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const subtract_with_carry_01<_RealType, __w, __s, __r>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      for (int __i = 0; __i < __r; ++__i)
+	for (int __j = 0; __j < __x.__n; ++__j)
+	  __os << __x._M_x[__i][__j] << __space;
+      __os << __x._M_carry;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _RealType, int __w, int __s, int __r,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       subtract_with_carry_01<_RealType, __w, __s, __r>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      for (int __i = 0; __i < __r; ++__i)
+	for (int __j = 0; __j < __x.__n; ++__j)
+	  __is >> __x._M_x[__i][__j];
+      __is >> __x._M_carry;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+  template<class _UniformRandomNumberGenerator, int __p, int __r>
+    const int
+    discard_block<_UniformRandomNumberGenerator, __p, __r>::block_size;
+
+  template<class _UniformRandomNumberGenerator, int __p, int __r>
+    const int
+    discard_block<_UniformRandomNumberGenerator, __p, __r>::used_block;
+
+  template<class _UniformRandomNumberGenerator, int __p, int __r>
+    typename discard_block<_UniformRandomNumberGenerator,
+			   __p, __r>::result_type
+    discard_block<_UniformRandomNumberGenerator, __p, __r>::
+    operator()()
+    {
+      if (_M_n >= used_block)
+	{
+	  while (_M_n < block_size)
+	    {
+	      _M_b();
+	      ++_M_n;
+	    }
+	  _M_n = 0;
+	}
+      ++_M_n;
+      return _M_b();
+    }
+
+  template<class _UniformRandomNumberGenerator, int __p, int __r,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const discard_block<_UniformRandomNumberGenerator,
+	       __p, __r>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed
+		 | __ios_base::left);
+      __os.fill(__space);
+
+      __os << __x._M_b << __space << __x._M_n;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<class _UniformRandomNumberGenerator, int __p, int __r,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       discard_block<_UniformRandomNumberGenerator, __p, __r>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      __is >> __x._M_b >> __x._M_n;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2>
+    const int
+    xor_combine<_UniformRandomNumberGenerator1, __s1,
+		_UniformRandomNumberGenerator2, __s2>::shift1;
+     
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2>
+    const int
+    xor_combine<_UniformRandomNumberGenerator1, __s1,
+		_UniformRandomNumberGenerator2, __s2>::shift2;
+
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2>
+    void
+    xor_combine<_UniformRandomNumberGenerator1, __s1,
+		_UniformRandomNumberGenerator2, __s2>::
+    _M_initialize_max()
+    {
+      const int __w = std::numeric_limits<result_type>::digits;
+
+      const result_type __m1 =
+	std::min(result_type(_M_b1.max() - _M_b1.min()),
+		 __detail::_Shift<result_type, __w - __s1>::__value - 1);
+
+      const result_type __m2 =
+	std::min(result_type(_M_b2.max() - _M_b2.min()),
+		 __detail::_Shift<result_type, __w - __s2>::__value - 1);
+
+      // NB: In TR1 s1 is not required to be >= s2.
+      if (__s1 < __s2)
+	_M_max = _M_initialize_max_aux(__m2, __m1, __s2 - __s1) << __s1;
+      else
+	_M_max = _M_initialize_max_aux(__m1, __m2, __s1 - __s2) << __s2;
+    }
+
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2>
+    typename xor_combine<_UniformRandomNumberGenerator1, __s1,
+			 _UniformRandomNumberGenerator2, __s2>::result_type
+    xor_combine<_UniformRandomNumberGenerator1, __s1,
+		_UniformRandomNumberGenerator2, __s2>::
+    _M_initialize_max_aux(result_type __a, result_type __b, int __d)
+    {
+      const result_type __two2d = result_type(1) << __d;
+      const result_type __c = __a * __two2d;
+
+      if (__a == 0 || __b < __two2d)
+	return __c + __b;
+
+      const result_type __t = std::max(__c, __b);
+      const result_type __u = std::min(__c, __b);
+
+      result_type __ub = __u;
+      result_type __p;
+      for (__p = 0; __ub != 1; __ub >>= 1)
+	++__p;
+
+      const result_type __two2p = result_type(1) << __p;
+      const result_type __k = __t / __two2p;
+
+      if (__k & 1)
+	return (__k + 1) * __two2p - 1;
+
+      if (__c >= __b)
+	return (__k + 1) * __two2p + _M_initialize_max_aux((__t % __two2p)
+							   / __two2d,
+							   __u % __two2p, __d);
+      else
+	return (__k + 1) * __two2p + _M_initialize_max_aux((__u % __two2p)
+							   / __two2d,
+							   __t % __two2p, __d);
+    }
+
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const xor_combine<_UniformRandomNumberGenerator1, __s1,
+	       _UniformRandomNumberGenerator2, __s2>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
+      __os.fill(__space);
+
+      __os << __x.base1() << __space << __x.base2();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os; 
+    }
+
+  template<class _UniformRandomNumberGenerator1, int __s1,
+	   class _UniformRandomNumberGenerator2, int __s2,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       xor_combine<_UniformRandomNumberGenerator1, __s1,
+	       _UniformRandomNumberGenerator2, __s2>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      __is >> __x._M_b1 >> __x._M_b2;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename uniform_int<_IntType>::result_type
+      uniform_int<_IntType>::
+      _M_call(_UniformRandomNumberGenerator& __urng,
+	      result_type __min, result_type __max, true_type)
+      {
+	// XXX Must be fixed to work well for *arbitrary* __urng.max(),
+	// __urng.min(), __max, __min.  Currently works fine only in the
+	// most common case __urng.max() - __urng.min() >= __max - __min,
+	// with __urng.max() > __urng.min() >= 0.
+	typedef typename __gnu_cxx::__add_unsigned<typename
+	  _UniformRandomNumberGenerator::result_type>::__type __urntype;
+	typedef typename __gnu_cxx::__add_unsigned<result_type>::__type
+	                                                      __utype;
+	typedef typename __gnu_cxx::__conditional_type<(sizeof(__urntype)
+							> sizeof(__utype)),
+	  __urntype, __utype>::__type                         __uctype;
+
+	result_type __ret;
+
+	const __urntype __urnmin = __urng.min();
+	const __urntype __urnmax = __urng.max();
+	const __urntype __urnrange = __urnmax - __urnmin;
+	const __uctype __urange = __max - __min;
+	const __uctype __udenom = (__urnrange <= __urange
+				   ? 1 : __urnrange / (__urange + 1));
+	do
+	  __ret = (__urntype(__urng()) -  __urnmin) / __udenom;
+	while (__ret > __max - __min);
+
+	return __ret + __min;
+      }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const uniform_int<_IntType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+
+      __os << __x.min() << __space << __x.max();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      return __os;
+    }
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       uniform_int<_IntType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      __is >> __x._M_min >> __x._M_max;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+  
+  template<typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const bernoulli_distribution& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(__gnu_cxx::__numeric_traits<double>::__max_digits10);
+
+      __os << __x.p();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+
+  template<typename _IntType, typename _RealType>
+    template<class _UniformRandomNumberGenerator>
+      typename geometric_distribution<_IntType, _RealType>::result_type
+      geometric_distribution<_IntType, _RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	// About the epsilon thing see this thread:
+        // http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html
+	const _RealType __naf =
+	  (1 - std::numeric_limits<_RealType>::epsilon()) / 2;
+	// The largest _RealType convertible to _IntType.
+	const _RealType __thr =
+	  std::numeric_limits<_IntType>::max() + __naf;
+
+	_RealType __cand;
+	do
+	  __cand = std::ceil(std::log(__urng()) / _M_log_p);
+	while (__cand >= __thr);
+
+	return result_type(__cand + __naf);
+      }
+
+  template<typename _IntType, typename _RealType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const geometric_distribution<_IntType, _RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
+
+      __os << __x.p();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+
+  template<typename _IntType, typename _RealType>
+    void
+    poisson_distribution<_IntType, _RealType>::
+    _M_initialize()
+    {
+#if _GLIBCXX_USE_C99_MATH_TR1
+      if (_M_mean >= 12)
+	{
+	  const _RealType __m = std::floor(_M_mean);
+	  _M_lm_thr = std::log(_M_mean);
+	  _M_lfm = std::tr1::lgamma(__m + 1);
+	  _M_sm = std::sqrt(__m);
+
+	  const _RealType __pi_4 = 0.7853981633974483096156608458198757L;
+	  const _RealType __dx = std::sqrt(2 * __m * std::log(32 * __m
+							      / __pi_4));
+	  _M_d = std::tr1::round(std::max(_RealType(6),
+					  std::min(__m, __dx)));
+	  const _RealType __cx = 2 * __m + _M_d;
+	  _M_scx = std::sqrt(__cx / 2);
+	  _M_1cx = 1 / __cx;
+
+	  _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx);
+	  _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2)) / _M_d;
+	}
+      else
+#endif
+	_M_lm_thr = std::exp(-_M_mean);
+      }
+
+  /**
+   * A rejection algorithm when mean >= 12 and a simple method based
+   * upon the multiplication of uniform random variates otherwise.
+   * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
+   * is defined.
+   *
+   * Reference:
+   * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+   * New York, 1986, Ch. X, Sects. 3.3 & 3.4 (+ Errata!).
+   */
+  template<typename _IntType, typename _RealType>
+    template<class _UniformRandomNumberGenerator>
+      typename poisson_distribution<_IntType, _RealType>::result_type
+      poisson_distribution<_IntType, _RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+#if _GLIBCXX_USE_C99_MATH_TR1
+	if (_M_mean >= 12)
+	  {
+	    _RealType __x;
+
+	    // See comments above...
+	    const _RealType __naf =
+	      (1 - std::numeric_limits<_RealType>::epsilon()) / 2;
+	    const _RealType __thr =
+	      std::numeric_limits<_IntType>::max() + __naf;
+
+	    const _RealType __m = std::floor(_M_mean);
+	    // sqrt(pi / 2)
+	    const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
+	    const _RealType __c1 = _M_sm * __spi_2;
+	    const _RealType __c2 = _M_c2b + __c1; 
+	    const _RealType __c3 = __c2 + 1;
+	    const _RealType __c4 = __c3 + 1;
+	    // e^(1 / 78)
+	    const _RealType __e178 = 1.0129030479320018583185514777512983L;
+	    const _RealType __c5 = __c4 + __e178;
+	    const _RealType __c = _M_cb + __c5;
+	    const _RealType __2cx = 2 * (2 * __m + _M_d);
+
+	    bool __reject = true;
+	    do
+	      {
+		const _RealType __u = __c * __urng();
+		const _RealType __e = -std::log(__urng());
+
+		_RealType __w = 0.0;
+		
+		if (__u <= __c1)
+		  {
+		    const _RealType __n = _M_nd(__urng);
+		    const _RealType __y = -std::abs(__n) * _M_sm - 1;
+		    __x = std::floor(__y);
+		    __w = -__n * __n / 2;
+		    if (__x < -__m)
+		      continue;
+		  }
+		else if (__u <= __c2)
+		  {
+		    const _RealType __n = _M_nd(__urng);
+		    const _RealType __y = 1 + std::abs(__n) * _M_scx;
+		    __x = std::ceil(__y);
+		    __w = __y * (2 - __y) * _M_1cx;
+		    if (__x > _M_d)
+		      continue;
+		  }
+		else if (__u <= __c3)
+		  // NB: This case not in the book, nor in the Errata,
+		  // but should be ok...
+		  __x = -1;
+		else if (__u <= __c4)
+		  __x = 0;
+		else if (__u <= __c5)
+		  __x = 1;
+		else
+		  {
+		    const _RealType __v = -std::log(__urng());
+		    const _RealType __y = _M_d + __v * __2cx / _M_d;
+		    __x = std::ceil(__y);
+		    __w = -_M_d * _M_1cx * (1 + __y / 2);
+		  }
+
+		__reject = (__w - __e - __x * _M_lm_thr
+			    > _M_lfm - std::tr1::lgamma(__x + __m + 1));
+
+		__reject |= __x + __m >= __thr;
+
+	      } while (__reject);
+
+	    return result_type(__x + __m + __naf);
+	  }
+	else
+#endif
+	  {
+	    _IntType     __x = 0;
+	    _RealType __prod = 1.0;
+
+	    do
+	      {
+		__prod *= __urng();
+		__x += 1;
+	      }
+	    while (__prod > _M_lm_thr);
+
+	    return __x - 1;
+	  }
+      }
+
+  template<typename _IntType, typename _RealType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const poisson_distribution<_IntType, _RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
+
+      __os << __x.mean() << __space << __x._M_nd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _IntType, typename _RealType,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       poisson_distribution<_IntType, _RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      __is >> __x._M_mean >> __x._M_nd;
+      __x._M_initialize();
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _IntType, typename _RealType>
+    void
+    binomial_distribution<_IntType, _RealType>::
+    _M_initialize()
+    {
+      const _RealType __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
+
+      _M_easy = true;
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+      if (_M_t * __p12 >= 8)
+	{
+	  _M_easy = false;
+	  const _RealType __np = std::floor(_M_t * __p12);
+	  const _RealType __pa = __np / _M_t;
+	  const _RealType __1p = 1 - __pa;
+	  
+	  const _RealType __pi_4 = 0.7853981633974483096156608458198757L;
+	  const _RealType __d1x =
+	    std::sqrt(__np * __1p * std::log(32 * __np
+					     / (81 * __pi_4 * __1p)));
+	  _M_d1 = std::tr1::round(std::max(_RealType(1), __d1x));
+	  const _RealType __d2x =
+	    std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
+					     / (__pi_4 * __pa)));
+	  _M_d2 = std::tr1::round(std::max(_RealType(1), __d2x));
+	  
+	  // sqrt(pi / 2)
+	  const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
+	  _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np));
+	  _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p));
+	  _M_c = 2 * _M_d1 / __np;
+	  _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2;
+	  const _RealType __a12 = _M_a1 + _M_s2 * __spi_2;
+	  const _RealType __s1s = _M_s1 * _M_s1;
+	  _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p))
+			     * 2 * __s1s / _M_d1
+			     * std::exp(-_M_d1 * _M_d1 / (2 * __s1s)));
+	  const _RealType __s2s = _M_s2 * _M_s2;
+	  _M_s = (_M_a123 + 2 * __s2s / _M_d2
+		  * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
+	  _M_lf = (std::tr1::lgamma(__np + 1)
+		   + std::tr1::lgamma(_M_t - __np + 1));
+	  _M_lp1p = std::log(__pa / __1p);
+
+	  _M_q = -std::log(1 - (__p12 - __pa) / __1p);
+	}
+      else
+#endif
+	_M_q = -std::log(1 - __p12);
+    }
+
+  template<typename _IntType, typename _RealType>
+    template<class _UniformRandomNumberGenerator>
+      typename binomial_distribution<_IntType, _RealType>::result_type
+      binomial_distribution<_IntType, _RealType>::
+      _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t)
+      {
+	_IntType    __x = 0;
+	_RealType __sum = 0;
+
+	do
+	  {
+	    const _RealType __e = -std::log(__urng());
+	    __sum += __e / (__t - __x);
+	    __x += 1;
+	  }
+	while (__sum <= _M_q);
+
+	return __x - 1;
+      }
+
+  /**
+   * A rejection algorithm when t * p >= 8 and a simple waiting time
+   * method - the second in the referenced book - otherwise.
+   * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
+   * is defined.
+   *
+   * Reference:
+   * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+   * New York, 1986, Ch. X, Sect. 4 (+ Errata!).
+   */
+  template<typename _IntType, typename _RealType>
+    template<class _UniformRandomNumberGenerator>
+      typename binomial_distribution<_IntType, _RealType>::result_type
+      binomial_distribution<_IntType, _RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	result_type __ret;
+	const _RealType __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+	if (!_M_easy)
+	  {
+	    _RealType __x;
+
+	    // See comments above...
+	    const _RealType __naf =
+	      (1 - std::numeric_limits<_RealType>::epsilon()) / 2;
+	    const _RealType __thr =
+	      std::numeric_limits<_IntType>::max() + __naf;
+
+	    const _RealType __np = std::floor(_M_t * __p12);
+	    const _RealType __pa = __np / _M_t;
+
+	    // sqrt(pi / 2)
+	    const _RealType __spi_2 = 1.2533141373155002512078826424055226L;
+	    const _RealType __a1 = _M_a1;
+	    const _RealType __a12 = __a1 + _M_s2 * __spi_2;
+	    const _RealType __a123 = _M_a123;
+	    const _RealType __s1s = _M_s1 * _M_s1;
+	    const _RealType __s2s = _M_s2 * _M_s2;
+
+	    bool __reject;
+	    do
+	      {
+		const _RealType __u = _M_s * __urng();
+
+		_RealType __v;
+
+		if (__u <= __a1)
+		  {
+		    const _RealType __n = _M_nd(__urng);
+		    const _RealType __y = _M_s1 * std::abs(__n);
+		    __reject = __y >= _M_d1;
+		    if (!__reject)
+		      {
+			const _RealType __e = -std::log(__urng());
+			__x = std::floor(__y);
+			__v = -__e - __n * __n / 2 + _M_c;
+		      }
+		  }
+		else if (__u <= __a12)
+		  {
+		    const _RealType __n = _M_nd(__urng);
+		    const _RealType __y = _M_s2 * std::abs(__n);
+		    __reject = __y >= _M_d2;
+		    if (!__reject)
+		      {
+			const _RealType __e = -std::log(__urng());
+			__x = std::floor(-__y);
+			__v = -__e - __n * __n / 2;
+		      }
+		  }
+		else if (__u <= __a123)
+		  {
+		    const _RealType __e1 = -std::log(__urng());		    
+		    const _RealType __e2 = -std::log(__urng());
+
+		    const _RealType __y = _M_d1 + 2 * __s1s * __e1 / _M_d1;
+		    __x = std::floor(__y);
+		    __v = (-__e2 + _M_d1 * (1 / (_M_t - __np)
+					    -__y / (2 * __s1s)));
+		    __reject = false;
+		  }
+		else
+		  {
+		    const _RealType __e1 = -std::log(__urng());		    
+		    const _RealType __e2 = -std::log(__urng());
+
+		    const _RealType __y = _M_d2 + 2 * __s2s * __e1 / _M_d2;
+		    __x = std::floor(-__y);
+		    __v = -__e2 - _M_d2 * __y / (2 * __s2s);
+		    __reject = false;
+		  }
+
+		__reject = __reject || __x < -__np || __x > _M_t - __np;
+		if (!__reject)
+		  {
+		    const _RealType __lfx =
+		      std::tr1::lgamma(__np + __x + 1)
+		      + std::tr1::lgamma(_M_t - (__np + __x) + 1);
+		    __reject = __v > _M_lf - __lfx + __x * _M_lp1p;
+		  }
+
+		__reject |= __x + __np >= __thr;
+	      }
+	    while (__reject);
+
+	    __x += __np + __naf;
+
+	    const _IntType __z = _M_waiting(__urng, _M_t - _IntType(__x)); 
+	    __ret = _IntType(__x) + __z;
+	  }
+	else
+#endif
+	  __ret = _M_waiting(__urng, _M_t);
+
+	if (__p12 != _M_p)
+	  __ret = _M_t - __ret;
+	return __ret;
+      }
+
+  template<typename _IntType, typename _RealType,
+	   typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const binomial_distribution<_IntType, _RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
+
+      __os << __x.t() << __space << __x.p() 
+	   << __space << __x._M_nd;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _IntType, typename _RealType,
+	   typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       binomial_distribution<_IntType, _RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      __is >> __x._M_t >> __x._M_p >> __x._M_nd;
+      __x._M_initialize();
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const uniform_real<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
+
+      __os << __x.min() << __space << __x.max();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       uniform_real<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      __is >> __x._M_min >> __x._M_max;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const exponential_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
+
+      __os << __x.lambda();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+
+  /**
+   * Polar method due to Marsaglia.
+   *
+   * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+   * New York, 1986, Ch. V, Sect. 4.4.
+   */
+  template<typename _RealType>
+    template<class _UniformRandomNumberGenerator>
+      typename normal_distribution<_RealType>::result_type
+      normal_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	result_type __ret;
+
+	if (_M_saved_available)
+	  {
+	    _M_saved_available = false;
+	    __ret = _M_saved;
+	  }
+	else
+	  {
+	    result_type __x, __y, __r2;
+	    do
+	      {
+		__x = result_type(2.0) * __urng() - 1.0;
+		__y = result_type(2.0) * __urng() - 1.0;
+		__r2 = __x * __x + __y * __y;
+	      }
+	    while (__r2 > 1.0 || __r2 == 0.0);
+
+	    const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
+	    _M_saved = __x * __mult;
+	    _M_saved_available = true;
+	    __ret = __y * __mult;
+	  }
+	
+	__ret = __ret * _M_sigma + _M_mean;
+	return __ret;
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const normal_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      const _CharT __space = __os.widen(' ');
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__space);
+      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
+
+      __os << __x._M_saved_available << __space
+	   << __x.mean() << __space
+	   << __x.sigma();
+      if (__x._M_saved_available)
+	__os << __space << __x._M_saved;
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       normal_distribution<_RealType>& __x)
+    {
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      __is >> __x._M_saved_available >> __x._M_mean
+	   >> __x._M_sigma;
+      if (__x._M_saved_available)
+	__is >> __x._M_saved;
+
+      __is.flags(__flags);
+      return __is;
+    }
+
+
+  template<typename _RealType>
+    void
+    gamma_distribution<_RealType>::
+    _M_initialize()
+    {
+      if (_M_alpha >= 1)
+	_M_l_d = std::sqrt(2 * _M_alpha - 1);
+      else
+	_M_l_d = (std::pow(_M_alpha, _M_alpha / (1 - _M_alpha))
+		  * (1 - _M_alpha));
+    }
+
+  /**
+   * Cheng's rejection algorithm GB for alpha >= 1 and a modification
+   * of Vaduva's rejection from Weibull algorithm due to Devroye for
+   * alpha < 1.
+   *
+   * References:
+   * Cheng, R. C. The Generation of Gamma Random Variables with Non-integral
+   * Shape Parameter. Applied Statistics, 26, 71-75, 1977.
+   *
+   * Vaduva, I. Computer Generation of Gamma Gandom Variables by Rejection
+   * and Composition Procedures. Math. Operationsforschung and Statistik,
+   * Series in Statistics, 8, 545-576, 1977.
+   *
+   * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+   * New York, 1986, Ch. IX, Sect. 3.4 (+ Errata!).
+   */
+  template<typename _RealType>
+    template<class _UniformRandomNumberGenerator>
+      typename gamma_distribution<_RealType>::result_type
+      gamma_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng)
+      {
+	result_type __x;
+
+	bool __reject;
+	if (_M_alpha >= 1)
+	  {
+	    // alpha - log(4)
+	    const result_type __b = _M_alpha
+	      - result_type(1.3862943611198906188344642429163531L);
+	    const result_type __c = _M_alpha + _M_l_d;
+	    const result_type __1l = 1 / _M_l_d;
+
+	    // 1 + log(9 / 2)
+	    const result_type __k = 2.5040773967762740733732583523868748L;
+
+	    do
+	      {
+		const result_type __u = __urng();
+		const result_type __v = __urng();
+
+		const result_type __y = __1l * std::log(__v / (1 - __v));
+		__x = _M_alpha * std::exp(__y);
+
+		const result_type __z = __u * __v * __v;
+		const result_type __r = __b + __c * __y - __x;
+
+		__reject = __r < result_type(4.5) * __z - __k;
+		if (__reject)
+		  __reject = __r < std::log(__z);
+	      }
+	    while (__reject);
+	  }
+	else
+	  {
+	    const result_type __c = 1 / _M_alpha;
+
+	    do
+	      {
+		const result_type __z = -std::log(__urng());
+		const result_type __e = -std::log(__urng());
+
+		__x = std::pow(__z, __c);
+
+		__reject = __z + __e < _M_l_d + __x;
+	      }
+	    while (__reject);
+	  }
+
+	return __x;
+      }
+
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const gamma_distribution<_RealType>& __x)
+    {
+      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
+      typedef typename __ostream_type::ios_base    __ios_base;
+
+      const typename __ios_base::fmtflags __flags = __os.flags();
+      const _CharT __fill = __os.fill();
+      const std::streamsize __precision = __os.precision();
+      __os.flags(__ios_base::scientific | __ios_base::left);
+      __os.fill(__os.widen(' '));
+      __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10);
+
+      __os << __x.alpha();
+
+      __os.flags(__flags);
+      __os.fill(__fill);
+      __os.precision(__precision);
+      return __os;
+    }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/regex b/gcc-4.9/libstdc++-v3/include/tr1/regex
new file mode 100644
index 0000000..3cff23a
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/regex
@@ -0,0 +1,2730 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/**
+ * @file tr1/regex
+ * @author Stephen M. Webb  <stephen.webb@bregmasoft.ca>
+ * This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_REGEX
+#define _GLIBCXX_TR1_REGEX 1
+
+#pragma GCC system_header
+
+#include <algorithm>
+#include <bitset>
+#include <iterator>
+#include <locale>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <utility>
+#include <sstream>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+/**
+ * @defgroup tr1_regex Regular Expressions
+ * A facility for performing regular expression pattern matching.
+ */
+ //@{
+
+/** @namespace std::regex_constants
+ *  @brief ISO C++ 0x entities sub namespace for regex.
+ */
+namespace regex_constants
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @name 5.1 Regular Expression Syntax Options
+   */
+  //@{
+  enum __syntax_option
+    {
+      _S_icase,
+      _S_nosubs,
+      _S_optimize,
+      _S_collate,
+      _S_ECMAScript,
+      _S_basic,
+      _S_extended,
+      _S_awk,
+      _S_grep,
+      _S_egrep,
+      _S_syntax_last
+    };
+
+  /**
+   * @brief This is a bitmask type indicating how to interpret the regex.
+   *
+   * The @c syntax_option_type is implementation defined but it is valid to
+   * perform bitwise operations on these values and expect the right thing to
+   * happen.
+   *
+   * A valid value of type syntax_option_type shall have exactly one of the
+   * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
+   * %set.
+   */
+  typedef unsigned int syntax_option_type;
+
+  /** 
+   * Specifies that the matching of regular expressions against a character
+   * sequence shall be performed without regard to case.
+   */
+  static const syntax_option_type icase      = 1 << _S_icase;
+
+  /**
+   * Specifies that when a regular expression is matched against a character
+   * container sequence, no sub-expression matches are to be stored in the
+   * supplied match_results structure.
+   */
+  static const syntax_option_type nosubs     = 1 << _S_nosubs;
+
+  /**
+   * Specifies that the regular expression engine should pay more attention to
+   * the speed with which regular expressions are matched, and less to the
+   * speed with which regular expression objects are constructed. Otherwise
+   * it has no detectable effect on the program output.
+   */
+  static const syntax_option_type optimize   = 1 << _S_optimize;
+
+  /**
+   * Specifies that character ranges of the form [a-b] should be locale
+   * sensitive.
+   */
+  static const syntax_option_type collate    = 1 << _S_collate;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
+   * Language Specification, Standard Ecma-262, third edition, 1999], as
+   * modified in tr1 section [7.13].  This grammar is similar to that defined
+   * in the PERL scripting language but extended with elements found in the
+   * POSIX regular expression grammar.
+   */
+  static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
+   * Portable Operating System Interface (POSIX), Base Definitions and
+   * Headers, Section 9, Regular Expressions [IEEE, Information Technology --
+   * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+   */
+  static const syntax_option_type basic      = 1 << _S_basic;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
+   * Portable Operating System Interface (POSIX), Base Definitions and Headers,
+   * Section 9, Regular Expressions.
+   */
+  static const syntax_option_type extended   = 1 << _S_extended;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX utility awk in IEEE Std 1003.1-2001.  This option is
+   * identical to syntax_option_type extended, except that C-style escape
+   * sequences are supported.  These sequences are: 
+   * \\\\, \\a, \\b, \\f, 
+   * \\n, \\r, \\t , \\v, 
+   * \\&apos;, &apos;, and \\ddd 
+   * (where ddd is one, two, or three octal digits).  
+   */
+  static const syntax_option_type awk        = 1 << _S_awk;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX utility grep in IEEE Std 1003.1-2001.  This option is
+   * identical to syntax_option_type basic, except that newlines are treated
+   * as whitespace.
+   */
+  static const syntax_option_type grep       = 1 << _S_grep;
+
+  /**
+   * Specifies that the grammar recognized by the regular expression engine is
+   * that used by POSIX utility grep when given the -E option in
+   * IEEE Std 1003.1-2001.  This option is identical to syntax_option_type 
+   * extended, except that newlines are treated as whitespace.
+   */
+  static const syntax_option_type egrep      = 1 << _S_egrep;
+
+  //@}
+
+  /**
+   * @name 5.2 Matching Rules
+   *
+   * Matching a regular expression against a sequence of characters [first,
+   * last) proceeds according to the rules of the grammar specified for the
+   * regular expression object, modified according to the effects listed
+   * below for any bitmask elements set.
+   *
+   */
+  //@{
+
+  enum __match_flag
+    {
+      _S_not_bol,
+      _S_not_eol,
+      _S_not_bow,
+      _S_not_eow,
+      _S_any,
+      _S_not_null,
+      _S_continuous,
+      _S_prev_avail,
+      _S_sed,
+      _S_no_copy,
+      _S_first_only,
+      _S_match_flag_last
+    };
+
+  /**
+   * @brief This is a bitmask type indicating regex matching rules.
+   *
+   * The @c match_flag_type is implementation defined but it is valid to
+   * perform bitwise operations on these values and expect the right thing to
+   * happen.
+   */
+  typedef std::bitset<_S_match_flag_last> match_flag_type;
+
+  /**
+   * The default matching rules.
+   */
+  static const match_flag_type match_default     = 0;
+
+  /**
+   * The first character in the sequence [first, last) is treated as though it
+   * is not at the beginning of a line, so the character (^) in the regular
+   * expression shall not match [first, first).
+   */
+  static const match_flag_type match_not_bol     = 1 << _S_not_bol;
+
+  /**
+   * The last character in the sequence [first, last) is treated as though it
+   * is not at the end of a line, so the character ($) in the regular
+   * expression shall not match [last, last).
+   */
+  static const match_flag_type match_not_eol     = 1 << _S_not_eol;
+   
+  /**
+   * The expression \\b is not matched against the sub-sequence
+   * [first,first).
+   */
+  static const match_flag_type match_not_bow     = 1 << _S_not_bow;
+   
+  /**
+   * The expression \\b should not be matched against the sub-sequence
+   * [last,last).
+   */
+  static const match_flag_type match_not_eow     = 1 << _S_not_eow;
+   
+  /**
+   * If more than one match is possible then any match is an acceptable
+   * result.
+   */
+  static const match_flag_type match_any         = 1 << _S_any;
+   
+  /**
+   * The expression does not match an empty sequence.
+   */
+  static const match_flag_type match_not_null    = 1 << _S_not_null;
+   
+  /**
+   * The expression only matches a sub-sequence that begins at first .
+   */
+  static const match_flag_type match_continuous  = 1 << _S_continuous;
+   
+  /**
+   * --first is a valid iterator position.  When this flag is set then the
+   * flags match_not_bol and match_not_bow are ignored by the regular
+   * expression algorithms 7.11 and iterators 7.12.
+   */
+  static const match_flag_type match_prev_avail  = 1 << _S_prev_avail;
+
+  /**
+   * When a regular expression match is to be replaced by a new string, the
+   * new string is constructed using the rules used by the ECMAScript replace
+   * function in ECMA- 262 [Ecma International, ECMAScript Language
+   * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
+   * String.prototype.replace. In addition, during search and replace
+   * operations all non-overlapping occurrences of the regular expression
+   * are located and replaced, and sections of the input that did not match
+   * the expression are copied unchanged to the output string.
+   * 
+   * Format strings (from ECMA-262 [15.5.4.11]):
+   * @li $$  The dollar-sign itself ($)
+   * @li $&  The matched substring.
+   * @li $`  The portion of @a string that precedes the matched substring.
+   *         This would be match_results::prefix().
+   * @li $'  The portion of @a string that follows the matched substring.
+   *         This would be match_results::suffix().
+   * @li $n  The nth capture, where n is in [1,9] and $n is not followed by a
+   *         decimal digit.  If n <= match_results::size() and the nth capture
+   *         is undefined, use the empty string instead.  If n >
+   *         match_results::size(), the result is implementation-defined.
+   * @li $nn The nnth capture, where nn is a two-digit decimal number on
+   *         [01, 99].  If nn <= match_results::size() and the nth capture is
+   *         undefined, use the empty string instead. If
+   *         nn > match_results::size(), the result is implementation-defined.
+   */
+  static const match_flag_type format_default    = 0;
+
+  /**
+   * When a regular expression match is to be replaced by a new string, the
+   * new string is constructed using the rules used by the POSIX sed utility
+   * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
+   * Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
+   */
+  static const match_flag_type format_sed        = 1 << _S_sed;
+
+  /**
+   * During a search and replace operation, sections of the character
+   * container sequence being searched that do not match the regular
+   * expression shall not be copied to the output string.
+   */
+  static const match_flag_type format_no_copy    = 1 << _S_no_copy;
+
+  /**
+   * When specified during a search and replace operation, only the first
+   * occurrence of the regular expression shall be replaced.
+   */
+  static const match_flag_type format_first_only = 1 << _S_first_only;
+
+  //@}
+
+  /**
+   * @name 5.3 Error Types
+   */
+  //@{
+ 
+  enum error_type
+    {
+      _S_error_collate,
+      _S_error_ctype,
+      _S_error_escape,
+      _S_error_backref,
+      _S_error_brack,
+      _S_error_paren,
+      _S_error_brace,
+      _S_error_badbrace,
+      _S_error_range,
+      _S_error_space,
+      _S_error_badrepeat,
+      _S_error_complexity,
+      _S_error_stack,
+      _S_error_last
+    };
+
+  /** The expression contained an invalid collating element name. */
+  static const error_type error_collate(_S_error_collate);
+
+  /** The expression contained an invalid character class name. */
+  static const error_type error_ctype(_S_error_ctype);
+
+  /**
+   * The expression contained an invalid escaped character, or a trailing
+   * escape.
+   */
+  static const error_type error_escape(_S_error_escape);
+
+  /** The expression contained an invalid back reference. */
+  static const error_type error_backref(_S_error_backref);
+
+  /** The expression contained mismatched [ and ]. */
+  static const error_type error_brack(_S_error_brack);
+
+  /** The expression contained mismatched ( and ). */
+  static const error_type error_paren(_S_error_paren);
+
+  /** The expression contained mismatched { and } */
+  static const error_type error_brace(_S_error_brace);
+
+  /** The expression contained an invalid range in a {} expression. */
+  static const error_type error_badbrace(_S_error_badbrace);
+
+  /**
+   * The expression contained an invalid character range,
+   * such as [b-a] in most encodings.
+   */
+  static const error_type error_range(_S_error_range);
+
+  /**
+   * There was insufficient memory to convert the expression into a
+   * finite state machine.
+   */
+  static const error_type error_space(_S_error_space);
+
+  /**
+   * One of <em>*?+{</em> was not preceded by a valid regular expression.
+   */
+  static const error_type error_badrepeat(_S_error_badrepeat);
+
+  /**
+   * The complexity of an attempted match against a regular expression
+   * exceeded a pre-set level.
+   */
+  static const error_type error_complexity(_S_error_complexity);
+
+  /**
+   * There was insufficient memory to determine whether the
+   * regular expression could match the specified character sequence.
+   */
+  static const error_type error_stack(_S_error_stack);
+
+  //@}
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // [7.8] Class regex_error
+  /**
+   *  @brief A regular expression exception class.
+   *  @ingroup exceptions
+   *
+   *  The regular expression library throws objects of this class on error.
+   */
+  class regex_error
+  : public std::runtime_error
+  {
+  public:
+    /**
+     * @brief Constructs a regex_error object.
+     *
+     * @param ecode the regex error code.
+     */
+    explicit
+    regex_error(regex_constants::error_type __ecode)
+    : std::runtime_error("regex_error"), _M_code(__ecode)
+    { }
+
+    /**
+     * @brief Gets the regex error code.
+     *
+     * @returns the regex error code.
+     */
+    regex_constants::error_type
+    code() const
+    { return _M_code; }
+
+  protected:
+    regex_constants::error_type _M_code;
+  };
+
+  // [7.7] Class regex_traits
+  /**
+   * @brief Describes aspects of a regular expression.
+   *
+   * A regular expression traits class that satisfies the requirements of tr1
+   * section [7.2].
+   *
+   * The class %regex is parameterized around a set of related types and
+   * functions used to complete the definition of its semantics.  This class
+   * satisfies the requirements of such a traits class.
+   */
+  template<typename _Ch_type>
+    struct regex_traits
+    {
+    public:
+      typedef _Ch_type                     char_type;
+      typedef std::basic_string<char_type> string_type;
+      typedef std::locale                  locale_type;
+      typedef std::ctype_base::mask        char_class_type;
+
+    public:
+      /**
+       * @brief Constructs a default traits object.
+       */
+      regex_traits()
+      { }
+      
+      /**
+       * @brief Gives the length of a C-style string starting at @p __p.
+       *
+       * @param __p a pointer to the start of a character sequence.
+       *
+       * @returns the number of characters between @p *__p and the first
+       * default-initialized value of type @p char_type.  In other words, uses
+       * the C-string algorithm for determining the length of a sequence of
+       * characters.
+       */
+      static std::size_t
+      length(const char_type* __p)
+      { return string_type::traits_type::length(__p); }
+
+      /**
+       * @brief Performs the identity translation.
+       *
+       * @param c A character to the locale-specific character set.
+       *
+       * @returns c.
+       */
+      char_type
+      translate(char_type __c) const
+      { return __c; }
+      
+      /**
+       * @brief Translates a character into a case-insensitive equivalent.
+       *
+       * @param c A character to the locale-specific character set.
+       *
+       * @returns the locale-specific lower-case equivalent of c.
+       * @throws std::bad_cast if the imbued locale does not support the ctype
+       *         facet.
+       */
+      char_type
+      translate_nocase(char_type __c) const
+      {
+	using std::ctype;
+	using std::use_facet;
+	return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
+      }
+      
+      /**
+       * @brief Gets a sort key for a character sequence.
+       *
+       * @param first beginning of the character sequence.
+       * @param last  one-past-the-end of the character sequence.
+       *
+       * Returns a sort key for the character sequence designated by the
+       * iterator range [F1, F2) such that if the character sequence [G1, G2)
+       * sorts before the character sequence [H1, H2) then
+       * v.transform(G1, G2) < v.transform(H1, H2).
+       *
+       * What this really does is provide a more efficient way to compare a
+       * string to multiple other strings in locales with fancy collation
+       * rules and equivalence classes.
+       *
+       * @returns a locale-specific sort key equivalent to the input range.
+       *
+       * @throws std::bad_cast if the current locale does not have a collate
+       *         facet.
+       */
+      template<typename _Fwd_iter>
+        string_type
+        transform(_Fwd_iter __first, _Fwd_iter __last) const
+        {
+	  using std::collate;
+	  using std::use_facet;
+	  const collate<_Ch_type>& __c(use_facet<
+				       collate<_Ch_type> >(_M_locale));
+	  string_type __s(__first, __last);
+	  return __c.transform(__s.data(), __s.data() + __s.size());
+	}
+
+      /**
+       * @brief Dunno.
+       *
+       * @param first beginning of the character sequence.
+       * @param last  one-past-the-end of the character sequence.
+       *
+       * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
+       * typeid(collate_byname<_Ch_type>) and the form of the sort key
+       * returned by collate_byname<_Ch_type>::transform(first, last) is known
+       * and can be converted into a primary sort key then returns that key,
+       * otherwise returns an empty string. WTF??
+       *
+       * @todo Implement this function.
+       */
+      template<typename _Fwd_iter>
+        string_type
+        transform_primary(_Fwd_iter __first, _Fwd_iter __last) const;
+
+      /**
+       * @brief Gets a collation element by name.
+       *
+       * @param first beginning of the collation element name.
+       * @param last  one-past-the-end of the collation element name.
+       * 
+       * @returns a sequence of one or more characters that represents the
+       * collating element consisting of the character sequence designated by
+       * the iterator range [first, last). Returns an empty string if the
+       * character sequence is not a valid collating element.
+       *
+       * @todo Implement this function.
+       */
+      template<typename _Fwd_iter>
+        string_type
+        lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
+
+      /**
+       * @brief Maps one or more characters to a named character
+       *        classification.
+       *
+       * @param first beginning of the character sequence.
+       * @param last  one-past-the-end of the character sequence.
+       *
+       * @returns an unspecified value that represents the character
+       * classification named by the character sequence designated by the
+       * iterator range [first, last). The value returned shall be independent
+       * of the case of the characters in the character sequence. If the name
+       * is not recognized then returns a value that compares equal to 0.
+       *
+       * At least the following names (or their wide-character equivalent) are
+       * supported.
+       * - d
+       * - w
+       * - s
+       * - alnum
+       * - alpha
+       * - blank
+       * - cntrl
+       * - digit
+       * - graph
+       * - lower
+       * - print
+       * - punct
+       * - space
+       * - upper
+       * - xdigit
+       *
+       * @todo Implement this function.
+       */
+      template<typename _Fwd_iter>
+        char_class_type
+        lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const;
+
+      /**
+       * @brief Determines if @p c is a member of an identified class.
+       *
+       * @param c a character.
+       * @param f a class type (as returned from lookup_classname).
+       *
+       * @returns true if the character @p c is a member of the classification
+       * represented by @p f, false otherwise.
+       *
+       * @throws std::bad_cast if the current locale does not have a ctype
+       *         facet.
+       */
+      bool
+      isctype(_Ch_type __c, char_class_type __f) const;
+
+      /**
+       * @brief Converts a digit to an int.
+       *
+       * @param ch    a character representing a digit.
+       * @param radix the radix if the numeric conversion (limited to 8, 10,
+       *              or 16).
+       * 
+       * @returns the value represented by the digit ch in base radix if the
+       * character ch is a valid digit in base radix; otherwise returns -1.
+       */
+      int
+      value(_Ch_type __ch, int __radix) const;
+      
+      /**
+       * @brief Imbues the regex_traits object with a copy of a new locale.
+       *
+       * @param loc A locale.
+       *
+       * @returns a copy of the previous locale in use by the regex_traits
+       *          object.
+       *
+       * @note Calling imbue with a different locale than the one currently in
+       *       use invalidates all cached data held by *this.
+       */
+      locale_type
+      imbue(locale_type __loc)
+      {
+	std::swap(_M_locale, __loc);
+	return __loc;
+      }
+      
+      /**
+       * @brief Gets a copy of the current locale in use by the regex_traits
+       * object.
+       */
+      locale_type
+      getloc() const
+      { return _M_locale; }
+      
+    protected:
+      locale_type _M_locale;
+    };
+
+  template<typename _Ch_type>
+    bool regex_traits<_Ch_type>::
+    isctype(_Ch_type __c, char_class_type __f) const
+    {
+      using std::ctype;
+      using std::use_facet;
+      const ctype<_Ch_type>& __ctype(use_facet<
+				     ctype<_Ch_type> >(_M_locale));
+      
+      if (__ctype.is(__c, __f))
+	return true;
+      
+      // special case of underscore in [[:w:]]
+      if (__c == __ctype.widen('_'))
+	{
+	  const char* const __wb[] = "w";
+	  char_class_type __wt = this->lookup_classname(__wb,
+							__wb + sizeof(__wb));
+	  if (__f | __wt)
+	    return true;
+	}
+    
+      // special case of [[:space:]] in [[:blank:]]
+      if (__c == __ctype.isspace(__c))
+	{
+	  const char* const __bb[] = "blank";
+	  char_class_type __bt = this->lookup_classname(__bb,
+							__bb + sizeof(__bb));
+	  if (__f | __bt)
+	    return true;
+	}
+      
+      return false;
+    }
+
+  template<typename _Ch_type>
+    int regex_traits<_Ch_type>::
+    value(_Ch_type __ch, int __radix) const
+    {
+      std::basic_istringstream<_Ch_type> __is(string_type(1, __ch));
+      int __v;
+      if (__radix == 8)
+	__is >> std::oct;
+      else if (__radix == 16)
+	__is >> std::hex;
+      __is >> __v;
+      return __is.fail() ? -1 : __v;
+    }
+
+  // [7.8] Class basic_regex
+  /**
+   * Objects of specializations of this class represent regular expressions
+   * constructed from sequences of character type @p _Ch_type.
+   *
+   * Storage for the regular expression is allocated and deallocated as
+   * necessary by the member functions of this class.
+   */
+  template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
+    class basic_regex
+    {
+    public:
+      // types:
+      typedef _Ch_type                              value_type;
+      typedef regex_constants::syntax_option_type flag_type;
+      typedef typename _Rx_traits::locale_type  locale_type;
+      typedef typename _Rx_traits::string_type  string_type;
+
+      /**
+       * @name Constants
+       * tr1 [7.8.1] std [28.8.1]
+       */
+      //@{
+      static const regex_constants::syntax_option_type icase
+        = regex_constants::icase;
+      static const regex_constants::syntax_option_type nosubs
+        = regex_constants::nosubs;
+      static const regex_constants::syntax_option_type optimize
+        = regex_constants::optimize;
+      static const regex_constants::syntax_option_type collate
+        = regex_constants::collate;
+      static const regex_constants::syntax_option_type ECMAScript
+        = regex_constants::ECMAScript;
+      static const regex_constants::syntax_option_type basic
+        = regex_constants::basic;
+      static const regex_constants::syntax_option_type extended
+        = regex_constants::extended;
+      static const regex_constants::syntax_option_type awk
+        = regex_constants::awk;
+      static const regex_constants::syntax_option_type grep
+        = regex_constants::grep;
+      static const regex_constants::syntax_option_type egrep
+        = regex_constants::egrep;
+      //@}
+
+      // [7.8.2] construct/copy/destroy
+      /**
+       * Constructs a basic regular expression that does not match any
+       * character sequence.
+       */
+      basic_regex()
+      : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
+      { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the sequence
+       * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
+       * flags in @p f.
+       *
+       * @param p A pointer to the start of a C-style null-terminated string
+       *          containing a regular expression.
+       * @param f Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p p is not a valid regular expression.
+       */
+      explicit
+      basic_regex(const _Ch_type* __p,
+		  flag_type __f = regex_constants::ECMAScript)
+      : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
+      { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the sequence
+       * [p, p + len) interpreted according to the flags in @p f.
+       *
+       * @param p   A pointer to the start of a string containing a regular
+       *            expression.
+       * @param len The length of the string containing the regular expression.
+       * @param f   Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p p is not a valid regular expression.
+       */
+      basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
+      : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
+      { _M_compile(); }
+
+      /**
+       * @brief Copy-constructs a basic regular expression.
+       *
+       * @param rhs A @p regex object.
+     */
+      basic_regex(const basic_regex& __rhs)
+      : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
+	_M_mark_count(__rhs._M_mark_count)
+      { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the string
+       * @p s interpreted according to the flags in @p f.
+       *
+       * @param s A string containing a regular expression.
+       * @param f Flags indicating the syntax rules and options.
+       *
+       * @throws regex_error if @p s is not a valid regular expression.
+       */
+      template<typename _Ch_traits, typename _Ch_alloc>
+        explicit
+        basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		    flag_type __f = regex_constants::ECMAScript)
+	: _M_flags(__f), _M_pattern(__s.begin(), __s.end()), _M_mark_count(0)
+        { _M_compile(); }
+
+      /**
+       * @brief Constructs a basic regular expression from the range
+       * [first, last) interpreted according to the flags in @p f.
+       *
+       * @param first The start of a range containing a valid regular
+       *              expression.
+       * @param last  The end of a range containing a valid regular
+       *              expression.
+       * @param f     The format flags of the regular expression.
+       *
+       * @throws regex_error if @p [first, last) is not a valid regular
+       *         expression.
+       */
+      template<typename _InputIterator>
+        basic_regex(_InputIterator __first, _InputIterator __last, 
+		    flag_type __f = regex_constants::ECMAScript)
+	: _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
+        { _M_compile(); }
+
+#ifdef _GLIBCXX_INCLUDE_AS_CXX11
+      /**
+       * @brief Constructs a basic regular expression from an initializer list.
+       *
+       * @param l  The initializer list.
+       * @param f  The format flags of the regular expression.
+       *
+       * @throws regex_error if @p l is not a valid regular expression.
+       */
+      basic_regex(initializer_list<_Ch_type> __l,
+		  flag_type __f = regex_constants::ECMAScript)
+	: _M_flags(__f), _M_pattern(__l.begin(), __l.end()), _M_mark_count(0)
+        { _M_compile(); }
+#endif
+
+      /**
+       * @brief Destroys a basic regular expression.
+       */
+      ~basic_regex()
+      { }
+      
+      /**
+       * @brief Assigns one regular expression to another.
+       */
+      basic_regex&
+      operator=(const basic_regex& __rhs)
+      { return this->assign(__rhs); }
+
+      /**
+       * @brief Replaces a regular expression with a new one constructed from
+       * a C-style null-terminated string.
+       *
+       * @param A pointer to the start of a null-terminated C-style string
+       *        containing a regular expression.
+       */
+      basic_regex&
+      operator=(const _Ch_type* __p)
+      { return this->assign(__p, flags()); }
+      
+      /**
+       * @brief Replaces a regular expression with a new one constructed from
+       * a string.
+       *
+       * @param A pointer to a string containing a regular expression.
+       */
+      template<typename _Ch_typeraits, typename _Allocator>
+        basic_regex&
+        operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
+        { return this->assign(__s, flags()); }
+
+      // [7.8.3] assign
+      /**
+       * @brief the real assignment operator.
+       *
+       * @param that Another regular expression object.
+       */
+      basic_regex&
+      assign(const basic_regex& __that)
+      {
+	basic_regex __tmp(__that);
+	this->swap(__tmp);
+	return *this;
+      }
+      
+      /**
+       * @brief Assigns a new regular expression to a regex object from a
+       * C-style null-terminated string containing a regular expression
+       * pattern.
+       *
+       * @param p     A pointer to a C-style null-terminated string containing
+       *              a regular expression pattern.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * *this remains unchanged.
+       */
+      basic_regex&
+      assign(const _Ch_type* __p,
+	     flag_type __flags = regex_constants::ECMAScript)
+      { return this->assign(string_type(__p), __flags); }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object from a
+       * C-style string containing a regular expression pattern.
+       *
+       * @param p     A pointer to a C-style string containing a
+       *              regular expression pattern.
+       * @param len   The length of the regular expression pattern string.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * *this remains unchanged.
+       */
+      basic_regex&
+      assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
+      { return this->assign(string_type(__p, __len), __flags); }
+
+      /**
+       * @brief Assigns a new regular expression to a regex object from a 
+       * string containing a regular expression pattern.
+       *
+       * @param s     A string containing a regular expression pattern.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * *this remains unchanged.
+       */
+      template<typename _Ch_typeraits, typename _Allocator>
+        basic_regex&
+        assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
+	       flag_type __f = regex_constants::ECMAScript)
+        { 
+	  basic_regex __tmp(__s, __f);
+	  this->swap(__tmp);
+	  return *this;
+	}
+
+      /**
+       * @brief Assigns a new regular expression to a regex object.
+       *
+       * @param first The start of a range containing a valid regular
+       *              expression.
+       * @param last  The end of a range containing a valid regular
+       *              expression.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if p does not contain a valid regular expression
+       * pattern interpreted according to @p flags.  If regex_error is thrown,
+       * the object remains unchanged.
+       */
+      template<typename _InputIterator>
+        basic_regex&
+        assign(_InputIterator __first, _InputIterator __last,
+	       flag_type __flags = regex_constants::ECMAScript)
+        { return this->assign(string_type(__first, __last), __flags); }
+
+#ifdef _GLIBCXX_INCLUDE_AS_CXX11
+      /**
+       * @brief Assigns a new regular expression to a regex object.
+       *
+       * @param l     An initializer list representing a regular expression.
+       * @param flags Syntax option flags.
+       *
+       * @throws regex_error if @p l does not contain a valid regular
+       * expression pattern interpreted according to @p flags.  If regex_error
+       * is thrown, the object remains unchanged.
+       */
+      basic_regex&
+      assign(initializer_list<_Ch_type> __l,
+	     flag_type __f = regex_constants::ECMAScript)
+      { return this->assign(__l.begin(), __l.end(), __f); }
+#endif
+
+      // [7.8.4] const operations
+      /**
+       * @brief Gets the number of marked subexpressions within the regular
+       * expression.
+       */
+      unsigned int
+      mark_count() const
+      { return _M_mark_count; }
+      
+      /**
+       * @brief Gets the flags used to construct the regular expression
+       * or in the last call to assign().
+       */
+      flag_type
+      flags() const
+      { return _M_flags; }
+      
+      // [7.8.5] locale
+      /**
+       * @brief Imbues the regular expression object with the given locale.
+       *
+       * @param loc A locale.
+       */
+      locale_type
+      imbue(locale_type __loc)
+      { return _M_traits.imbue(__loc); }
+      
+      /**
+       * @brief Gets the locale currently imbued in the regular expression
+       *        object.
+       */
+      locale_type
+      getloc() const
+      { return _M_traits.getloc(); }
+      
+      // [7.8.6] swap
+      /**
+       * @brief Swaps the contents of two regular expression objects.
+       *
+       * @param rhs Another regular expression object.
+       */
+      void
+      swap(basic_regex& __rhs)
+      {
+	std::swap(_M_flags,      __rhs._M_flags);
+	std::swap(_M_pattern,    __rhs._M_pattern);
+	std::swap(_M_mark_count, __rhs._M_mark_count);
+	std::swap(_M_traits,     __rhs._M_traits);
+      }
+      
+    private:
+      /**
+       * @brief Compiles a regular expression pattern into a NFA.
+       * @todo Implement this function.
+       */
+      void _M_compile();
+
+    protected:
+      flag_type    _M_flags;
+      string_type  _M_pattern;
+      unsigned int _M_mark_count;
+      _Rx_traits   _M_traits;
+    };
+  
+  /** @brief Standard regular expressions. */
+  typedef basic_regex<char>    regex;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /** @brief Standard wide-character regular expressions. */
+  typedef basic_regex<wchar_t> wregex;
+#endif
+
+
+  // [7.8.6] basic_regex swap
+  /**
+   * @brief Swaps the contents of two regular expression objects.
+   * @param lhs First regular expression.
+   * @param rhs Second regular expression.
+   */
+  template<typename _Ch_type, typename _Rx_traits>
+    inline void
+    swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
+	 basic_regex<_Ch_type, _Rx_traits>& __rhs)
+    { __lhs.swap(__rhs); }
+
+
+  // [7.9] Class template sub_match
+  /**
+   * A sequence of characters matched by a particular marked sub-expression.
+   *
+   * An object of this class is essentially a pair of iterators marking a
+   * matched subexpression within a regular expression pattern match. Such
+   * objects can be converted to and compared with std::basic_string objects
+   * of a similar base character type as the pattern matched by the regular
+   * expression.
+   *
+   * The iterators that make up the pair are the usual half-open interval
+   * referencing the actual original pattern matched.
+   */
+  template<typename _BiIter>
+    class sub_match : public std::pair<_BiIter, _BiIter>
+    {
+    public:
+      typedef typename iterator_traits<_BiIter>::value_type      value_type;
+      typedef typename iterator_traits<_BiIter>::difference_type
+                                                            difference_type;
+      typedef _BiIter                                              iterator;
+
+    public:
+      bool matched;
+      
+      /**
+       * Gets the length of the matching sequence.
+       */
+      difference_type
+      length() const
+      { return this->matched ? std::distance(this->first, this->second) : 0; }
+
+      /**
+       * @brief Gets the matching sequence as a string.
+       *
+       * @returns the matching sequence as a string.
+       *
+       * This is the implicit conversion operator.  It is identical to the
+       * str() member function except that it will want to pop up in
+       * unexpected places and cause a great deal of confusion and cursing
+       * from the unwary.
+       */
+      operator basic_string<value_type>() const
+      {
+	return this->matched
+	  ? std::basic_string<value_type>(this->first, this->second)
+	  : std::basic_string<value_type>();
+      }
+      
+      /**
+       * @brief Gets the matching sequence as a string.
+       *
+       * @returns the matching sequence as a string.
+       */
+      basic_string<value_type>
+      str() const
+      {
+	return this->matched
+	  ? std::basic_string<value_type>(this->first, this->second)
+	  : std::basic_string<value_type>();
+      }
+      
+      /**
+       * @brief Compares this and another matched sequence.
+       *
+       * @param s Another matched sequence to compare to this one.
+       *
+       * @retval <0 this matched sequence will collate before @p s.
+       * @retval =0 this matched sequence is equivalent to @p s.
+       * @retval <0 this matched sequence will collate after @p s.
+       */
+      int
+      compare(const sub_match& __s) const
+      { return this->str().compare(__s.str()); }
+
+      /**
+       * @brief Compares this sub_match to a string.
+       *
+       * @param s A string to compare to this sub_match.
+       *
+       * @retval <0 this matched sequence will collate before @p s.
+       * @retval =0 this matched sequence is equivalent to @p s.
+       * @retval <0 this matched sequence will collate after @p s.
+       */
+      int
+      compare(const basic_string<value_type>& __s) const
+      { return this->str().compare(__s); }
+      
+      /**
+       * @brief Compares this sub_match to a C-style string.
+       *
+       * @param s A C-style string to compare to this sub_match.
+       *
+       * @retval <0 this matched sequence will collate before @p s.
+       * @retval =0 this matched sequence is equivalent to @p s.
+       * @retval <0 this matched sequence will collate after @p s.
+       */
+      int
+      compare(const value_type* __s) const
+      { return this->str().compare(__s); }
+    };
+  
+  
+  /** @brief Standard regex submatch over a C-style null-terminated string. */
+  typedef sub_match<const char*>             csub_match;
+  /** @brief Standard regex submatch over a standard string. */
+  typedef sub_match<string::const_iterator>  ssub_match;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /** @brief Regex submatch over a C-style null-terminated wide string. */
+  typedef sub_match<const wchar_t*>          wcsub_match;
+  /** @brief Regex submatch over a standard wide string. */
+  typedef sub_match<wstring::const_iterator> wssub_match;
+#endif
+
+  // [7.9.2] sub_match non-member operators
+  
+  /**
+   * @brief Tests the equivalence of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator==(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  /**
+   * @brief Tests the inequivalence of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator!=(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) != 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator<(const sub_match<_BiIter>& __lhs,
+	      const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator<=(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator>=(const sub_match<_BiIter>& __lhs,
+	       const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+  /**
+   * @brief Tests the ordering of two regular expression submatches.
+   * @param lhs First regular expression submatch.
+   * @param rhs Second regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _BiIter>
+    inline bool
+    operator>(const sub_match<_BiIter>& __lhs,
+	      const sub_match<_BiIter>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+  /**
+   * @brief Tests the equivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator==(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs == __rhs.str(); }
+
+  /**
+   * @brief Tests the inequivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs  is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator!=(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs != __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator<(const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type,
+	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+     { return __lhs < __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator>(const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type, 
+	      _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs > __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator>=(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs >= __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator<=(const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
+    { return __lhs <= __rhs.str(); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() == __rhs; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() != __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type,
+	      _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() < __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      const basic_string<
+	      typename iterator_traits<_Bi_iter>::value_type,
+	      _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() > __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() >= __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       const basic_string<
+	       typename iterator_traits<_Bi_iter>::value_type,
+	       _Ch_traits, _Ch_alloc>& __rhs)
+    { return __lhs.str() <= __rhs; }
+
+  /**
+   * @brief Tests the equivalence of a C string and a regular expression
+   *        submatch.
+   * @param lhs A C string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs == __rhs.str(); }
+
+  /**
+   * @brief Tests the inequivalence of an iterator value and a regular
+   *        expression submatch.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs != __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs < __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs > __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs >= __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs <= __rhs.str(); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A pointer to a string?
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() == __rhs; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A pointer to a string.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() != __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() < __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() > __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() >= __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A string.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const* __rhs)
+    { return __lhs.str() <= __rhs; }
+
+  /**
+   * @brief Tests the equivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs == __rhs.str(); }
+
+  /**
+   * @brief Tests the inequivalence of a string and a regular expression
+   *        submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs != __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs < __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	      const sub_match<_Bi_iter>& __rhs)
+    { return __lhs > __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs >= __rhs.str(); }
+
+  /**
+   * @brief Tests the ordering of a string and a regular expression submatch.
+   * @param lhs A string.
+   * @param rhs A regular expression submatch.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
+	       const sub_match<_Bi_iter>& __rhs)
+    { return __lhs <= __rhs.str(); }
+
+  /**
+   * @brief Tests the equivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs  is equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator==(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() == __rhs; }
+
+  /**
+   * @brief Tests the inequivalence of a regular expression submatch and a
+   *        string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator!=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() != __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs precedes @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() < __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs succeeds @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>(const sub_match<_Bi_iter>& __lhs,
+	      typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() > __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs does not precede @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator>=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() >= __rhs; }
+
+  /**
+   * @brief Tests the ordering of a regular expression submatch and a string.
+   * @param lhs A regular expression submatch.
+   * @param rhs A const string reference.
+   * @returns true if @a lhs does not succeed @a rhs, false otherwise.
+   */
+  template<typename _Bi_iter>
+    inline bool
+    operator<=(const sub_match<_Bi_iter>& __lhs,
+	       typename iterator_traits<_Bi_iter>::value_type const& __rhs)
+    { return __lhs.str() <= __rhs; }
+
+  /**
+   * @brief Inserts a matched string into an output stream.
+   *
+   * @param os The output stream.
+   * @param m  A submatch string.
+   *
+   * @returns the output stream with the submatch string inserted.
+   */
+  template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
+    inline
+    basic_ostream<_Ch_type, _Ch_traits>&
+    operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
+	       const sub_match<_Bi_iter>& __m)
+    { return __os << __m.str(); }
+
+  // [7.10] Class template match_results
+  /**
+   * @brief The results of a match or search operation.
+   *
+   * A collection of character sequences representing the result of a regular
+   * expression match.  Storage for the collection is allocated and freed as
+   * necessary by the member functions of class template match_results.
+   *
+   * This class satisfies the Sequence requirements, with the exception that
+   * only the operations defined for a const-qualified Sequence are supported.
+   *
+   * The sub_match object stored at index 0 represents sub-expression 0, i.e.
+   * the whole match. In this case the sub_match member matched is always true.
+   * The sub_match object stored at index n denotes what matched the marked
+   * sub-expression n within the matched expression. If the sub-expression n
+   * participated in a regular expression match then the sub_match member
+   * matched evaluates to true, and members first and second denote the range
+   * of characters [first, second) which formed that match. Otherwise matched
+   * is false, and members first and second point to the end of the sequence
+   * that was searched.
+   *
+   * @nosubgrouping
+   */
+  template<typename _Bi_iter,
+	   typename _Allocator = allocator<sub_match<_Bi_iter> > >
+    class match_results
+    : private std::vector<std::tr1::sub_match<_Bi_iter>, _Allocator>
+    {
+    private:
+      typedef std::vector<std::tr1::sub_match<_Bi_iter>, _Allocator>
+                                                              _Base_type;
+
+    public:
+      /**
+       * @name 10.? Public Types
+       */
+      //@{
+      typedef sub_match<_Bi_iter>                             value_type;
+      typedef typename _Allocator::const_reference            const_reference;
+      typedef const_reference                                 reference;
+      typedef typename _Base_type::const_iterator             const_iterator;
+      typedef const_iterator                                  iterator;
+      typedef typename iterator_traits<_Bi_iter>::difference_type
+                                                              difference_type;
+      typedef typename _Allocator::size_type                  size_type;
+      typedef _Allocator                                      allocator_type;
+      typedef typename iterator_traits<_Bi_iter>::value_type  char_type;
+      typedef basic_string<char_type>                         string_type;
+      //@}
+  
+    public:
+      /**
+       * @name 10.1 Construction, Copying, and Destruction
+       */
+      //@{
+
+      /**
+       * @brief Constructs a default %match_results container.
+       * @post size() returns 0 and str() returns an empty string.
+       */
+      explicit
+      match_results(const _Allocator& __a = _Allocator())
+      : _Base_type(__a), _M_matched(false)
+      { }
+
+      /**
+       * @brief Copy constructs a %match_results.
+       */
+      match_results(const match_results& __rhs)
+      : _Base_type(__rhs), _M_matched(__rhs._M_matched),
+	_M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
+      { }
+
+      /**
+       * @brief Assigns rhs to *this.
+       */
+      match_results&
+      operator=(const match_results& __rhs)
+      {
+	match_results __tmp(__rhs);
+	this->swap(__tmp);
+	return *this;
+      }
+
+      /**
+       * @brief Destroys a %match_results object.
+       */
+      ~match_results()
+      { }
+      
+      //@}
+
+      /**
+       * @name 10.2 Size
+       */
+      //@{
+
+      /**
+       * @brief Gets the number of matches and submatches.
+       *
+       * The number of matches for a given regular expression will be either 0
+       * if there was no match or mark_count() + 1 if a match was successful.
+       * Some matches may be empty.
+       *
+       * @returns the number of matches found.
+       */
+      size_type
+      size() const
+      { return _M_matched ? _Base_type::size() + 1 : 0; }
+      
+      //size_type
+      //max_size() const;
+      using _Base_type::max_size;
+
+      /**
+       * @brief Indicates if the %match_results contains no results.
+       * @retval true The %match_results object is empty.
+       * @retval false The %match_results object is not empty.
+       */
+      bool
+      empty() const
+      { return size() == 0; }
+      
+      //@}
+
+      /**
+       * @name 10.3 Element Access
+       */
+      //@{
+
+      /**
+       * @brief Gets the length of the indicated submatch.
+       * @param sub indicates the submatch.
+       *
+       * This function returns the length of the indicated submatch, or the
+       * length of the entire match if @p sub is zero (the default).
+       */
+      difference_type
+      length(size_type __sub = 0) const
+      { return _M_matched ? this->str(__sub).length() : 0; }
+
+      /**
+       * @brief Gets the offset of the beginning of the indicated submatch.
+       * @param sub indicates the submatch.
+       *
+       * This function returns the offset from the beginning of the target
+       * sequence to the beginning of the submatch, unless the value of @p sub
+       * is zero (the default), in which case this function returns the offset
+       * from the beginning of the target sequence to the beginning of the
+       * match.
+       */
+      difference_type
+      position(size_type __sub = 0) const
+      {
+	return _M_matched ? std::distance(this->prefix().first,
+					  (*this)[__sub].first) : 0;
+      }
+
+      /**
+       * @brief Gets the match or submatch converted to a string type.
+       * @param sub indicates the submatch.
+       *
+       * This function gets the submatch (or match, if @p sub is zero) extracted
+       * from the target range and converted to the associated string type.
+       */
+      string_type
+      str(size_type __sub = 0) const
+      { return _M_matched ? (*this)[__sub].str() : string_type(); }
+      
+      /**
+       * @brief Gets a %sub_match reference for the match or submatch.
+       * @param sub indicates the submatch.
+       *
+       * This function gets a reference to the indicated submatch, or the entire
+       * match if @p sub is zero.
+       *
+       * If @p sub >= size() then this function returns a %sub_match with a
+       * special value indicating no submatch.
+       */
+      const_reference
+      operator[](size_type __sub) const
+      { return _Base_type::operator[](__sub); }
+
+      /**
+       * @brief Gets a %sub_match representing the match prefix.
+       *
+       * This function gets a reference to a %sub_match object representing the
+       * part of the target range between the start of the target range and the
+       * start of the match.
+       */
+      const_reference
+      prefix() const
+      { return _M_prefix; }
+
+      /**
+       * @brief Gets a %sub_match representing the match suffix.
+       *
+       * This function gets a reference to a %sub_match object representing the
+       * part of the target range between the end of the match and the end of
+       * the target range.
+       */
+      const_reference
+      suffix() const
+      { return _M_suffix; }
+
+      /**
+       * @brief Gets an iterator to the start of the %sub_match collection.
+       */
+      const_iterator
+      begin() const
+      { return _Base_type::begin(); }
+      
+#ifdef _GLIBCXX_INCLUDE_AS_CXX11
+      /**
+       * @brief Gets an iterator to the start of the %sub_match collection.
+       */
+      const_iterator
+      cbegin() const
+      { return _Base_type::begin(); }
+#endif
+
+      /**
+       * @brief Gets an iterator to one-past-the-end of the collection.
+       */
+      const_iterator
+      end() const
+      { return _Base_type::end(); }
+      
+#ifdef _GLIBCXX_INCLUDE_AS_CXX11
+      /**
+       * @brief Gets an iterator to one-past-the-end of the collection.
+       */
+      const_iterator
+      cend() const
+      { return _Base_type::end(); }
+#endif
+
+      //@}
+
+      /**
+       * @name 10.4 Formatting
+       *
+       * These functions perform formatted substitution of the matched
+       * character sequences into their target.  The format specifiers
+       * and escape sequences accepted by these functions are
+       * determined by their @p flags parameter as documented above.
+       */
+       //@{
+
+      /**
+       * @todo Implement this function.
+       */
+      template<typename _Out_iter>
+        _Out_iter
+        format(_Out_iter __out, const string_type& __fmt,
+	       regex_constants::match_flag_type __flags
+	       = regex_constants::format_default) const;
+
+      /**
+       * @todo Implement this function.
+       */
+      string_type
+      format(const string_type& __fmt,
+	     regex_constants::match_flag_type __flags
+	     = regex_constants::format_default) const;
+
+      //@} 
+
+      /**
+       * @name 10.5 Allocator
+       */
+      //@{ 
+
+      /**
+       * @brief Gets a copy of the allocator.
+       */
+      //allocator_type
+      //get_allocator() const;
+      using _Base_type::get_allocator;
+      
+      //@} 
+
+      /**
+       * @name 10.6 Swap
+       */
+       //@{ 
+
+      /**
+       * @brief Swaps the contents of two match_results.
+       */
+      void
+      swap(match_results& __that)
+      {
+	_Base_type::swap(__that);
+	std::swap(_M_matched, __that._M_matched);
+	std::swap(_M_prefix,  __that._M_prefix);
+	std::swap(_M_suffix,  __that._M_suffix);
+      }
+      //@} 
+      
+    private:
+      bool       _M_matched;
+      value_type _M_prefix;
+      value_type _M_suffix;
+    };
+  
+  typedef match_results<const char*>             cmatch;
+  typedef match_results<string::const_iterator>  smatch;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef match_results<const wchar_t*>          wcmatch;
+  typedef match_results<wstring::const_iterator> wsmatch;
+#endif
+
+  // match_results comparisons
+  /**
+   * @brief Compares two match_results for equality.
+   * @returns true if the two objects refer to the same match,
+   * false otherwise.
+   * @todo Implement this function.
+   */
+  template<typename _Bi_iter, typename _Allocator>
+    inline bool
+    operator==(const match_results<_Bi_iter, _Allocator>& __m1,
+	       const match_results<_Bi_iter, _Allocator>& __m2);
+
+  /**
+   * @brief Compares two match_results for inequality.
+   * @returns true if the two objects do not refer to the same match,
+   * false otherwise.
+   */
+  template<typename _Bi_iter, class _Allocator>
+    inline bool
+    operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
+	       const match_results<_Bi_iter, _Allocator>& __m2)
+    { return !(__m1 == __m2); }
+
+  // [7.10.6] match_results swap
+  /**
+   * @brief Swaps two match results.
+   * @param lhs A match result.
+   * @param rhs A match result.
+   *
+   * The contents of the two match_results objects are swapped.
+   */
+  template<typename _Bi_iter, typename _Allocator>
+    inline void
+    swap(match_results<_Bi_iter, _Allocator>& __lhs,
+	 match_results<_Bi_iter, _Allocator>& __rhs)
+    { __lhs.swap(__rhs); }
+
+  // [7.11.2] Function template regex_match
+  /**
+   * @name Matching, Searching, and Replacing
+   */
+  //@{
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and all of the character sequence [first, last).
+   *
+   * @param first Beginning of the character sequence to match.
+   * @param last  One-past-the-end of the character sequence to match.
+   * @param m     The match results.
+   * @param re    The regular expression.
+   * @param flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   *
+   * @todo Implement this function.
+   */
+  template<typename _Bi_iter, typename _Allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    bool
+    regex_match(_Bi_iter __first, _Bi_iter __last,
+		match_results<_Bi_iter, _Allocator>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default);
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and all of the character sequence [first, last).
+   *
+   * @param first Beginning of the character sequence to match.
+   * @param last  One-past-the-end of the character sequence to match.
+   * @param re    The regular expression.
+   * @param flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+    bool
+    regex_match(_Bi_iter __first, _Bi_iter __last,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { 
+      match_results<_Bi_iter> __what;
+      return regex_match(__first, __last, __what, __re, __flags);
+    }
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and a C-style null-terminated string.
+   *
+   * @param s  The C-style null-terminated string to match.
+   * @param m  The match results.
+   * @param re The regular expression.
+   * @param f  Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
+    inline bool
+    regex_match(const _Ch_type* __s,
+		match_results<const _Ch_type*, _Allocator>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __f
+		= regex_constants::match_default)
+    { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
+
+  /**
+   * @brief Determines if there is a match between the regular expression @p e
+   * and a string.
+   *
+   * @param s     The string to match.
+   * @param m     The match results.
+   * @param re    The regular expression.
+   * @param flags Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _Ch_alloc,
+	   typename _Allocator, typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		match_results<typename basic_string<_Ch_type, 
+		_Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and a C-style null-terminated string.
+   *
+   * @param s  The C-style null-terminated string to match.
+   * @param re The regular expression.
+   * @param f  Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, class _Rx_traits>
+    inline bool
+    regex_match(const _Ch_type* __s,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __f
+		= regex_constants::match_default)
+    { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
+
+  /**
+   * @brief Indicates if there is a match between the regular expression @p e
+   * and a string.
+   *
+   * @param s     [IN] The string to match.
+   * @param re    [IN] The regular expression.
+   * @param flags [IN] Controls how the regular expression is matched.
+   *
+   * @retval true  A match exists.
+   * @retval false Otherwise.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _Str_allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
+		const basic_regex<_Ch_type, _Rx_traits>& __re,
+		regex_constants::match_flag_type __flags
+		= regex_constants::match_default)
+    { return regex_match(__s.begin(), __s.end(), __re, __flags); }
+
+  // [7.11.3] Function template regex_search
+  /**
+   * Searches for a regular expression within a range.
+   * @param first [IN]  The start of the string to search.
+   * @param last  [IN]  One-past-the-end of the string to search.
+   * @param m     [OUT] The match results.
+   * @param re    [IN]  The regular expression to search for.
+   * @param flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   *
+   * @throws an exception of type regex_error.
+   *
+   * @todo Implement this function.
+   */
+  template<typename _Bi_iter, typename _Allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(_Bi_iter __first, _Bi_iter __last,
+		 match_results<_Bi_iter, _Allocator>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __re,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default);
+
+  /**
+   * Searches for a regular expression within a range.
+   * @param first [IN]  The start of the string to search.
+   * @param last  [IN]  One-past-the-end of the string to search.
+   * @param re    [IN]  The regular expression to search for.
+   * @param flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   * @doctodo
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(_Bi_iter __first, _Bi_iter __last,
+		 const basic_regex<_Ch_type, _Rx_traits>& __re,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    {
+      match_results<_Bi_iter> __what;
+      return regex_search(__first, __last, __what, __re, __flags);
+    }
+
+  /**
+   * @brief Searches for a regular expression within a C-string.
+   * @param s [IN]  A C-string to search for the regex.
+   * @param m [OUT] The set of regex matches.
+   * @param e [IN]  The regex to search for in @p s.
+   * @param f [IN]  The search flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   * @doctodo
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, class _Allocator, class _Rx_traits>
+    inline bool
+    regex_search(const _Ch_type* __s,
+		 match_results<const _Ch_type*, _Allocator>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
+
+  /**
+   * @brief Searches for a regular expression within a C-string.
+   * @param s [IN]  The C-string to search.
+   * @param e [IN]  The regular expression to search for.
+   * @param f [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   * @doctodo
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(const _Ch_type* __s,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
+
+  /**
+   * @brief Searches for a regular expression within a string.
+   * @param s     [IN]  The string to search.
+   * @param e     [IN]  The regular expression to search for.
+   * @param flags [IN]  Search policy flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string.
+   * @doctodo
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _String_allocator,
+	   typename _Ch_type, typename _Rx_traits>
+    inline bool
+    regex_search(const basic_string<_Ch_type, _Ch_traits,
+		 _String_allocator>& __s,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __flags
+		 = regex_constants::match_default)
+    { return regex_search(__s.begin(), __s.end(), __e, __flags); }
+
+  /**
+   * @brief Searches for a regular expression within a string.
+   * @param s [IN]  A C++ string to search for the regex.
+   * @param m [OUT] The set of regex matches.
+   * @param e [IN]  The regex to search for in @p s.
+   * @param f [IN]  The search flags.
+   * @retval true  A match was found within the string.
+   * @retval false No match was found within the string, the content of %m is
+   *               undefined.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Ch_traits, typename _Ch_alloc,
+	   typename _Allocator, typename _Ch_type,
+	   typename _Rx_traits>
+    inline bool
+    regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
+		 match_results<typename basic_string<_Ch_type,
+		 _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
+		 const basic_regex<_Ch_type, _Rx_traits>& __e,
+		 regex_constants::match_flag_type __f
+		 = regex_constants::match_default)
+    { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
+
+  // tr1 [7.11.4] std [28.11.4] Function template regex_replace
+  /**
+   * @doctodo
+   * @param out
+   * @param first
+   * @param last
+   * @param e
+   * @param fmt
+   * @param flags
+   *
+   * @returns out
+   * @throws an exception of type regex_error.
+   *
+   * @todo Implement this function.
+   */
+  template<typename _Out_iter, typename _Bi_iter,
+	   typename _Rx_traits, typename _Ch_type>
+    inline _Out_iter
+    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const basic_string<_Ch_type>& __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default);
+
+  /**
+   * @doctodo
+   * @param s
+   * @param e
+   * @param fmt
+   * @param flags
+   *
+   * @returns a copy of string @p s with replacements.
+   *
+   * @throws an exception of type regex_error.
+   */
+  template<typename _Rx_traits, typename _Ch_type>
+    inline basic_string<_Ch_type>
+    regex_replace(const basic_string<_Ch_type>& __s,
+		  const basic_regex<_Ch_type, _Rx_traits>& __e,
+		  const basic_string<_Ch_type>& __fmt,
+		  regex_constants::match_flag_type __flags
+		  = regex_constants::match_default)
+    {
+      std::string __result;
+      regex_replace(std::back_inserter(__result),
+		    __s.begin(), __s.end(), __e, __fmt, __flags);
+      return __result;
+    }
+
+  //@}
+
+  // tr1 [7.12.1] std [28.12] Class template regex_iterator
+  /**
+   * An iterator adaptor that will provide repeated calls of regex_search over 
+   * a range until no more matches remain.
+   */
+  template<typename _Bi_iter,
+	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+	   typename _Rx_traits = regex_traits<_Ch_type> >
+    class regex_iterator
+    {
+    public:
+      typedef basic_regex<_Ch_type, _Rx_traits>  regex_type;
+      typedef match_results<_Bi_iter>            value_type;
+      typedef std::ptrdiff_t                     difference_type;
+      typedef const value_type*                  pointer;
+      typedef const value_type&                  reference;
+      typedef std::forward_iterator_tag          iterator_category;
+
+    public:
+      /**
+       * @brief Provides a singular iterator, useful for indicating
+       * one-past-the-end of a range.
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_iterator();
+      
+      /**
+       * Constructs a %regex_iterator...
+       * @param a  [IN] The start of a text range to search.
+       * @param b  [IN] One-past-the-end of the text range to search.
+       * @param re [IN] The regular expression to match.
+       * @param m  [IN] Policy flags for match rules.
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+		     regex_constants::match_flag_type __m
+		     = regex_constants::match_default);
+
+      /**
+       * Copy constructs a %regex_iterator.
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_iterator(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_iterator&
+      operator=(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @doctodo
+       */
+      bool
+      operator==(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @doctodo
+       */
+      bool
+      operator!=(const regex_iterator& __rhs);
+      
+      /**
+       * @todo Implement this function.
+       * @doctodo
+       */
+      const value_type&
+      operator*();
+      
+      /**
+       * @todo Implement this function.
+       * @doctodo
+       */
+      const value_type*
+      operator->();
+      
+      /**
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_iterator&
+      operator++();
+      
+      /**
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_iterator
+      operator++(int);
+      
+    private:
+      // these members are shown for exposition only:
+      _Bi_iter                         begin;
+      _Bi_iter                         end;
+      const regex_type*                pregex;
+      regex_constants::match_flag_type flags;
+      match_results<_Bi_iter>          match;
+    };
+  
+  typedef regex_iterator<const char*>             cregex_iterator;
+  typedef regex_iterator<string::const_iterator>  sregex_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef regex_iterator<const wchar_t*>          wcregex_iterator;
+  typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
+#endif
+
+  // [7.12.2] Class template regex_token_iterator
+  /**
+   * Iterates over submatches in a range (or @a splits a text string).
+   *
+   * The purpose of this iterator is to enumerate all, or all specified,
+   * matches of a regular expression within a text range.  The dereferenced
+   * value of an iterator of this class is a std::tr1::sub_match object.
+   */
+  template<typename _Bi_iter,
+	   typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
+	   typename _Rx_traits = regex_traits<_Ch_type> >
+    class regex_token_iterator
+    {
+    public:
+      typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
+      typedef sub_match<_Bi_iter>               value_type;
+      typedef std::ptrdiff_t                    difference_type;
+      typedef const value_type*                 pointer;
+      typedef const value_type&                 reference;
+      typedef std::forward_iterator_tag         iterator_category;
+      
+    public:
+      /**
+       * @brief Default constructs a %regex_token_iterator.
+       * @todo Implement this function.
+       * 
+       * A default-constructed %regex_token_iterator is a singular iterator
+       * that will compare equal to the one-past-the-end value for any
+       * iterator of the same type.
+       */
+      regex_token_iterator();
+      
+      /**
+       * Constructs a %regex_token_iterator...
+       * @param a          [IN] The start of the text to search.
+       * @param b          [IN] One-past-the-end of the text to search.
+       * @param re         [IN] The regular expression to search for.
+       * @param submatch   [IN] Which submatch to return.  There are some
+       *                        special values for this parameter:
+       *                        - -1 each enumerated subexpression does NOT
+       *                          match the regular expression (aka field
+       *                          splitting)
+       *                        - 0 the entire string matching the
+       *                          subexpression is returned for each match
+       *                          within the text.
+       *                        - >0 enumerates only the indicated
+       *                          subexpression from a match within the text.
+       * @param m          [IN] Policy flags for match rules.
+       *
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
+			   int __submatch = 0,
+			   regex_constants::match_flag_type __m
+			   = regex_constants::match_default);
+
+      /**
+       * Constructs a %regex_token_iterator...
+       * @param a          [IN] The start of the text to search.
+       * @param b          [IN] One-past-the-end of the text to search.
+       * @param re         [IN] The regular expression to search for.
+       * @param submatches [IN] A list of subexpressions to return for each
+       *                        regular expression match within the text.
+       * @param m          [IN] Policy flags for match rules.
+       *
+       * @todo Implement this function.
+       * @doctodo
+       */
+      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+			   const regex_type& __re,
+			   const std::vector<int>& __submatches,
+			   regex_constants::match_flag_type __m
+			     = regex_constants::match_default);
+
+      /**
+       * Constructs a %regex_token_iterator...
+       * @param a          [IN] The start of the text to search.
+       * @param b          [IN] One-past-the-end of the text to search.
+       * @param re         [IN] The regular expression to search for.
+       * @param submatches [IN] A list of subexpressions to return for each
+       *                        regular expression match within the text.
+       * @param m          [IN] Policy flags for match rules.
+       
+       * @todo Implement this function.
+       * @doctodo
+       */
+      template<std::size_t _Nm>
+        regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
+			     const regex_type& __re,
+			     const int (&__submatches)[_Nm],
+			     regex_constants::match_flag_type __m
+			     = regex_constants::match_default);
+
+      /**
+       * @brief Copy constructs a %regex_token_iterator.
+       * @param rhs [IN] A %regex_token_iterator to copy.
+       * @todo Implement this function.
+       */
+      regex_token_iterator(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Assigns a %regex_token_iterator to another.
+       * @param rhs [IN] A %regex_token_iterator to copy.
+       * @todo Implement this function.
+       */
+      regex_token_iterator&
+      operator=(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Compares a %regex_token_iterator to another for equality.
+       * @todo Implement this function.
+       */
+      bool
+      operator==(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Compares a %regex_token_iterator to another for inequality.
+       * @todo Implement this function.
+       */
+      bool
+      operator!=(const regex_token_iterator& __rhs);
+      
+      /**
+       * @brief Dereferences a %regex_token_iterator.
+       * @todo Implement this function.
+       */
+      const value_type&
+      operator*();
+      
+      /**
+       * @brief Selects a %regex_token_iterator member.
+       * @todo Implement this function.
+       */
+      const value_type*
+      operator->();
+      
+      /**
+       * @brief Increments a %regex_token_iterator.
+       * @todo Implement this function.
+       */
+      regex_token_iterator&
+      operator++();
+      
+      /**
+       * @brief Postincrements a %regex_token_iterator.
+       * @todo Implement this function.
+       */
+      regex_token_iterator
+      operator++(int);
+      
+    private: // data members for exposition only:
+      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
+
+      position_iterator __position;
+      const value_type* __result;
+      value_type        __suffix;
+      std::size_t       __n;
+      std::vector<int>  __subs;
+    };
+
+  /** @brief Token iterator for C-style NULL-terminated strings. */
+  typedef regex_token_iterator<const char*>             cregex_token_iterator;
+  /** @brief Token iterator for standard strings. */
+  typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  /** @brief Token iterator for C-style NULL-terminated wide strings. */
+  typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
+  /** @brief Token iterator for standard wide-character strings. */
+  typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+#endif
+  
+  //@}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_REGEX
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/riemann_zeta.tcc b/gcc-4.9/libstdc++-v3/include/tr1/riemann_zeta.tcc
new file mode 100644
index 0000000..dbedfe0
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/riemann_zeta.tcc
@@ -0,0 +1,433 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/riemann_zeta.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. by Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications, New-York, Section 5, pp. 807-808.
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Gamma, Exploring Euler's Constant, Julian Havil,
+//       Princeton, 2003.
+
+#ifndef _GLIBCXX_TR1_RIEMANN_ZETA_TCC
+#define _GLIBCXX_TR1_RIEMANN_ZETA_TCC 1
+
+#include "special_function_util.h"
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /**
+     *   @brief  Compute the Riemann zeta function @f$ \zeta(s) @f$
+     *           by summation for s > 1.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_sum(_Tp __s)
+    {
+      //  A user shouldn't get to this.
+      if (__s < _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in zeta sum."));
+
+      const unsigned int max_iter = 10000;
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __k = 1; __k < max_iter; ++__k)
+        {
+          _Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            {
+              break;
+            }
+          __zeta += __term;
+        }
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Evaluate the Riemann zeta function @f$ \zeta(s) @f$
+     *           by an alternate series for s > 0.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_alt(_Tp __s)
+    {
+      _Tp __sgn = _Tp(1);
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __i = 1; __i < 10000000; ++__i)
+        {
+          _Tp __term = __sgn / std::pow(__i, __s);
+          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __zeta += __term;
+          __sgn *= _Tp(-1);
+        }
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Evaluate the Riemann zeta function by series for all s != 1.
+     *           Convergence is great until largish negative numbers.
+     *           Then the convergence of the > 0 sum gets better.
+     *
+     *   The series is:
+     *    \f[
+     *      \zeta(s) = \frac{1}{1-2^{1-s}}
+     *                 \sum_{n=0}^{\infty} \frac{1}{2^{n+1}}
+     *                 \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (k+1)^{-s}
+     *    \f]
+     *   Havil 2003, p. 206.
+     *
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_glob(_Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      //  Max e exponent before overflow.
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+
+      //  This series works until the binomial coefficient blows up
+      //  so use reflection.
+      if (__s < _Tp(0))
+        {
+#if _GLIBCXX_USE_C99_MATH_TR1
+          if (std::tr1::fmod(__s,_Tp(2)) == _Tp(0))
+            return _Tp(0);
+          else
+#endif
+            {
+              _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
+              __zeta *= std::pow(_Tp(2)
+                     * __numeric_constants<_Tp>::__pi(), __s)
+                     * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+#if _GLIBCXX_USE_C99_MATH_TR1
+                     * std::exp(std::tr1::lgamma(_Tp(1) - __s))
+#else
+                     * std::exp(__log_gamma(_Tp(1) - __s))
+#endif
+                     / __numeric_constants<_Tp>::__pi();
+              return __zeta;
+            }
+        }
+
+      _Tp __num = _Tp(0.5L);
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+#if _GLIBCXX_USE_C99_MATH_TR1
+              _Tp __bincoeff =  std::tr1::lgamma(_Tp(1 + __i))
+                              - std::tr1::lgamma(_Tp(1 + __j))
+                              - std::tr1::lgamma(_Tp(1 + __i - __j));
+#else
+              _Tp __bincoeff =  __log_gamma(_Tp(1 + __i))
+                              - __log_gamma(_Tp(1 + __j))
+                              - __log_gamma(_Tp(1 + __i - __j));
+#endif
+              if (__bincoeff > __max_bincoeff)
+                {
+                  //  This only gets hit for x << 0.
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term *= __num;
+          __zeta += __term;
+          if (std::abs(__term/__zeta) < __eps)
+            break;
+          __num *= _Tp(0.5L);
+        }
+
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Compute the Riemann zeta function @f$ \zeta(s) @f$
+     *           using the product over prime factors.
+     *    \f[
+     *      \zeta(s) = \Pi_{i=1}^\infty \frac{1}{1 - p_i^{-s}}
+     *    \f]
+     *    where @f$ {p_i} @f$ are the prime numbers.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_product(_Tp __s)
+    {
+      static const _Tp __prime[] = {
+        _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
+        _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
+        _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
+        _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
+      };
+      static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);
+
+      _Tp __zeta = _Tp(1);
+      for (unsigned int __i = 0; __i < __num_primes; ++__i)
+        {
+          const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
+          __zeta *= __fact;
+          if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+
+      __zeta = _Tp(1) / __zeta;
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Return the Riemann zeta function @f$ \zeta(s) @f$.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} k^{-s} for s > 1
+     *                 \frac{(2\pi)^s}{pi} sin(\frac{\pi s}{2})
+     *                 \Gamma (1 - s) \zeta (1 - s) for s < 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta(_Tp __s)
+    {
+      if (__isnan(__s))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__s == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (__s < -_Tp(19))
+        {
+          _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
+          __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
+                 * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+#if _GLIBCXX_USE_C99_MATH_TR1
+                 * std::exp(std::tr1::lgamma(_Tp(1) - __s))
+#else
+                 * std::exp(__log_gamma(_Tp(1) - __s))
+#endif
+                 / __numeric_constants<_Tp>::__pi();
+          return __zeta;
+        }
+      else if (__s < _Tp(20))
+        {
+          //  Global double sum or McLaurin?
+          bool __glob = true;
+          if (__glob)
+            return __riemann_zeta_glob(__s);
+          else
+            {
+              if (__s > _Tp(1))
+                return __riemann_zeta_sum(__s);
+              else
+                {
+                  _Tp __zeta = std::pow(_Tp(2)
+                                * __numeric_constants<_Tp>::__pi(), __s)
+                         * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+#if _GLIBCXX_USE_C99_MATH_TR1
+                             * std::tr1::tgamma(_Tp(1) - __s)
+#else
+                             * std::exp(__log_gamma(_Tp(1) - __s))
+#endif
+                             * __riemann_zeta_sum(_Tp(1) - __s);
+                  return __zeta;
+                }
+            }
+        }
+      else
+        return __riemann_zeta_product(__s);
+    }
+
+
+    /**
+     *   @brief  Return the Hurwitz zeta function @f$ \zeta(x,s) @f$
+     *           for all s != 1 and x > -1.
+     * 
+     *   The Hurwitz zeta function is defined by:
+     *   @f[
+     *     \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s}
+     *   @f]
+     *   The Riemann zeta function is a special case:
+     *   @f[
+     *     \zeta(s) = \zeta(1,s)
+     *   @f]
+     * 
+     *   This functions uses the double sum that converges for s != 1
+     *   and x > -1:
+     *   @f[
+     *     \zeta(x,s) = \frac{1}{s-1}
+     *                \sum_{n=0}^{\infty} \frac{1}{n + 1}
+     *                \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (x+k)^{-s}
+     *   @f]
+     */
+    template<typename _Tp>
+    _Tp
+    __hurwitz_zeta_glob(_Tp __a, _Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      //  Max e exponent before overflow.
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+#if _GLIBCXX_USE_C99_MATH_TR1
+              _Tp __bincoeff =  std::tr1::lgamma(_Tp(1 + __i))
+                              - std::tr1::lgamma(_Tp(1 + __j))
+                              - std::tr1::lgamma(_Tp(1 + __i - __j));
+#else
+              _Tp __bincoeff =  __log_gamma(_Tp(1 + __i))
+                              - __log_gamma(_Tp(1 + __j))
+                              - __log_gamma(_Tp(1 + __i - __j));
+#endif
+              if (__bincoeff > __max_bincoeff)
+                {
+                  //  This only gets hit for x << 0.
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term /= _Tp(__i + 1);
+          if (std::abs(__term / __zeta) < __eps)
+            break;
+          __zeta += __term;
+        }
+
+      __zeta /= __s - _Tp(1);
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Return the Hurwitz zeta function @f$ \zeta(x,s) @f$
+     *           for all s != 1 and x > -1.
+     * 
+     *   The Hurwitz zeta function is defined by:
+     *   @f[
+     *     \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s}
+     *   @f]
+     *   The Riemann zeta function is a special case:
+     *   @f[
+     *     \zeta(s) = \zeta(1,s)
+     *   @f]
+     */
+    template<typename _Tp>
+    inline _Tp
+    __hurwitz_zeta(_Tp __a, _Tp __s)
+    { return __hurwitz_zeta_glob(__a, __s); }
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_RIEMANN_ZETA_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/shared_ptr.h b/gcc-4.9/libstdc++-v3/include/tr1/shared_ptr.h
new file mode 100644
index 0000000..b13f434
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/shared_ptr.h
@@ -0,0 +1,1172 @@
+// <tr1/shared_ptr.h> -*- C++ -*-
+
+// Copyright (C) 2007-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+//  shared_count.hpp
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+
+//  shared_ptr.hpp
+//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
+//  Copyright (C) 2001, 2002, 2003 Peter Dimov
+
+//  weak_ptr.hpp
+//  Copyright (C) 2001, 2002, 2003 Peter Dimov
+
+//  enable_shared_from_this.hpp
+//  Copyright (C) 2002 Peter Dimov
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// GCC Note:  based on version 1.32.0 of the Boost library.
+
+/** @file tr1/shared_ptr.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/memory}
+ */
+
+#ifndef _TR1_SHARED_PTR_H
+#define _TR1_SHARED_PTR_H 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+   *  @brief  Exception possibly thrown by @c shared_ptr.
+   *  @ingroup exceptions
+   */
+  class bad_weak_ptr : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "tr1::bad_weak_ptr"; }
+  };
+
+  // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
+  inline void
+  __throw_bad_weak_ptr()
+  { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); }
+
+  using __gnu_cxx::_Lock_policy;
+  using __gnu_cxx::__default_lock_policy;
+  using __gnu_cxx::_S_single;
+  using __gnu_cxx::_S_mutex;
+  using __gnu_cxx::_S_atomic;
+
+  // Empty helper class except when the template argument is _S_mutex.
+  template<_Lock_policy _Lp>
+    class _Mutex_base
+    {
+    protected:
+      // The atomic policy uses fully-fenced builtins, single doesn't care.
+      enum { _S_need_barriers = 0 };
+    };
+
+  template<>
+    class _Mutex_base<_S_mutex>
+    : public __gnu_cxx::__mutex
+    {
+    protected:
+      // This policy is used when atomic builtins are not available.
+      // The replacement atomic operations might not have the necessary
+      // memory barriers.
+      enum { _S_need_barriers = 1 };
+    };
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class _Sp_counted_base
+    : public _Mutex_base<_Lp>
+    {
+    public:  
+      _Sp_counted_base()
+      : _M_use_count(1), _M_weak_count(1) { }
+      
+      virtual
+      ~_Sp_counted_base() // nothrow 
+      { }
+  
+      // Called when _M_use_count drops to zero, to release the resources
+      // managed by *this.
+      virtual void
+      _M_dispose() = 0; // nothrow
+      
+      // Called when _M_weak_count drops to zero.
+      virtual void
+      _M_destroy() // nothrow
+      { delete this; }
+      
+      virtual void*
+      _M_get_deleter(const std::type_info&) = 0;
+
+      void
+      _M_add_ref_copy()
+      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
+  
+      void
+      _M_add_ref_lock();
+      
+      void
+      _M_release() // nothrow
+      {
+        // Be race-detector-friendly.  For more info see bits/c++config.
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
+	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
+	  {
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
+	    _M_dispose();
+	    // There must be a memory barrier between dispose() and destroy()
+	    // to ensure that the effects of dispose() are observed in the
+	    // thread that runs destroy().
+	    // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
+	    if (_Mutex_base<_Lp>::_S_need_barriers)
+	      {
+	        _GLIBCXX_READ_MEM_BARRIER;
+	        _GLIBCXX_WRITE_MEM_BARRIER;
+	      }
+
+            // Be race-detector-friendly.  For more info see bits/c++config.
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
+	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
+						       -1) == 1)
+              {
+                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
+	        _M_destroy();
+              }
+	  }
+      }
+  
+      void
+      _M_weak_add_ref() // nothrow
+      { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
+
+      void
+      _M_weak_release() // nothrow
+      {
+        // Be race-detector-friendly. For more info see bits/c++config.
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
+	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
+	  {
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
+	    if (_Mutex_base<_Lp>::_S_need_barriers)
+	      {
+	        // See _M_release(),
+	        // destroy() must observe results of dispose()
+	        _GLIBCXX_READ_MEM_BARRIER;
+	        _GLIBCXX_WRITE_MEM_BARRIER;
+	      }
+	    _M_destroy();
+	  }
+      }
+  
+      long
+      _M_get_use_count() const // nothrow
+      {
+        // No memory barrier is used here so there is no synchronization
+        // with other threads.
+        return const_cast<const volatile _Atomic_word&>(_M_use_count);
+      }
+
+    private:  
+      _Sp_counted_base(_Sp_counted_base const&);
+      _Sp_counted_base& operator=(_Sp_counted_base const&);
+
+      _Atomic_word  _M_use_count;     // #shared
+      _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
+    };
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::
+    _M_add_ref_lock()
+    {
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+	{
+	  _M_use_count = 0;
+	  __throw_bad_weak_ptr();
+	}
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_mutex>::
+    _M_add_ref_lock()
+    {
+      __gnu_cxx::__scoped_lock sentry(*this);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+	{
+	  _M_use_count = 0;
+	  __throw_bad_weak_ptr();
+	}
+    }
+
+  template<> 
+    inline void
+    _Sp_counted_base<_S_atomic>::
+    _M_add_ref_lock()
+    {
+      // Perform lock-free add-if-not-zero operation.
+      _Atomic_word __count = _M_use_count;
+      do
+	{
+	  if (__count == 0)
+	    __throw_bad_weak_ptr();
+	  // Replace the current counter value with the old value + 1, as
+	  // long as it's not changed meanwhile. 
+	}
+      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
+					  true, __ATOMIC_ACQ_REL, 
+					  __ATOMIC_RELAXED));
+     }
+
+  template<typename _Ptr, typename _Deleter, _Lock_policy _Lp>
+    class _Sp_counted_base_impl
+    : public _Sp_counted_base<_Lp>
+    {
+    public:
+      // Precondition: __d(__p) must not throw.
+      _Sp_counted_base_impl(_Ptr __p, _Deleter __d)
+      : _M_ptr(__p), _M_del(__d) { }
+    
+      virtual void
+      _M_dispose() // nothrow
+      { _M_del(_M_ptr); }
+      
+      virtual void*
+      _M_get_deleter(const std::type_info& __ti)
+      {
+#ifdef __GXX_RTTI
+        return __ti == typeid(_Deleter) ? &_M_del : 0;
+#else
+        return 0;
+#endif
+      }
+      
+    private:
+      _Sp_counted_base_impl(const _Sp_counted_base_impl&);
+      _Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&);
+      
+      _Ptr      _M_ptr;  // copy constructor must not throw
+      _Deleter  _M_del;  // copy constructor must not throw
+    };
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __weak_count;
+
+  template<typename _Tp>
+    struct _Sp_deleter
+    {
+      typedef void result_type;
+      typedef _Tp* argument_type;
+      void operator()(_Tp* __p) const { delete __p; }
+    };
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __shared_count
+    {
+    public: 
+      __shared_count()
+      : _M_pi(0) // nothrow
+      { }
+  
+      template<typename _Ptr>
+        __shared_count(_Ptr __p) : _M_pi(0)
+        {
+	  __try
+	    {
+	      typedef typename std::tr1::remove_pointer<_Ptr>::type _Tp;
+	      _M_pi = new _Sp_counted_base_impl<_Ptr, _Sp_deleter<_Tp>, _Lp>(
+	          __p, _Sp_deleter<_Tp>());
+	    }
+	  __catch(...)
+	    {
+	      delete __p;
+	      __throw_exception_again;
+	    }
+	}
+
+      template<typename _Ptr, typename _Deleter>
+        __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
+        {
+	  __try
+	    {
+	      _M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d);
+	    }
+	  __catch(...)
+	    {
+	      __d(__p); // Call _Deleter on __p.
+	      __throw_exception_again;
+	    }
+	}
+
+      // Special case for auto_ptr<_Tp> to provide the strong guarantee.
+      template<typename _Tp>
+        explicit
+        __shared_count(std::auto_ptr<_Tp>& __r)
+	: _M_pi(new _Sp_counted_base_impl<_Tp*,
+		_Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>()))
+        { __r.release(); }
+
+      // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
+      explicit
+      __shared_count(const __weak_count<_Lp>& __r);
+  
+      ~__shared_count() // nothrow
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_release();
+      }
+      
+      __shared_count(const __shared_count& __r)
+      : _M_pi(__r._M_pi) // nothrow
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_add_ref_copy();
+      }
+  
+      __shared_count&
+      operator=(const __shared_count& __r) // nothrow
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	if (__tmp != _M_pi)
+	  {
+	    if (__tmp != 0)
+	      __tmp->_M_add_ref_copy();
+	    if (_M_pi != 0)
+	      _M_pi->_M_release();
+	    _M_pi = __tmp;
+	  }
+	return *this;
+      }
+  
+      void
+      _M_swap(__shared_count& __r) // nothrow
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	__r._M_pi = _M_pi;
+	_M_pi = __tmp;
+      }
+  
+      long
+      _M_get_use_count() const // nothrow
+      { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
+
+      bool
+      _M_unique() const // nothrow
+      { return this->_M_get_use_count() == 1; }
+      
+      friend inline bool
+      operator==(const __shared_count& __a, const __shared_count& __b)
+      { return __a._M_pi == __b._M_pi; }
+  
+      friend inline bool
+      operator<(const __shared_count& __a, const __shared_count& __b)
+      { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); }
+  
+      void*
+      _M_get_deleter(const std::type_info& __ti) const
+      { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
+
+    private:
+      friend class __weak_count<_Lp>;
+
+      _Sp_counted_base<_Lp>*  _M_pi;
+    };
+
+
+  template<_Lock_policy _Lp>
+    class __weak_count
+    {
+    public:
+      __weak_count()
+      : _M_pi(0) // nothrow
+      { }
+  
+      __weak_count(const __shared_count<_Lp>& __r)
+      : _M_pi(__r._M_pi) // nothrow
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_add_ref();
+      }
+      
+      __weak_count(const __weak_count<_Lp>& __r)
+      : _M_pi(__r._M_pi) // nothrow
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_add_ref();
+      }
+      
+      ~__weak_count() // nothrow
+      {
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_release();
+      }
+      
+      __weak_count<_Lp>&
+      operator=(const __shared_count<_Lp>& __r) // nothrow
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	if (__tmp != 0)
+	  __tmp->_M_weak_add_ref();
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_release();
+	_M_pi = __tmp;  
+	return *this;
+      }
+      
+      __weak_count<_Lp>&
+      operator=(const __weak_count<_Lp>& __r) // nothrow
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	if (__tmp != 0)
+	  __tmp->_M_weak_add_ref();
+	if (_M_pi != 0)
+	  _M_pi->_M_weak_release();
+	_M_pi = __tmp;
+	return *this;
+      }
+
+      void
+      _M_swap(__weak_count<_Lp>& __r) // nothrow
+      {
+	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+	__r._M_pi = _M_pi;
+	_M_pi = __tmp;
+      }
+  
+      long
+      _M_get_use_count() const // nothrow
+      { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
+
+      friend inline bool
+      operator==(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b)
+      { return __a._M_pi == __b._M_pi; }
+      
+      friend inline bool
+      operator<(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b)
+      { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); }
+
+    private:
+      friend class __shared_count<_Lp>;
+
+      _Sp_counted_base<_Lp>*  _M_pi;
+    };
+
+  // now that __weak_count is defined we can define this constructor:
+  template<_Lock_policy _Lp>
+    inline
+    __shared_count<_Lp>::
+    __shared_count(const __weak_count<_Lp>& __r)
+    : _M_pi(__r._M_pi)
+    {
+      if (_M_pi != 0)
+	_M_pi->_M_add_ref_lock();
+      else
+	__throw_bad_weak_ptr();
+    }
+
+  // Forward declarations.
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __shared_ptr;
+  
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __weak_ptr;
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __enable_shared_from_this;
+
+  template<typename _Tp>
+    class shared_ptr;
+  
+  template<typename _Tp>
+    class weak_ptr;
+
+  template<typename _Tp>
+    class enable_shared_from_this;
+
+  // Support for enable_shared_from_this.
+
+  // Friend of __enable_shared_from_this.
+  template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
+    void
+    __enable_shared_from_this_helper(const __shared_count<_Lp>&,
+				     const __enable_shared_from_this<_Tp1,
+				     _Lp>*, const _Tp2*);
+
+  // Friend of enable_shared_from_this.
+  template<typename _Tp1, typename _Tp2>
+    void
+    __enable_shared_from_this_helper(const __shared_count<>&,
+				     const enable_shared_from_this<_Tp1>*,
+				     const _Tp2*);
+
+  template<_Lock_policy _Lp>
+    inline void
+    __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...)
+    { }
+
+
+  struct __static_cast_tag { };
+  struct __const_cast_tag { };
+  struct __dynamic_cast_tag { };
+
+  // A smart pointer with reference-counted copy semantics.  The
+  // object pointed to is deleted when the last shared_ptr pointing to
+  // it is destroyed or reset.
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr
+    {
+    public:
+      typedef _Tp   element_type;
+      
+      __shared_ptr()
+      : _M_ptr(0), _M_refcount() // never throws
+      { }
+
+      template<typename _Tp1>
+        explicit
+        __shared_ptr(_Tp1* __p)
+	: _M_ptr(__p), _M_refcount(__p)
+        {
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  typedef int _IsComplete[sizeof(_Tp1)];
+	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
+	}
+
+      template<typename _Tp1, typename _Deleter>
+        __shared_ptr(_Tp1* __p, _Deleter __d)
+        : _M_ptr(__p), _M_refcount(__p, __d)
+        {
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
+	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
+	}
+      
+      //  generated copy constructor, assignment, destructor are fine.
+      
+      template<typename _Tp1>
+        __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
+	: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
+        { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
+
+      template<typename _Tp1>
+        explicit
+        __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
+	: _M_refcount(__r._M_refcount) // may throw
+        {
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount)
+	  // did not throw.
+	  _M_ptr = __r._M_ptr;
+	}
+
+#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
+      // Postcondition: use_count() == 1 and __r.get() == 0
+      template<typename _Tp1>
+        explicit
+        __shared_ptr(std::auto_ptr<_Tp1>& __r)
+	: _M_ptr(__r.get()), _M_refcount()
+        { // TODO requries delete __r.release() well-formed
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  typedef int _IsComplete[sizeof(_Tp1)];
+	  _Tp1* __tmp = __r.get();
+	  _M_refcount = __shared_count<_Lp>(__r);
+	  __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
+	}
+
+#endif
+
+      template<typename _Tp1>
+        __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __static_cast_tag)
+	: _M_ptr(static_cast<element_type*>(__r._M_ptr)),
+	  _M_refcount(__r._M_refcount)
+        { }
+
+      template<typename _Tp1>
+        __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __const_cast_tag)
+	: _M_ptr(const_cast<element_type*>(__r._M_ptr)),
+	  _M_refcount(__r._M_refcount)
+        { }
+
+      template<typename _Tp1>
+        __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __dynamic_cast_tag)
+	: _M_ptr(dynamic_cast<element_type*>(__r._M_ptr)),
+	  _M_refcount(__r._M_refcount)
+        {
+	  if (_M_ptr == 0) // need to allocate new counter -- the cast failed
+	    _M_refcount = __shared_count<_Lp>();
+	}
+
+      template<typename _Tp1>
+        __shared_ptr&
+        operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
+        {
+	  _M_ptr = __r._M_ptr;
+	  _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
+	  return *this;
+	}
+
+#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
+      template<typename _Tp1>
+        __shared_ptr&
+        operator=(std::auto_ptr<_Tp1>& __r)
+        {
+	  __shared_ptr(__r).swap(*this);
+	  return *this;
+	}
+#endif
+
+      void
+      reset() // never throws
+      { __shared_ptr().swap(*this); }
+
+      template<typename _Tp1>
+        void
+        reset(_Tp1* __p) // _Tp1 must be complete.
+        {
+	  // Catch self-reset errors.
+	  _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); 
+	  __shared_ptr(__p).swap(*this);
+	}
+
+      template<typename _Tp1, typename _Deleter>
+        void
+        reset(_Tp1* __p, _Deleter __d)
+        { __shared_ptr(__p, __d).swap(*this); }
+
+      // Allow class instantiation when _Tp is [cv-qual] void.
+      typename std::tr1::add_reference<_Tp>::type
+      operator*() const // never throws
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	return *_M_ptr;
+      }
+
+      _Tp*
+      operator->() const // never throws
+      {
+	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	return _M_ptr;
+      }
+    
+      _Tp*
+      get() const // never throws
+      { return _M_ptr; }
+
+      // Implicit conversion to "bool"
+    private:
+      typedef _Tp* __shared_ptr::*__unspecified_bool_type;
+
+    public:
+      operator __unspecified_bool_type() const // never throws
+      { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; }
+
+      bool
+      unique() const // never throws
+      { return _M_refcount._M_unique(); }
+
+      long
+      use_count() const // never throws
+      { return _M_refcount._M_get_use_count(); }
+
+      void
+      swap(__shared_ptr<_Tp, _Lp>& __other) // never throws
+      {
+	std::swap(_M_ptr, __other._M_ptr);
+	_M_refcount._M_swap(__other._M_refcount);
+      }
+
+    private:
+      void*
+      _M_get_deleter(const std::type_info& __ti) const
+      { return _M_refcount._M_get_deleter(__ti); }
+
+      template<typename _Tp1, _Lock_policy _Lp1>
+        bool
+        _M_less(const __shared_ptr<_Tp1, _Lp1>& __rhs) const
+        { return _M_refcount < __rhs._M_refcount; }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+
+      template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
+        friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&);
+
+      // Friends injected into enclosing namespace and found by ADL:
+      template<typename _Tp1>
+        friend inline bool
+        operator==(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b)
+        { return __a.get() == __b.get(); }
+
+      template<typename _Tp1>
+        friend inline bool
+        operator!=(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b)
+        { return __a.get() != __b.get(); }
+
+      template<typename _Tp1>
+        friend inline bool
+        operator<(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b)
+        { return __a._M_less(__b); }
+
+      _Tp*         	   _M_ptr;         // Contained pointer.
+      __shared_count<_Lp>  _M_refcount;    // Reference counter.
+    };
+
+  // 2.2.3.8 shared_ptr specialized algorithms.
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b)
+    { __a.swap(__b); }
+
+  // 2.2.3.9 shared_ptr casts
+  /*  The seemingly equivalent
+   *           shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
+   *  will eventually result in undefined behaviour,
+   *  attempting to delete the same object twice.
+   */
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
+    { return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag()); }
+
+  /*  The seemingly equivalent
+   *           shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
+   *  will eventually result in undefined behaviour,
+   *  attempting to delete the same object twice.
+   */
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
+    { return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag()); }
+
+  /*  The seemingly equivalent
+   *           shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
+   *  will eventually result in undefined behaviour,
+   *  attempting to delete the same object twice.
+   */
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
+    { return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag()); }
+
+  // 2.2.3.7 shared_ptr I/O
+  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
+    std::basic_ostream<_Ch, _Tr>&
+    operator<<(std::basic_ostream<_Ch, _Tr>& __os, 
+	       const __shared_ptr<_Tp, _Lp>& __p)
+    {
+      __os << __p.get();
+      return __os;
+    }
+
+  // 2.2.3.10 shared_ptr get_deleter (experimental)
+  template<typename _Del, typename _Tp, _Lock_policy _Lp>
+    inline _Del*
+    get_deleter(const __shared_ptr<_Tp, _Lp>& __p)
+    {
+#ifdef __GXX_RTTI
+      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
+#else
+      return 0;
+#endif
+    }
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __weak_ptr
+    {
+    public:
+      typedef _Tp element_type;
+      
+      __weak_ptr()
+      : _M_ptr(0), _M_refcount() // never throws
+      { }
+
+      // Generated copy constructor, assignment, destructor are fine.
+      
+      // The "obvious" converting constructor implementation:
+      //
+      //  template<typename _Tp1>
+      //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
+      //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
+      //    { }
+      //
+      // has a serious problem.
+      //
+      //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
+      //  conversion may require access to *__r._M_ptr (virtual inheritance).
+      //
+      // It is not possible to avoid spurious access violations since
+      // in multithreaded programs __r._M_ptr may be invalidated at any point.
+      template<typename _Tp1>
+        __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
+	: _M_refcount(__r._M_refcount) // never throws
+        {
+	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+	  _M_ptr = __r.lock().get();
+	}
+
+      template<typename _Tp1>
+        __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
+	: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
+        { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
+
+      template<typename _Tp1>
+        __weak_ptr&
+        operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws
+        {
+	  _M_ptr = __r.lock().get();
+	  _M_refcount = __r._M_refcount;
+	  return *this;
+	}
+      
+      template<typename _Tp1>
+        __weak_ptr&
+        operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
+        {
+	  _M_ptr = __r._M_ptr;
+	  _M_refcount = __r._M_refcount;
+	  return *this;
+	}
+
+      __shared_ptr<_Tp, _Lp>
+      lock() const // never throws
+      {
+#ifdef __GTHREADS
+	// Optimization: avoid throw overhead.
+	if (expired())
+	  return __shared_ptr<element_type, _Lp>();
+
+	__try
+	  {
+	    return __shared_ptr<element_type, _Lp>(*this);
+	  }
+	__catch(const bad_weak_ptr&)
+	  {
+	    // Q: How can we get here?
+	    // A: Another thread may have invalidated r after the
+	    //    use_count test above.
+	    return __shared_ptr<element_type, _Lp>();
+	  }
+	
+#else
+	// Optimization: avoid try/catch overhead when single threaded.
+	return expired() ? __shared_ptr<element_type, _Lp>()
+	                 : __shared_ptr<element_type, _Lp>(*this);
+
+#endif
+      } // XXX MT
+
+      long
+      use_count() const // never throws
+      { return _M_refcount._M_get_use_count(); }
+
+      bool
+      expired() const // never throws
+      { return _M_refcount._M_get_use_count() == 0; }
+      
+      void
+      reset() // never throws
+      { __weak_ptr().swap(*this); }
+
+      void
+      swap(__weak_ptr& __s) // never throws
+      {
+	std::swap(_M_ptr, __s._M_ptr);
+	_M_refcount._M_swap(__s._M_refcount);
+      }
+
+    private:
+      // Used by __enable_shared_from_this.
+      void
+      _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount)
+      {
+	_M_ptr = __ptr;
+	_M_refcount = __refcount;
+      }
+
+      template<typename _Tp1>
+        bool
+        _M_less(const __weak_ptr<_Tp1, _Lp>& __rhs) const
+        { return _M_refcount < __rhs._M_refcount; }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+      friend class __enable_shared_from_this<_Tp, _Lp>;
+      friend class enable_shared_from_this<_Tp>;
+
+      // Friend injected into namespace and found by ADL.
+      template<typename _Tp1>
+        friend inline bool
+        operator<(const __weak_ptr& __lhs, const __weak_ptr<_Tp1, _Lp>& __rhs)
+        { return __lhs._M_less(__rhs); }
+
+      _Tp*       	 _M_ptr;         // Contained pointer.
+      __weak_count<_Lp>  _M_refcount;    // Reference counter.
+    };
+
+  // 2.2.4.7 weak_ptr specialized algorithms.
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b)
+    { __a.swap(__b); }
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __enable_shared_from_this
+    {
+    protected:
+      __enable_shared_from_this() { }
+      
+      __enable_shared_from_this(const __enable_shared_from_this&) { }
+      
+      __enable_shared_from_this&
+      operator=(const __enable_shared_from_this&)
+      { return *this; }
+
+      ~__enable_shared_from_this() { }
+      
+    public:
+      __shared_ptr<_Tp, _Lp>
+      shared_from_this()
+      { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
+
+      __shared_ptr<const _Tp, _Lp>
+      shared_from_this() const
+      { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
+
+    private:
+      template<typename _Tp1>
+        void
+        _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const
+        { _M_weak_this._M_assign(__p, __n); }
+
+      template<typename _Tp1>
+        friend void
+        __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
+					 const __enable_shared_from_this* __pe,
+					 const _Tp1* __px)
+        {
+	  if (__pe != 0)
+	    __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
+	}
+
+      mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
+    };
+
+
+  // The actual shared_ptr, with forwarding constructors and
+  // assignment operators.
+  template<typename _Tp>
+    class shared_ptr
+    : public __shared_ptr<_Tp>
+    {
+    public:
+      shared_ptr()
+      : __shared_ptr<_Tp>() { }
+
+      template<typename _Tp1>
+        explicit
+        shared_ptr(_Tp1* __p)
+	: __shared_ptr<_Tp>(__p) { }
+
+      template<typename _Tp1, typename _Deleter>
+        shared_ptr(_Tp1* __p, _Deleter __d)
+	: __shared_ptr<_Tp>(__p, __d) { }
+
+      template<typename _Tp1>
+        shared_ptr(const shared_ptr<_Tp1>& __r)
+	: __shared_ptr<_Tp>(__r) { }
+
+      template<typename _Tp1>
+        explicit
+        shared_ptr(const weak_ptr<_Tp1>& __r)
+	: __shared_ptr<_Tp>(__r) { }
+
+#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
+      template<typename _Tp1>
+        explicit
+        shared_ptr(std::auto_ptr<_Tp1>& __r)
+	: __shared_ptr<_Tp>(__r) { }
+#endif
+
+      template<typename _Tp1>
+        shared_ptr(const shared_ptr<_Tp1>& __r, __static_cast_tag)
+	: __shared_ptr<_Tp>(__r, __static_cast_tag()) { }
+
+      template<typename _Tp1>
+        shared_ptr(const shared_ptr<_Tp1>& __r, __const_cast_tag)
+	: __shared_ptr<_Tp>(__r, __const_cast_tag()) { }
+
+      template<typename _Tp1>
+        shared_ptr(const shared_ptr<_Tp1>& __r, __dynamic_cast_tag)
+	: __shared_ptr<_Tp>(__r, __dynamic_cast_tag()) { }
+
+      template<typename _Tp1>
+        shared_ptr&
+        operator=(const shared_ptr<_Tp1>& __r) // never throws
+        {
+	  this->__shared_ptr<_Tp>::operator=(__r);
+	  return *this;
+	}
+
+#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
+      template<typename _Tp1>
+        shared_ptr&
+        operator=(std::auto_ptr<_Tp1>& __r)
+        {
+	  this->__shared_ptr<_Tp>::operator=(__r);
+	  return *this;
+	}
+#endif
+    };
+
+  // 2.2.3.8 shared_ptr specialized algorithms.
+  template<typename _Tp>
+    inline void
+    swap(__shared_ptr<_Tp>& __a, __shared_ptr<_Tp>& __b)
+    { __a.swap(__b); }
+
+  template<typename _Tp, typename _Tp1>
+    inline shared_ptr<_Tp>
+    static_pointer_cast(const shared_ptr<_Tp1>& __r)
+    { return shared_ptr<_Tp>(__r, __static_cast_tag()); }
+
+  template<typename _Tp, typename _Tp1>
+    inline shared_ptr<_Tp>
+    const_pointer_cast(const shared_ptr<_Tp1>& __r)
+    { return shared_ptr<_Tp>(__r, __const_cast_tag()); }
+
+  template<typename _Tp, typename _Tp1>
+    inline shared_ptr<_Tp>
+    dynamic_pointer_cast(const shared_ptr<_Tp1>& __r)
+    { return shared_ptr<_Tp>(__r, __dynamic_cast_tag()); }
+
+
+  // The actual weak_ptr, with forwarding constructors and
+  // assignment operators.
+  template<typename _Tp>
+    class weak_ptr
+    : public __weak_ptr<_Tp>
+    {
+    public:
+      weak_ptr()
+      : __weak_ptr<_Tp>() { }
+      
+      template<typename _Tp1>
+        weak_ptr(const weak_ptr<_Tp1>& __r)
+	: __weak_ptr<_Tp>(__r) { }
+
+      template<typename _Tp1>
+        weak_ptr(const shared_ptr<_Tp1>& __r)
+	: __weak_ptr<_Tp>(__r) { }
+
+      template<typename _Tp1>
+        weak_ptr&
+        operator=(const weak_ptr<_Tp1>& __r) // never throws
+        {
+	  this->__weak_ptr<_Tp>::operator=(__r);
+	  return *this;
+	}
+
+      template<typename _Tp1>
+        weak_ptr&
+        operator=(const shared_ptr<_Tp1>& __r) // never throws
+        {
+	  this->__weak_ptr<_Tp>::operator=(__r);
+	  return *this;
+	}
+
+      shared_ptr<_Tp>
+      lock() const // never throws
+      {
+#ifdef __GTHREADS
+	if (this->expired())
+	  return shared_ptr<_Tp>();
+
+	__try
+	  {
+	    return shared_ptr<_Tp>(*this);
+	  }
+	__catch(const bad_weak_ptr&)
+	  {
+	    return shared_ptr<_Tp>();
+	  }
+#else
+	return this->expired() ? shared_ptr<_Tp>()
+	                       : shared_ptr<_Tp>(*this);
+#endif
+      }
+    };
+
+  template<typename _Tp>
+    class enable_shared_from_this
+    {
+    protected:
+      enable_shared_from_this() { }
+      
+      enable_shared_from_this(const enable_shared_from_this&) { }
+
+      enable_shared_from_this&
+      operator=(const enable_shared_from_this&)
+      { return *this; }
+
+      ~enable_shared_from_this() { }
+
+    public:
+      shared_ptr<_Tp>
+      shared_from_this()
+      { return shared_ptr<_Tp>(this->_M_weak_this); }
+
+      shared_ptr<const _Tp>
+      shared_from_this() const
+      { return shared_ptr<const _Tp>(this->_M_weak_this); }
+
+    private:
+      template<typename _Tp1>
+        void
+        _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const
+        { _M_weak_this._M_assign(__p, __n); }
+
+      template<typename _Tp1>
+        friend void
+        __enable_shared_from_this_helper(const __shared_count<>& __pn,
+					 const enable_shared_from_this* __pe,
+					 const _Tp1* __px)
+        {
+	  if (__pe != 0)
+	    __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
+	}
+
+      mutable weak_ptr<_Tp>  _M_weak_this;
+    };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _TR1_SHARED_PTR_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/special_function_util.h b/gcc-4.9/libstdc++-v3/include/tr1/special_function_util.h
new file mode 100644
index 0000000..3c5ca6d
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/special_function_util.h
@@ -0,0 +1,135 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/special_function_util.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/cmath}
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on numerous mathematics books.
+
+#ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
+#define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+  namespace __detail
+  {
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+    /// A class to encapsulate type dependent floating point
+    /// constants.  Not everything will be able to be expressed as
+    /// type logic.
+    template<typename _Tp>
+    struct __floating_point_constant
+    {
+      static const _Tp __value;
+    };
+
+
+    /// A structure for numeric constants.
+    template<typename _Tp>
+      struct __numeric_constants
+      {
+        ///  Constant @f$ \pi @f$.
+        static _Tp __pi() throw()
+        { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }
+        ///  Constant @f$ \pi / 2 @f$.
+        static _Tp __pi_2() throw()
+        { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }
+        ///  Constant @f$ \pi / 3 @f$.
+        static _Tp __pi_3() throw()
+        { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }
+        ///  Constant @f$ \pi / 4 @f$.
+        static _Tp __pi_4() throw()
+        { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }
+        ///  Constant @f$ 1 / \pi @f$.
+        static _Tp __1_pi() throw()
+        { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }
+        ///  Constant @f$ 2 / \sqrt(\pi) @f$.
+        static _Tp __2_sqrtpi() throw()
+        { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }
+        ///  Constant @f$ \sqrt(2) @f$.
+        static _Tp __sqrt2() throw()
+        { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }
+        ///  Constant @f$ \sqrt(3) @f$.
+        static _Tp __sqrt3() throw()
+        { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }
+        ///  Constant @f$ \sqrt(\pi/2) @f$.
+        static _Tp __sqrtpio2() throw()
+        { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }
+        ///  Constant @f$ 1 / sqrt(2) @f$.
+        static _Tp __sqrt1_2() throw()
+        { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }
+        ///  Constant @f$ \log(\pi) @f$.
+        static _Tp __lnpi() throw()
+        { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }
+        ///  Constant Euler's constant @f$ \gamma_E @f$.
+        static _Tp __gamma_e() throw()
+        { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }
+        ///  Constant Euler-Mascheroni @f$ e @f$
+        static _Tp __euler() throw()
+        { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
+      };
+
+
+#if _GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+
+    /// This is a wrapper for the isnan function. Otherwise, for NaN,
+    /// all comparisons result in false. If/when we build a std::isnan
+    /// out of intrinsics, this will disappear completely in favor of
+    /// std::isnan.
+    template<typename _Tp>
+    inline bool __isnan(_Tp __x)
+    { return std::isnan(__x); }
+
+#else
+
+    template<typename _Tp>
+    inline bool __isnan(const _Tp __x)
+    { return __builtin_isnan(__x); }
+
+    template<>
+    inline bool __isnan<float>(float __x)
+    { return __builtin_isnanf(__x); }
+
+    template<>
+    inline bool __isnan<long double>(long double __x)
+    { return __builtin_isnanl(__x); }
+
+#endif
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+  } // namespace __detail
+}
+}
+
+#endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
+
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/stdarg.h b/gcc-4.9/libstdc++-v3/include/tr1/stdarg.h
new file mode 100644
index 0000000..abb3cff
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/stdarg.h
@@ -0,0 +1,34 @@
+// TR1 stdarg.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/stdarg.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDARG_H
+#define _TR1_STDARG_H 1
+
+#include <tr1/cstdarg>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/stdbool.h b/gcc-4.9/libstdc++-v3/include/tr1/stdbool.h
new file mode 100644
index 0000000..354effa
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/stdbool.h
@@ -0,0 +1,34 @@
+// TR1 stdbool.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/stdbool.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDBOOL_H
+#define _TR1_STDBOOL_H 1
+
+#include <tr1/cstdbool>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/stdint.h b/gcc-4.9/libstdc++-v3/include/tr1/stdint.h
new file mode 100644
index 0000000..e97145b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/stdint.h
@@ -0,0 +1,34 @@
+// TR1 stdint.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/stdint.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDINT_H
+#define _TR1_STDINT_H 1
+
+#include <tr1/cstdint>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/stdio.h b/gcc-4.9/libstdc++-v3/include/tr1/stdio.h
new file mode 100644
index 0000000..6640af9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/stdio.h
@@ -0,0 +1,34 @@
+// TR1 stdio.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/stdio.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDIO_H
+#define _TR1_STDIO_H 1
+
+#include <tr1/cstdio>
+
+#endif
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/stdlib.h b/gcc-4.9/libstdc++-v3/include/tr1/stdlib.h
new file mode 100644
index 0000000..c50c363
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/stdlib.h
@@ -0,0 +1,52 @@
+// TR1 stdlib.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/stdlib.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_STDLIB_H
+#define _GLIBCXX_TR1_STDLIB_H 1
+
+#include <tr1/cstdlib>
+
+#if _GLIBCXX_HOSTED
+
+#if _GLIBCXX_USE_C99
+
+using std::tr1::atoll;
+using std::tr1::strtoll;
+using std::tr1::strtoull;
+
+using std::tr1::abs;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+using std::tr1::div;
+#endif
+
+#endif
+
+#endif
+
+#endif // _GLIBCXX_TR1_STDLIB_H
+
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/tgmath.h b/gcc-4.9/libstdc++-v3/include/tr1/tgmath.h
new file mode 100644
index 0000000..063f342
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/tgmath.h
@@ -0,0 +1,34 @@
+// TR1 tgmath.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/tgmath.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_TGMATH_H
+#define _GLIBCXX_TR1_TGMATH_H 1
+
+#include <tr1/ctgmath>
+
+#endif // _GLIBCXX_TR1_TGMATH_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/tuple b/gcc-4.9/libstdc++-v3/include/tr1/tuple
new file mode 100644
index 0000000..312d887
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/tuple
@@ -0,0 +1,426 @@
+// class template tuple -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/tuple
+*  This is a TR1 C++ Library header.
+*/
+
+// Chris Jefferson <chris@bubblescope.net>
+// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
+
+#ifndef _GLIBCXX_TR1_TUPLE
+#define _GLIBCXX_TR1_TUPLE 1
+
+#pragma GCC system_header
+
+#include <utility>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Adds a const reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_c_ref
+    { typedef const _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_c_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  // Adds a reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_ref
+    { typedef _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  /**
+   * Contains the actual implementation of the @c tuple template, stored
+   * as a recursive inheritance hierarchy from the first element (most
+   * derived class) to the last (least derived class). The @c Idx
+   * parameter gives the 0-based index of the element stored at this
+   * point in the hierarchy; we use it to implement a constant-time
+   * get() operation.
+   */
+  template<int _Idx, typename... _Elements>
+    struct _Tuple_impl; 
+
+  /**
+   * Zero-element tuple implementation. This is the basis case for the 
+   * inheritance recursion.
+   */
+  template<int _Idx>
+    struct _Tuple_impl<_Idx> { };
+
+  /**
+   * Recursive tuple implementation. Here we store the @c Head element
+   * and derive from a @c Tuple_impl containing the remaining elements
+   * (which contains the @c Tail).
+   */
+  template<int _Idx, typename _Head, typename... _Tail>
+    struct _Tuple_impl<_Idx, _Head, _Tail...>
+    : public _Tuple_impl<_Idx + 1, _Tail...>
+    {
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      
+      _Head _M_head;
+      
+      _Inherited&       _M_tail()       { return *this; }
+      const _Inherited& _M_tail() const { return *this; }
+      
+      _Tuple_impl() : _Inherited(), _M_head() { }
+      
+      explicit 
+      _Tuple_impl(typename __add_c_ref<_Head>::type __head,
+		  typename __add_c_ref<_Tail>::type... __tail)
+      : _Inherited(__tail...), _M_head(__head) { }
+
+      template<typename... _UElements>
+      _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+
+      _Tuple_impl(const _Tuple_impl& __in)
+      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+     
+      template<typename... _UElements>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+	  _M_head = __in._M_head;
+	  _M_tail() = __in._M_tail();
+	  return *this;
+	}
+
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+	_M_head = __in._M_head;
+	_M_tail() = __in._M_tail();
+	return *this;
+      }
+    };
+
+  template<typename... _Elements> 
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+    public:
+      tuple() : _Inherited() { }
+
+      explicit
+      tuple(typename __add_c_ref<_Elements>::type... __elements)
+      : _Inherited(__elements...) { }
+
+      template<typename... _UElements>
+        tuple(const tuple<_UElements...>& __in)
+	: _Inherited(__in) { }
+
+      tuple(const tuple& __in)
+      : _Inherited(__in) { }
+
+      template<typename... _UElements>
+        tuple&
+        operator=(const tuple<_UElements...>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+    };
+
+  template<> class tuple<> { };
+
+  // 2-element tuple, with construction and assignment from a pair.
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+    public:
+      tuple() : _Inherited() { }
+
+      explicit
+      tuple(typename __add_c_ref<_T1>::type __a1,
+	    typename __add_c_ref<_T2>::type __a2)
+      : _Inherited(__a1, __a2) { }
+
+      template<typename _U1, typename _U2>
+        tuple(const tuple<_U1, _U2>& __in)
+	: _Inherited(__in) { }
+
+      tuple(const tuple& __in)
+      : _Inherited(__in) { }
+
+      template<typename _U1, typename _U2>
+        tuple(const pair<_U1, _U2>& __in)
+	: _Inherited(_Tuple_impl<0, 
+		     typename __add_c_ref<_U1>::type,
+		     typename __add_c_ref<_U2>::type>(__in.first, 
+						      __in.second))
+        { }
+  
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const tuple<_U1, _U2>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const pair<_U1, _U2>& __in)
+        {
+	  this->_M_head = __in.first;
+	  this->_M_tail()._M_head = __in.second;
+	  return *this;
+	}
+    };
+
+  
+  /// Gives the type of the ith element of a given tuple type.
+  template<int __i, typename _Tp>
+    struct tuple_element;
+
+  /**
+   * Recursive case for tuple_element: strip off the first element in
+   * the tuple and retrieve the (i-1)th element of the remaining tuple.
+   */
+  template<int __i, typename _Head, typename... _Tail>
+    struct tuple_element<__i, tuple<_Head, _Tail...> >
+    : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+  /**
+   * Basis case for tuple_element: The first element is the one we're seeking.
+   */
+  template<typename _Head, typename... _Tail>
+    struct tuple_element<0, tuple<_Head, _Tail...> >
+    {
+      typedef _Head type;
+    };
+
+  /// Finds the size of a given tuple type.
+  template<typename _Tp>
+    struct tuple_size;
+
+  /// class tuple_size
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...> >
+    {
+      static const int value = sizeof...(_Elements);
+    };
+
+  template<typename... _Elements>
+    const int tuple_size<tuple<_Elements...> >::value;
+
+  template<int __i, typename _Head, typename... _Tail>
+    inline typename __add_ref<_Head>::type
+    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
+    {
+      return __t._M_head;
+    }
+
+  template<int __i, typename _Head, typename... _Tail>
+    inline typename __add_c_ref<_Head>::type
+    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
+    {
+      return __t._M_head;
+    }
+
+  // Return a reference (const reference) to the ith element of a tuple.
+  // Any const or non-const ref elements are returned with their original type.
+  template<int __i, typename... _Elements>
+    inline typename __add_ref<
+                      typename tuple_element<__i, tuple<_Elements...> >::type
+                    >::type
+    get(tuple<_Elements...>& __t)
+    { 
+      return __get_helper<__i>(__t); 
+    }
+
+  template<int __i, typename... _Elements>
+    inline typename __add_c_ref<
+                      typename tuple_element<__i, tuple<_Elements...> >::type
+                    >::type
+    get(const tuple<_Elements...>& __t)
+    {
+      return __get_helper<__i>(__t);
+    }
+
+  // This class helps construct the various comparison operations on tuples
+  template<int __check_equal_size, int __i, int __j,
+	   typename _Tp, typename _Up>
+    struct __tuple_compare;
+
+  template<int __i, int __j, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __j, _Tp, _Up>
+    {
+      static bool __eq(const _Tp& __t, const _Up& __u)
+      {
+	return (get<__i>(__t) == get<__i>(__u) &&
+		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
+      }
+     
+      static bool __less(const _Tp& __t, const _Up& __u)
+      {
+	return ((get<__i>(__t) < get<__i>(__u))
+		|| !(get<__i>(__u) < get<__i>(__t)) &&
+		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
+      }
+    };
+
+  template<int __i, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __i, _Tp, _Up>
+    {
+      static bool __eq(const _Tp&, const _Up&)
+      { return true; }
+     
+      static bool __less(const _Tp&, const _Up&)
+      { return false; }
+    };
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator==(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator<(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator!=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator>(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    { return __u < __t; }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator<=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator>=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t < __u); }
+
+  template<typename _Tp>
+    class reference_wrapper;
+
+  // Helper which adds a reference to a type when given a reference_wrapper
+  template<typename _Tp>
+    struct __strip_reference_wrapper
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename... _Elements>
+    inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+    make_tuple(_Elements... __args)
+    {
+      typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+        __result_type;
+      return __result_type(__args...);
+    }
+
+  template<typename... _Elements>
+    inline tuple<_Elements&...>
+    tie(_Elements&... __args)
+    {
+      return tuple<_Elements&...>(__args...);
+    }
+
+  // A class (and instance) which can be used in 'tie' when an element
+  // of a tuple is not required
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      _Swallow_assign&
+      operator=(const _Tp&)
+      { return *this; }
+  };
+
+  // TODO: Put this in some kind of shared file.
+  namespace
+  {
+    _Swallow_assign ignore;
+  }; // anonymous namespace
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_TUPLE
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/type_traits b/gcc-4.9/libstdc++-v3/include/tr1/type_traits
new file mode 100644
index 0000000..e25c670
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/type_traits
@@ -0,0 +1,687 @@
+// TR1 type_traits -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/type_traits
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_TYPE_TRAITS
+#define _GLIBCXX_TR1_TYPE_TRAITS 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup metaprogramming
+   * @{
+   */
+
+  struct __sfinae_types
+  {
+    typedef char __one;
+    typedef struct { char __arr[2]; } __two;
+  };
+
+#define _DEFINE_SPEC_0_HELPER                          \
+  template<>
+
+#define _DEFINE_SPEC_1_HELPER                          \
+  template<typename _Tp>
+
+#define _DEFINE_SPEC_2_HELPER                          \
+  template<typename _Tp, typename _Cp>
+
+#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value)    \
+  _DEFINE_SPEC_##_Order##_HELPER                       \
+    struct _Trait<_Type>                               \
+    : public integral_constant<bool, _Value> { };
+
+  // helper classes [4.3].
+
+  /// integral_constant
+  template<typename _Tp, _Tp __v>
+    struct integral_constant
+    {
+      static const _Tp                      value = __v;
+      typedef _Tp                           value_type;
+      typedef integral_constant<_Tp, __v>   type;
+    };
+  
+  /// typedef for true_type
+  typedef integral_constant<bool, true>     true_type;
+
+  /// typedef for false_type
+  typedef integral_constant<bool, false>    false_type;
+
+  template<typename _Tp, _Tp __v>
+    const _Tp integral_constant<_Tp, __v>::value;
+
+  /// remove_cv
+  template<typename>
+    struct remove_cv;
+
+  template<typename>
+    struct __is_void_helper
+    : public false_type { };
+  _DEFINE_SPEC(0, __is_void_helper, void, true)
+
+  // primary type categories [4.5.1].
+
+  /// is_void
+  template<typename _Tp>
+    struct is_void
+    : public integral_constant<bool, (__is_void_helper<typename
+				      remove_cv<_Tp>::type>::value)>
+    { };
+
+  template<typename>
+    struct __is_integral_helper
+    : public false_type { };
+  _DEFINE_SPEC(0, __is_integral_helper, bool, true)
+  _DEFINE_SPEC(0, __is_integral_helper, char, true)
+  _DEFINE_SPEC(0, __is_integral_helper, signed char, true)
+  _DEFINE_SPEC(0, __is_integral_helper, unsigned char, true)
+#ifdef _GLIBCXX_USE_WCHAR_T
+  _DEFINE_SPEC(0, __is_integral_helper, wchar_t, true)
+#endif
+  _DEFINE_SPEC(0, __is_integral_helper, short, true)
+  _DEFINE_SPEC(0, __is_integral_helper, unsigned short, true)
+  _DEFINE_SPEC(0, __is_integral_helper, int, true)
+  _DEFINE_SPEC(0, __is_integral_helper, unsigned int, true)
+  _DEFINE_SPEC(0, __is_integral_helper, long, true)
+  _DEFINE_SPEC(0, __is_integral_helper, unsigned long, true)
+  _DEFINE_SPEC(0, __is_integral_helper, long long, true)
+  _DEFINE_SPEC(0, __is_integral_helper, unsigned long long, true)
+
+  /// is_integral
+  template<typename _Tp>
+    struct is_integral
+    : public integral_constant<bool, (__is_integral_helper<typename
+				      remove_cv<_Tp>::type>::value)>
+    { };
+
+  template<typename>
+    struct __is_floating_point_helper
+    : public false_type { };
+  _DEFINE_SPEC(0, __is_floating_point_helper, float, true)
+  _DEFINE_SPEC(0, __is_floating_point_helper, double, true)
+  _DEFINE_SPEC(0, __is_floating_point_helper, long double, true)
+
+  /// is_floating_point
+  template<typename _Tp>
+    struct is_floating_point
+    : public integral_constant<bool, (__is_floating_point_helper<typename
+				      remove_cv<_Tp>::type>::value)>
+    { };
+
+  /// is_array
+  template<typename>
+    struct is_array
+    : public false_type { };
+
+  template<typename _Tp, std::size_t _Size>
+    struct is_array<_Tp[_Size]>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_array<_Tp[]>
+    : public true_type { };
+
+  template<typename>
+    struct __is_pointer_helper
+    : public false_type { };
+  _DEFINE_SPEC(1, __is_pointer_helper, _Tp*, true)
+
+  /// is_pointer
+  template<typename _Tp>
+    struct is_pointer
+    : public integral_constant<bool, (__is_pointer_helper<typename
+				      remove_cv<_Tp>::type>::value)>
+    { };
+
+  /// is_reference
+  template<typename _Tp>
+    struct is_reference;
+
+  /// is_function
+  template<typename _Tp>
+    struct is_function;
+
+  template<typename>
+    struct __is_member_object_pointer_helper
+    : public false_type { };
+  _DEFINE_SPEC(2, __is_member_object_pointer_helper, _Tp _Cp::*,
+	       !is_function<_Tp>::value)
+
+  /// is_member_object_pointer
+  template<typename _Tp>
+    struct is_member_object_pointer
+    : public integral_constant<bool, (__is_member_object_pointer_helper<
+				      typename remove_cv<_Tp>::type>::value)>
+    { };
+
+  template<typename>
+    struct __is_member_function_pointer_helper
+    : public false_type { };
+  _DEFINE_SPEC(2, __is_member_function_pointer_helper, _Tp _Cp::*,
+	       is_function<_Tp>::value)
+
+  /// is_member_function_pointer
+  template<typename _Tp>
+    struct is_member_function_pointer
+    : public integral_constant<bool, (__is_member_function_pointer_helper<
+				      typename remove_cv<_Tp>::type>::value)>
+    { };
+
+  /// is_enum
+  template<typename _Tp>
+    struct is_enum
+    : public integral_constant<bool, __is_enum(_Tp)>
+    { };
+
+  /// is_union
+  template<typename _Tp>
+    struct is_union
+    : public integral_constant<bool, __is_union(_Tp)>
+    { };
+
+  /// is_class
+  template<typename _Tp>
+    struct is_class
+    : public integral_constant<bool, __is_class(_Tp)>
+    { };
+
+  /// is_function
+  template<typename>
+    struct is_function
+    : public false_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) volatile>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) volatile>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const volatile>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const volatile>
+    : public true_type { };
+
+  // composite type traits [4.5.2].
+  
+  /// is_arithmetic
+  template<typename _Tp>
+    struct is_arithmetic
+    : public integral_constant<bool, (is_integral<_Tp>::value
+				      || is_floating_point<_Tp>::value)>
+    { };
+
+  /// is_fundamental
+  template<typename _Tp>
+    struct is_fundamental
+    : public integral_constant<bool, (is_arithmetic<_Tp>::value
+				      || is_void<_Tp>::value)>
+    { };
+
+  /// is_object
+  template<typename _Tp>
+    struct is_object
+    : public integral_constant<bool, !(is_function<_Tp>::value
+				       || is_reference<_Tp>::value
+				       || is_void<_Tp>::value)>
+    { };
+
+  /// is_member_pointer
+  template<typename _Tp>
+    struct is_member_pointer;
+
+  /// is_scalar
+  template<typename _Tp>
+    struct is_scalar
+    : public integral_constant<bool, (is_arithmetic<_Tp>::value
+				      || is_enum<_Tp>::value
+				      || is_pointer<_Tp>::value
+				      || is_member_pointer<_Tp>::value)>
+    { };
+
+  /// is_compound
+  template<typename _Tp>
+    struct is_compound
+    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
+
+  /// is_member_pointer
+  template<typename _Tp>
+    struct __is_member_pointer_helper
+    : public false_type { };
+  _DEFINE_SPEC(2, __is_member_pointer_helper, _Tp _Cp::*, true)
+
+  template<typename _Tp>
+  struct is_member_pointer
+    : public integral_constant<bool, (__is_member_pointer_helper<
+				      typename remove_cv<_Tp>::type>::value)>
+    { };
+
+  // type properties [4.5.3].
+  /// is_const
+  template<typename>
+    struct is_const
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_const<_Tp const>
+    : public true_type { };
+  
+  /// is_volatile
+  template<typename>
+    struct is_volatile
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_volatile<_Tp volatile>
+    : public true_type { };
+
+  /// is_empty
+  template<typename _Tp>
+    struct is_empty
+    : public integral_constant<bool, __is_empty(_Tp)>
+    { };
+
+  /// is_polymorphic
+  template<typename _Tp>
+    struct is_polymorphic
+    : public integral_constant<bool, __is_polymorphic(_Tp)>
+    { };
+
+  /// is_abstract
+  template<typename _Tp>
+    struct is_abstract
+    : public integral_constant<bool, __is_abstract(_Tp)>
+    { };
+
+  /// has_virtual_destructor
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    { };
+
+  /// alignment_of
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
+  
+  /// rank
+  template<typename>
+    struct rank
+    : public integral_constant<std::size_t, 0> { };
+   
+  template<typename _Tp, std::size_t _Size>
+    struct rank<_Tp[_Size]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct rank<_Tp[]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  /// extent
+  template<typename, unsigned _Uint = 0>
+    struct extent
+    : public integral_constant<std::size_t, 0> { };
+  
+  template<typename _Tp, unsigned _Uint, std::size_t _Size>
+    struct extent<_Tp[_Size], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? _Size : extent<_Tp,
+							   _Uint - 1>::value>
+    { };
+
+  template<typename _Tp, unsigned _Uint>
+    struct extent<_Tp[], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? 0 : extent<_Tp,
+						       _Uint - 1>::value>
+    { };
+
+  // relationships between types [4.6].
+
+  /// is_same
+  template<typename, typename>
+    struct is_same
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_same<_Tp, _Tp>
+    : public true_type { };
+
+  // const-volatile modifications [4.7.1].
+
+  /// remove_const
+  template<typename _Tp>
+    struct remove_const
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_const<_Tp const>
+    { typedef _Tp     type; };
+  
+  /// remove_volatile
+  template<typename _Tp>
+    struct remove_volatile
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_volatile<_Tp volatile>
+    { typedef _Tp     type; };
+  
+  /// remove_cv
+  template<typename _Tp>
+    struct remove_cv
+    {
+      typedef typename
+      remove_const<typename remove_volatile<_Tp>::type>::type     type;
+    };
+  
+  /// add_const
+  template<typename _Tp>
+    struct add_const
+    { typedef _Tp const     type; };
+   
+  /// add_volatile
+  template<typename _Tp>
+    struct add_volatile
+    { typedef _Tp volatile     type; };
+  
+  /// add_cv
+  template<typename _Tp>
+    struct add_cv
+    {
+      typedef typename
+      add_const<typename add_volatile<_Tp>::type>::type     type;
+    };
+
+  // array modifications [4.7.3].
+
+  /// remove_extent
+  template<typename _Tp>
+    struct remove_extent
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_extent<_Tp[_Size]>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_extent<_Tp[]>
+    { typedef _Tp     type; };
+
+  /// remove_all_extents
+  template<typename _Tp>
+    struct remove_all_extents
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_all_extents<_Tp[_Size]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+  template<typename _Tp>
+    struct remove_all_extents<_Tp[]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+  // pointer modifications [4.7.4].
+
+  template<typename _Tp, typename>
+    struct __remove_pointer_helper
+    { typedef _Tp     type; };
+
+  template<typename _Tp, typename _Up>
+    struct __remove_pointer_helper<_Tp, _Up*>
+    { typedef _Up     type; };
+
+  /// remove_pointer
+  template<typename _Tp>
+    struct remove_pointer
+    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
+    { };
+
+  template<typename>
+    struct remove_reference;
+
+  /// add_pointer
+  template<typename _Tp>
+    struct add_pointer
+    { typedef typename remove_reference<_Tp>::type*     type; };
+
+  template<typename>
+    struct is_reference
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_reference<_Tp&>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_pod
+    : public integral_constant<bool, __is_pod(_Tp) || is_void<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_constructor
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_copy
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_assign
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_destructor
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_constructor
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_copy
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_assign
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename>
+    struct __is_signed_helper
+    : public false_type { };
+  _DEFINE_SPEC(0, __is_signed_helper, signed char, true)
+  _DEFINE_SPEC(0, __is_signed_helper, short, true)
+  _DEFINE_SPEC(0, __is_signed_helper, int, true)
+  _DEFINE_SPEC(0, __is_signed_helper, long, true)
+  _DEFINE_SPEC(0, __is_signed_helper, long long, true)
+
+  template<typename _Tp>
+    struct is_signed
+    : public integral_constant<bool, (__is_signed_helper<typename
+				      remove_cv<_Tp>::type>::value)>
+    { };
+
+  template<typename>
+    struct __is_unsigned_helper
+    : public false_type { };
+  _DEFINE_SPEC(0, __is_unsigned_helper, unsigned char, true)
+  _DEFINE_SPEC(0, __is_unsigned_helper, unsigned short, true)
+  _DEFINE_SPEC(0, __is_unsigned_helper, unsigned int, true)
+  _DEFINE_SPEC(0, __is_unsigned_helper, unsigned long, true)
+  _DEFINE_SPEC(0, __is_unsigned_helper, unsigned long long, true)
+
+  template<typename _Tp>
+    struct is_unsigned
+    : public integral_constant<bool, (__is_unsigned_helper<typename
+				      remove_cv<_Tp>::type>::value)>
+    { };
+
+  template<typename _Base, typename _Derived>
+    struct __is_base_of_helper
+    {
+      typedef typename remove_cv<_Base>::type    _NoCv_Base;
+      typedef typename remove_cv<_Derived>::type _NoCv_Derived;
+      static const bool __value = (is_same<_Base, _Derived>::value
+				   || (__is_base_of(_Base, _Derived)
+				       && !is_same<_NoCv_Base,
+				                   _NoCv_Derived>::value));
+    };
+ 
+  template<typename _Base, typename _Derived>
+    struct is_base_of
+    : public integral_constant<bool,
+			       __is_base_of_helper<_Base, _Derived>::__value>
+    { };
+
+  template<typename _From, typename _To>
+    struct __is_convertible_simple
+    : public __sfinae_types
+    {
+    private:
+      static __one __test(_To);
+      static __two __test(...);
+      static _From __makeFrom();
+    
+    public:
+      static const bool __value = sizeof(__test(__makeFrom())) == 1;
+    };
+
+  template<typename _Tp>
+    struct add_reference;
+
+  template<typename _Tp>
+    struct __is_int_or_cref
+    {
+      typedef typename remove_reference<_Tp>::type __rr_Tp;
+      static const bool __value = (is_integral<_Tp>::value
+				   || (is_integral<__rr_Tp>::value
+				       && is_const<__rr_Tp>::value
+				       && !is_volatile<__rr_Tp>::value));
+    };
+
+  template<typename _From, typename _To,
+	   bool = (is_void<_From>::value || is_void<_To>::value
+		   || is_function<_To>::value || is_array<_To>::value
+		   // This special case is here only to avoid warnings.	
+		   || (is_floating_point<typename
+		       remove_reference<_From>::type>::value
+		       && __is_int_or_cref<_To>::__value))>
+    struct __is_convertible_helper
+    {
+      // "An imaginary lvalue of type From...".
+      static const bool __value = (__is_convertible_simple<typename
+				   add_reference<_From>::type, _To>::__value);
+    };
+
+  template<typename _From, typename _To>
+    struct __is_convertible_helper<_From, _To, true>
+    { static const bool __value = (is_void<_To>::value
+				   || (__is_int_or_cref<_To>::__value
+				       && !is_void<_From>::value)); };
+
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public integral_constant<bool,
+			       __is_convertible_helper<_From, _To>::__value>
+    { };
+
+  // reference modifications [4.7.2].
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp     type; };
+
+  // NB: Careful with reference to void.
+  template<typename _Tp, bool = (is_void<_Tp>::value
+				 || is_reference<_Tp>::value)>
+    struct __add_reference_helper
+    { typedef _Tp&    type; };
+
+  template<typename _Tp>
+    struct __add_reference_helper<_Tp, true>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct add_reference
+    : public __add_reference_helper<_Tp>
+    { };
+
+  // other transformations [4.8].
+  template<std::size_t _Len, std::size_t _Align>
+    struct aligned_storage
+    { 
+      union type
+      {
+	unsigned char __data[_Len];
+	struct __attribute__((__aligned__((_Align)))) { } __align; 
+      };
+    };
+
+#undef _DEFINE_SPEC_0_HELPER
+#undef _DEFINE_SPEC_1_HELPER
+#undef _DEFINE_SPEC_2_HELPER
+#undef _DEFINE_SPEC
+
+  /// @} group metaprogramming
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_TYPE_TRAITS
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/unordered_map b/gcc-4.9/libstdc++-v3/include/tr1/unordered_map
new file mode 100644
index 0000000..c9c2b76
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/unordered_map
@@ -0,0 +1,44 @@
+// TR1 unordered_map -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/unordered_map
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_UNORDERED_MAP
+#define _GLIBCXX_TR1_UNORDERED_MAP 1
+
+#pragma GCC system_header
+
+#include <utility>
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <bits/stringfwd.h>
+#include <tr1/type_traits>
+#include <tr1/functional_hash.h>
+#include <tr1/hashtable.h>
+#include <tr1/unordered_map.h>
+
+#endif // _GLIBCXX_TR1_UNORDERED_MAP
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/unordered_map.h b/gcc-4.9/libstdc++-v3/include/tr1/unordered_map.h
new file mode 100644
index 0000000..38a23f8
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/unordered_map.h
@@ -0,0 +1,278 @@
+// TR1 unordered_map implementation -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/unordered_map.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/unordered_map}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // NB: When we get typedef templates these class definitions
+  // will be unnecessary.
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+	   bool __cache_hash_code = false>
+    class __unordered_map
+    : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
+			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, false, true>
+    {
+      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
+			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, false, true>
+	_Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      __unordered_map(size_type __n = 10,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(),
+	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+      { }
+
+      template<typename _InputIterator>
+	__unordered_map(_InputIterator __f, _InputIterator __l,
+			size_type __n = 10,
+			const hasher& __hf = hasher(),
+			const key_equal& __eql = key_equal(),
+			const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(),
+		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+	{ }
+    };
+
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+	   bool __cache_hash_code = false>
+    class __unordered_multimap
+    : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
+			_Alloc,
+			std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, false, false>
+    {
+      typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
+			 _Alloc,
+			 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, false, false>
+	_Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      __unordered_multimap(size_type __n = 10,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(),
+	      __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+      { }
+
+
+      template<typename _InputIterator>
+	__unordered_multimap(_InputIterator __f, _InputIterator __l,
+			     typename _Base::size_type __n = 0,
+			     const hasher& __hf = hasher(),
+			     const key_equal& __eql = key_equal(),
+			     const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(),
+		__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+	{ }
+    };
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __x,
+	 __unordered_map<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __x,
+	 __unordered_multimap<_Key, _Tp, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+
+  /**
+   *  @brief A standard container composed of unique keys (containing
+   *  at most one of each key value) that associates values of another type
+   *  with the keys.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   *  @param  Key  Type of key objects.
+   *  @param  Tp  Type of mapped objects.
+   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
+   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
+   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
+   *
+   * The resulting value type of the container is std::pair<const Key, Tp>.
+   */
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_map
+    : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      unordered_map(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __f, _InputIterator __l,
+		      size_type __n = 10,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+	{ }
+    };
+
+  /**
+   *  @brief A standard container composed of equivalent keys
+   *  (possibly containing multiple of each key value) that associates
+   *  values of another type with the keys.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   *  @param  Key  Type of key objects.
+   *  @param  Tp  Type of mapped objects.
+   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
+   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
+   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
+   *
+   * The resulting value type of the container is std::pair<const Key, Tp>.
+   */
+  template<class _Key, class _Tp,
+	   class _Hash = hash<_Key>,
+	   class _Pred = std::equal_to<_Key>,
+	   class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_multimap
+    : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      unordered_multimap(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __f, _InputIterator __l,
+			   typename _Base::size_type __n = 0,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+	{ }
+
+    };
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/unordered_set b/gcc-4.9/libstdc++-v3/include/tr1/unordered_set
new file mode 100644
index 0000000..470d96b
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/unordered_set
@@ -0,0 +1,44 @@
+// TR1 unordered_set -*- C++ -*-
+
+// Copyright (C) 2005-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/unordered_set
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_UNORDERED_SET
+#define _GLIBCXX_TR1_UNORDERED_SET 1
+
+#pragma GCC system_header
+
+#include <utility>
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <bits/stringfwd.h>
+#include <tr1/type_traits>
+#include <tr1/functional_hash.h>
+#include <tr1/hashtable.h>
+#include <tr1/unordered_set.h>
+
+#endif // _GLIBCXX_TR1_UNORDERED_SET
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/unordered_set.h b/gcc-4.9/libstdc++-v3/include/tr1/unordered_set.h
new file mode 100644
index 0000000..84336f4
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/unordered_set.h
@@ -0,0 +1,267 @@
+// TR1 unordered_set implementation -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/unordered_set.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr1/unordered_set}
+ */
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // NB: When we get typedef templates these class definitions
+  // will be unnecessary.
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value>,
+	   bool __cache_hash_code = false>
+    class __unordered_set
+    : public _Hashtable<_Value, _Value, _Alloc,
+			std::_Identity<_Value>, _Pred,
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, true, true>
+    {
+      typedef _Hashtable<_Value, _Value, _Alloc,
+			 std::_Identity<_Value>, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, true, true>
+	_Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      __unordered_set(size_type __n = 10,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(), __eql,
+	      std::_Identity<_Value>(), __a)
+      { }
+
+      template<typename _InputIterator>
+	__unordered_set(_InputIterator __f, _InputIterator __l,
+			size_type __n = 10,
+			const hasher& __hf = hasher(),
+			const key_equal& __eql = key_equal(),
+			const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(), __eql,
+		std::_Identity<_Value>(), __a)
+	{ }
+    };
+
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value>,
+	   bool __cache_hash_code = false>
+    class __unordered_multiset
+    : public _Hashtable<_Value, _Value, _Alloc,
+			std::_Identity<_Value>, _Pred,
+			_Hash, __detail::_Mod_range_hashing,
+			__detail::_Default_ranged_hash,
+			__detail::_Prime_rehash_policy,
+			__cache_hash_code, true, false>
+    {
+      typedef _Hashtable<_Value, _Value, _Alloc,
+			 std::_Identity<_Value>, _Pred,
+			 _Hash, __detail::_Mod_range_hashing,
+			 __detail::_Default_ranged_hash,
+			 __detail::_Prime_rehash_policy,
+			 __cache_hash_code, true, false>
+	_Base;
+
+    public:
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      __unordered_multiset(size_type __n = 10,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __detail::_Mod_range_hashing(),
+	      __detail::_Default_ranged_hash(), __eql,
+	      std::_Identity<_Value>(), __a)
+      { }
+
+
+      template<typename _InputIterator>
+	__unordered_multiset(_InputIterator __f, _InputIterator __l,
+			     typename _Base::size_type __n = 0,
+			     const hasher& __hf = hasher(),
+			     const key_equal& __eql = key_equal(),
+			     const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
+		__detail::_Default_ranged_hash(), __eql,
+		std::_Identity<_Value>(), __a)
+	{ }
+    };
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap(__unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __x,
+	 __unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc,
+	   bool __cache_hash_code>
+    inline void
+    swap(__unordered_multiset<_Value, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __x,
+	 __unordered_multiset<_Value, _Hash, _Pred,
+	 _Alloc, __cache_hash_code>& __y)
+    { __x.swap(__y); }
+
+
+  /**
+   *  @brief A standard container composed of unique keys (containing
+   *  at most one of each key value) in which the elements' keys are
+   *  the elements themselves.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   *  @param  Value  Type of key objects.
+   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
+   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
+   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
+   */
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value> >
+    class unordered_set
+    : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_set<_Value, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      unordered_set(size_type __n = 10,
+		    const hasher& __hf = hasher(),
+		    const key_equal& __eql = key_equal(),
+		    const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __f, _InputIterator __l,
+		      size_type __n = 10,
+		      const hasher& __hf = hasher(),
+		      const key_equal& __eql = key_equal(),
+		      const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+	{ }
+    };
+
+  /**
+   *  @brief A standard container composed of equivalent keys
+   *  (possibly containing multiple of each key value) in which the
+   *  elements' keys are the elements themselves.
+   *
+   *  @ingroup unordered_associative_containers
+   *
+   *  Meets the requirements of a <a href="tables.html#65">container</a>, and
+   *  <a href="tables.html#xx">unordered associative container</a>
+   *
+   *  @param  Value  Type of key objects.
+   *  @param  Hash  Hashing function object type, defaults to hash<Value>.
+   *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
+   *  @param  Alloc  Allocator type, defaults to allocator<Key>.
+   */
+  template<class _Value,
+	   class _Hash = hash<_Value>,
+	   class _Pred = std::equal_to<_Value>,
+	   class _Alloc = std::allocator<_Value> >
+    class unordered_multiset
+    : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc>  _Base;
+
+    public:
+      typedef typename _Base::value_type      value_type;
+      typedef typename _Base::size_type       size_type;
+      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::key_equal       key_equal;
+      typedef typename _Base::allocator_type  allocator_type;
+
+      explicit
+      unordered_multiset(size_type __n = 10,
+			 const hasher& __hf = hasher(),
+			 const key_equal& __eql = key_equal(),
+			 const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __f, _InputIterator __l,
+			   typename _Base::size_type __n = 0,
+			   const hasher& __hf = hasher(),
+			   const key_equal& __eql = key_equal(),
+			   const allocator_type& __a = allocator_type())
+	: _Base(__f, __l, __n, __hf, __eql, __a)
+	{ }
+    };
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+	 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+  template<class _Value, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/utility b/gcc-4.9/libstdc++-v3/include/tr1/utility
new file mode 100644
index 0000000..872c1a7
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/utility
@@ -0,0 +1,108 @@
+// TR1 utility -*- C++ -*-
+
+// Copyright (C) 2004-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/utility
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_UTILITY
+#define _GLIBCXX_TR1_UTILITY 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <bits/stl_relops.h>
+#include <bits/stl_pair.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<class _Tp>
+    class tuple_size;
+
+  template<int _Int, class _Tp>
+    class tuple_element;
+
+   // Various functions which give std::pair a tuple-like interface.
+  template<class _Tp1, class _Tp2>
+    struct tuple_size<std::pair<_Tp1, _Tp2> >
+    { static const int value = 2; };
+
+  template<class _Tp1, class _Tp2>
+    const int
+    tuple_size<std::pair<_Tp1, _Tp2> >::value;
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<0, std::pair<_Tp1, _Tp2> >
+    { typedef _Tp1 type; };
+ 
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<1, std::pair<_Tp1, _Tp2> >
+    { typedef _Tp2 type; };
+
+  template<int _Int>
+    struct __pair_get;
+
+  template<>
+    struct __pair_get<0>
+    {
+      template<typename _Tp1, typename _Tp2>
+      static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.first; }
+
+      template<typename _Tp1, typename _Tp2>
+      static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.first; }
+    };
+
+  template<>
+    struct __pair_get<1>
+    {
+      template<typename _Tp1, typename _Tp2>
+      static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.second; }
+
+      template<typename _Tp1, typename _Tp2>
+      static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
+      { return __pair.second; }
+    };
+
+  template<int _Int, class _Tp1, class _Tp2>
+    inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
+    get(std::pair<_Tp1, _Tp2>& __in)
+    { return __pair_get<_Int>::__get(__in); }
+
+  template<int _Int, class _Tp1, class _Tp2>
+    inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
+    get(const std::pair<_Tp1, _Tp2>& __in)
+    { return __pair_get<_Int>::__const_get(__in); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR1_UTILITY
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/wchar.h b/gcc-4.9/libstdc++-v3/include/tr1/wchar.h
new file mode 100644
index 0000000..a3f5e57
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/wchar.h
@@ -0,0 +1,34 @@
+// TR1 wchar.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/wchar.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_WCHAR_H
+#define _GLIBCXX_TR1_WCHAR_H 1
+
+#include <tr1/cwchar>
+
+#endif // _GLIBCXX_TR1_WCHAR_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr1/wctype.h b/gcc-4.9/libstdc++-v3/include/tr1/wctype.h
new file mode 100644
index 0000000..f10d2be
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr1/wctype.h
@@ -0,0 +1,34 @@
+// TR1 wctype.h -*- C++ -*-
+
+// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr1/wctype.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_WCTYPE_H
+#define _GLIBCXX_TR1_WCTYPE_H 1
+
+#include <tr1/cwctype>
+
+#endif // _GLIBCXX_TR1_WCTYPE_H
diff --git a/gcc-4.9/libstdc++-v3/include/tr2/bool_set b/gcc-4.9/libstdc++-v3/include/tr2/bool_set
new file mode 100644
index 0000000..d97714c
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr2/bool_set
@@ -0,0 +1,320 @@
+// TR2 <bool_set> -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr2/bool_set
+ *  This is a TR2 C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TR2_BOOL_SET
+#define _GLIBCXX_TR2_BOOL_SET 1
+
+#pragma GCC system_header
+
+#include <typeinfo>
+#include <iostream>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  bool_set
+   *
+   *  See N2136, Bool_set: multi-valued logic
+   *  by Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion.
+   *
+   *  The implicit conversion to bool is slippery!  I may use the new
+   *  explicit conversion.  This has been specialized in the language
+   *  so that in contexts requiring a bool the conversion happens
+   *  implicitly.  Thus most objections should be eliminated.
+   */
+  class bool_set
+  {
+  public:
+
+    ///  Default constructor.
+    constexpr bool_set() : _M_b(_S_false) { }
+
+    ///  Constructor from bool.
+    constexpr bool_set(bool __t) : _M_b(_Bool_set_val(__t)) { }
+
+    // I'm not sure about this.
+    bool contains(bool_set __b) const
+    { return this->is_singleton() && this->equals(__b); }
+
+    ///  Return true if states are equal.
+    bool equals(bool_set __b) const
+    { return __b._M_b == _M_b; }
+
+    ///  Return true if this is empty.
+    bool is_emptyset() const
+    { return _M_b == _S_empty; }
+
+    ///  Return true if this is indeterminate.
+    bool is_indeterminate() const
+    { return _M_b == _S_indet; }
+
+    ///  Return true if this is false or true (normal boolean).
+    bool is_singleton() const
+    { return _M_b == _S_false || _M_b == _S_true_; }
+
+    ///  Conversion to bool.
+    //explicit
+    operator bool() const
+    {
+      if (! is_singleton())
+	throw std::bad_cast();
+      return _M_b;
+    }
+
+    ///
+    static bool_set indeterminate()
+    {
+      bool_set __b;
+      __b._M_b = _S_indet;
+      return __b;
+    }
+
+    ///
+    static bool_set emptyset()
+    {
+      bool_set __b;
+      __b._M_b = _S_empty;
+      return __b;
+    }
+
+    friend bool_set
+    operator!(bool_set __b)
+    { return __b._M_not(); }
+
+    friend bool_set
+    operator^(bool_set __s, bool_set __t)
+    { return __s._M_xor(__t); }
+
+    friend bool_set
+    operator|(bool_set __s, bool_set __t)
+    { return __s._M_or(__t); }
+
+    friend bool_set
+    operator&(bool_set __s, bool_set __t)
+    { return __s._M_and(__t); }
+
+    friend bool_set
+    operator==(bool_set __s, bool_set __t)
+    { return __s._M_eq(__t); }
+
+
+    //  These overloads replace the facet additions in the paper!
+
+    template<typename CharT, typename Traits>
+      friend std::basic_ostream<CharT, Traits>&
+      operator<<(std::basic_ostream<CharT, Traits>& __out, bool_set __b)
+      {
+	int __a = __b._M_b;
+	__out << __a;
+      }
+
+    template<typename CharT, typename Traits>
+      friend std::basic_istream<CharT, Traits>&
+      operator>>(std::basic_istream<CharT, Traits>& __in, bool_set& __b)
+      {
+	long __c;
+	__in >> __c;
+	if (__c >= _S_false && __c < _S_empty)
+	  __b._M_b = static_cast<_Bool_set_val>(__c);
+      }
+
+  private:
+
+    ///
+    enum _Bool_set_val: unsigned char
+    {
+      _S_false = 0,
+      _S_true_ = 1,
+      _S_indet = 2,
+      _S_empty = 3
+    };
+
+    ///  Bool set state.
+    _Bool_set_val _M_b;
+
+    ///
+    bool_set(_Bool_set_val __c) : _M_b(__c) { }
+
+    ///
+    bool_set _M_not() const
+    { return _S_not[this->_M_b]; }
+
+    ///
+    bool_set _M_xor(bool_set __b) const
+    { return _S_xor[this->_M_b][__b._M_b]; }
+
+    ///
+    bool_set _M_or(bool_set __b) const
+    { return _S_or[this->_M_b][__b._M_b]; }
+
+    ///
+    bool_set _M_and(bool_set __b) const
+    { return _S_and[this->_M_b][__b._M_b]; }
+
+    ///
+    bool_set _M_eq(bool_set __b) const
+    { return _S_eq[this->_M_b][__b._M_b]; }
+
+    ///
+    static _Bool_set_val _S_not[4];
+
+    ///
+    static _Bool_set_val _S_xor[4][4];
+
+    ///
+    static _Bool_set_val _S_or[4][4];
+
+    ///
+    static _Bool_set_val _S_and[4][4];
+
+    ///
+    static _Bool_set_val _S_eq[4][4];
+  };
+
+  //  20.2.3.2 bool_set values
+
+  inline bool
+  contains(bool_set __s, bool_set __t)
+  { return __s.contains(__t); }
+
+  inline bool
+  equals(bool_set __s, bool_set __t)
+  { return __s.equals(__t); }
+
+  inline bool
+  is_emptyset(bool_set __b)
+  { return __b.is_emptyset(); }
+
+  inline bool
+  is_indeterminate(bool_set __b)
+  { return __b.is_indeterminate(); }
+
+  inline bool
+  is_singleton(bool_set __b)
+  { return __b.is_singleton(); }
+
+  inline bool
+  certainly(bool_set __b)
+  { return ! __b.contains(false); }
+
+  inline bool
+  possibly(bool_set __b)
+  { return __b.contains(true); }
+
+
+  //  20.2.3.3 bool_set set operations
+
+  inline bool_set
+  set_union(bool __s, bool_set __t)
+  { return bool_set(__s) | __t; }
+
+  inline bool_set
+  set_union(bool_set __s, bool __t)
+  { return __s | bool_set(__t); }
+
+  inline bool_set
+  set_union(bool_set __s, bool_set __t)
+  { return __s | __t; }
+
+  inline bool_set
+  set_intersection(bool __s, bool_set __t)
+  { return bool_set(__s) & __t; }
+
+  inline bool_set
+  set_intersection(bool_set __s, bool __t)
+  { return __s & bool_set(__t); }
+
+  inline bool_set
+  set_intersection(bool_set __s, bool_set __t)
+  { return __s & __t; }
+
+  inline bool_set
+  set_complement(bool_set __b)
+  { return ! __b; }
+
+
+  //  20.2.3.4 bool_set logical operators
+
+  inline bool_set
+  operator^(bool __s, bool_set __t)
+  { return bool_set(__s) ^ __t; }
+
+  inline bool_set
+  operator^(bool_set __s, bool __t)
+  { return __s ^ bool_set(__t); }
+
+  inline bool_set
+  operator|(bool __s, bool_set __t)
+  { return bool_set(__s) | __t; }
+
+  inline bool_set
+  operator|(bool_set __s, bool __t)
+  { return __s | bool_set(__t); }
+
+  inline bool_set
+  operator&(bool __s, bool_set __t)
+  { return bool_set(__s) & __t; }
+
+  inline bool_set
+  operator&(bool_set __s, bool __t)
+  { return __s & bool_set(__t); }
+
+
+  //  20.2.3.5 bool_set relational operators
+
+  inline bool_set
+  operator==(bool __s, bool_set __t)
+  { return bool_set(__s) == __t; }
+
+  inline bool_set
+  operator==(bool_set __s, bool __t)
+  { return __s == bool_set(__t); }
+
+  inline bool_set
+  operator!=(bool __s, bool_set __t)
+  { return ! (__s == __t); }
+
+  inline bool_set
+  operator!=(bool_set __s, bool __t)
+  { return ! (__s == __t); }
+
+  inline bool_set
+  operator!=(bool_set __s, bool_set __t)
+  { return ! (__s == __t); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#include <tr2/bool_set.tcc>
+
+#endif // _GLIBCXX_TR2_BOOL_SET
diff --git a/gcc-4.9/libstdc++-v3/include/tr2/bool_set.tcc b/gcc-4.9/libstdc++-v3/include/tr2/bool_set.tcc
new file mode 100644
index 0000000..7068e8f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr2/bool_set.tcc
@@ -0,0 +1,277 @@
+// TR2 <bool_set> support files -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr2/bool_set.tcc
+ *  This is a TR2 C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TR2_BOOL_SET_TCC
+#define _GLIBCXX_TR2_BOOL_SET_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  bool_set::_Bool_set_val
+  bool_set::_S_not[4] =
+  { _S_true_, _S_false, _S_indet, _S_empty };
+
+  bool_set::_Bool_set_val
+  bool_set::_S_xor[4][4] =
+  { { _S_false, _S_true_, _S_indet, _S_empty },
+    { _S_true_, _S_false, _S_indet, _S_empty },
+    { _S_indet, _S_indet, _S_indet, _S_empty },
+    { _S_empty, _S_empty, _S_empty, _S_empty } };
+
+  bool_set::_Bool_set_val
+  bool_set::_S_or[4][4] =
+  { { _S_false, _S_true_, _S_indet, _S_empty },
+    { _S_true_, _S_true_, _S_true_, _S_empty },
+    { _S_indet, _S_true_, _S_indet, _S_empty },
+    { _S_empty, _S_empty, _S_empty, _S_empty } };
+
+  bool_set::_Bool_set_val
+  bool_set::_S_and[4][4] =
+  { { _S_false, _S_false, _S_false, _S_empty },
+    { _S_false, _S_true_, _S_indet, _S_empty },
+    { _S_false, _S_indet, _S_indet, _S_empty },
+    { _S_empty, _S_empty, _S_empty, _S_empty } };
+
+  bool_set::_Bool_set_val
+  bool_set::_S_eq[4][4] =
+  { { _S_true_, _S_false, _S_indet, _S_empty },
+    { _S_false, _S_true_, _S_indet, _S_empty },
+    { _S_indet, _S_indet, _S_indet, _S_empty },
+    { _S_empty, _S_empty, _S_empty, _S_empty } };
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+//  I object to these things.
+//  The stuff in locale facets are for basic types.
+//  I think we could hack operator<< and operator>>.
+
+      /**
+       *  @brief  Numeric parsing.
+       *
+       *  Parses the input stream into the bool @a v.  It does so by calling
+       *  num_get::do_get().
+       *
+       *  If ios_base::boolalpha is set, attempts to read
+       *  ctype<CharT>::truename() or ctype<CharT>::falsename().  Sets
+       *  @a v to true or false if successful.  Sets err to
+       *  ios_base::failbit if reading the string fails.  Sets err to
+       *  ios_base::eofbit if the stream is emptied.
+       *
+       *  If ios_base::boolalpha is not set, proceeds as with reading a long,
+       *  except if the value is 1, sets @a v to true, if the value is 0, sets
+       *  @a v to false, and otherwise set err to ios_base::failbit.
+       *
+       *  @param  in  Start of input stream.
+       *  @param  end  End of input stream.
+       *  @param  io  Source of locale and flags.
+       *  @param  err  Error flags to set.
+       *  @param  v  Value to format and insert.
+       *  @return  Iterator after reading.
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+	  ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+       */
+/*
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+	   ios_base::iostate& __err, bool_set& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+	{
+	  // Parse bool values as long.
+	  // NB: We can't just call do_get(long) here, as it might
+	  // refer to a derived class.
+	  long __l = -1;
+	  __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+	  if (__c >= _S_false && __c < _S_empty)
+	    __b._M_b = static_cast<_Bool_set_val>(__c);
+	  else
+	    {
+	      // What should we do here?
+	      __v = true;
+	      __err = ios_base::failbit;
+	      if (__beg == __end)
+		__err |= ios_base::eofbit;
+	    }
+	}
+      else
+	{
+	  // Parse bool values as alphanumeric.
+	  typedef __numpunct_cache<_CharT>  __cache_type;
+	  __use_cache<__cache_type> __uc;
+	  const locale& __loc = __io._M_getloc();
+	  const __cache_type* __lc = __uc(__loc);
+
+	  bool __testf = true;
+	  bool __testt = true;
+	  bool __donef = __lc->_M_falsename_size == 0;
+	  bool __donet = __lc->_M_truename_size == 0;
+	  bool __testeof = false;
+	  size_t __n = 0;
+	  while (!__donef || !__donet)
+	    {
+	      if (__beg == __end)
+		{
+		  __testeof = true;
+		  break;
+		}
+
+	      const char_type __c = *__beg;
+
+	      if (!__donef)
+		__testf = __c == __lc->_M_falsename[__n];
+
+	      if (!__testf && __donet)
+		break;
+
+	      if (!__donet)
+		__testt = __c == __lc->_M_truename[__n];
+
+	      if (!__testt && __donef)
+		break;
+
+	      if (!__testt && !__testf)
+		break;
+
+	      ++__n;
+	      ++__beg;
+
+	      __donef = !__testf || __n >= __lc->_M_falsename_size;
+	      __donet = !__testt || __n >= __lc->_M_truename_size;
+	    }
+	  if (__testf && __n == __lc->_M_falsename_size && __n)
+	    {
+	      __v = false;
+	      if (__testt && __n == __lc->_M_truename_size)
+		__err = ios_base::failbit;
+	      else
+		__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+	    }
+	  else if (__testt && __n == __lc->_M_truename_size && __n)
+	    {
+	      __v = true;
+	      __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+	    }
+	  else
+	    {
+	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+	      // 23. Num_get overflow result.
+	      __v = false;
+	      __err = ios_base::failbit;
+	      if (__testeof)
+		__err |= ios_base::eofbit;
+	    }
+	}
+      return __beg;
+    }
+*/
+
+      /**
+       *  @brief  Numeric formatting.
+       *
+       *  Formats the boolean @a v and inserts it into a stream.  It does so
+       *  by calling num_put::do_put().
+       *
+       *  If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
+       *  ctype<CharT>::falsename().  Otherwise formats @a v as an int.
+       *
+       *  @param  s  Stream to write to.
+       *  @param  io  Source of locale and flags.
+       *  @param  fill  Char_type to use for filling.
+       *  @param  v  Value to format and insert.
+       *  @return  Iterator after writing.
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+       */
+
+/*
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool_set __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+	{
+	  const long __l = __v;
+	  __s = _M_insert_int(__s, __io, __fill, __l);
+	}
+      else
+	{
+	  typedef __numpunct_cache<_CharT> __cache_type;
+	  __use_cache<__cache_type> __uc;
+	  const locale& __loc = __io._M_getloc();
+	  const __cache_type* __lc = __uc(__loc);
+
+	  const _CharT* __name = __v ? __lc->_M_truename
+				     : __lc->_M_falsename;
+	  int __len = __v ? __lc->_M_truename_size
+			  : __lc->_M_falsename_size;
+
+	  const streamsize __w = __io.width();
+	  if (__w > static_cast<streamsize>(__len))
+	    {
+	      const streamsize __plen = __w - __len;
+	      _CharT* __ps
+		= static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+							* __plen));
+
+	      char_traits<_CharT>::assign(__ps, __plen, __fill);
+	      __io.width(0);
+
+	      if ((__flags & ios_base::adjustfield) == ios_base::left)
+		{
+		  __s = std::__write(__s, __name, __len);
+		  __s = std::__write(__s, __ps, __plen);
+		}
+	      else
+		{
+		  __s = std::__write(__s, __ps, __plen);
+		  __s = std::__write(__s, __name, __len);
+		}
+	      return __s;
+	    }
+	  __io.width(0);
+	  __s = std::__write(__s, __name, __len);
+	}
+      return __s;
+    }
+*/
+
+#endif // _GLIBCXX_TR2_BOOL_SET_TCC
diff --git a/gcc-4.9/libstdc++-v3/include/tr2/dynamic_bitset b/gcc-4.9/libstdc++-v3/include/tr2/dynamic_bitset
new file mode 100644
index 0000000..cf1ed0f
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr2/dynamic_bitset
@@ -0,0 +1,1262 @@
+// TR2 <dynamic_bitset> -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr2/dynamic_bitset
+ *  This is a TR2 C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TR2_DYNAMIC_BITSET
+#define _GLIBCXX_TR2_DYNAMIC_BITSET 1
+
+#pragma GCC system_header
+
+#include <limits>
+#include <vector>
+#include <string>
+#include <memory> // For std::allocator
+#include <bits/functexcept.h>   // For invalid_argument, out_of_range,
+				// overflow_error
+#include <iosfwd>
+#include <bits/cxxabi_forced.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   *  Dynamic Bitset.
+   *
+   *  See N2050,
+   *  Proposal to Add a Dynamically Sizeable Bitset to the Standard Library.
+   */
+namespace __detail
+{
+
+template<typename T>
+class _Bool2UChar
+{
+  typedef T type;
+};
+
+template<>
+class _Bool2UChar<bool>
+{
+public:
+  typedef unsigned char type;
+};
+
+}
+
+  /**
+   *  Base class, general case.
+   *
+   *  See documentation for dynamic_bitset.
+   */
+  template<typename _WordT = unsigned long long,
+	   typename _Alloc = std::allocator<_WordT>>
+    struct __dynamic_bitset_base
+    {
+      static_assert(std::is_unsigned<_WordT>::value, "template argument "
+		    "_WordT not an unsigned integral type");
+
+      typedef _WordT block_type;
+      typedef _Alloc allocator_type;
+      typedef size_t size_type;
+
+      static const size_type _S_bits_per_block = __CHAR_BIT__ * sizeof(block_type);
+      static const size_type npos = static_cast<size_type>(-1);
+
+      /// 0 is the least significant word.
+      std::vector<block_type, allocator_type> _M_w;
+
+      explicit
+      __dynamic_bitset_base(const allocator_type& __alloc = allocator_type())
+      : _M_w(__alloc)
+      { }
+
+      explicit
+      __dynamic_bitset_base(__dynamic_bitset_base&& __b)
+      { this->_M_w.swap(__b._M_w); }
+
+      explicit
+      __dynamic_bitset_base(size_type __nbits, unsigned long long __val = 0ULL,
+			   const allocator_type& __alloc = allocator_type())
+      : _M_w(__nbits / _S_bits_per_block
+	     + (__nbits % _S_bits_per_block > 0),
+	     __val, __alloc)
+      {
+	unsigned long long __mask = ~static_cast<block_type>(0);
+	size_t __n = std::min(this->_M_w.size(),
+			      sizeof(unsigned long long) / sizeof(block_type));
+	for (size_t __i = 0; __i < __n; ++__i)
+	  {
+	    this->_M_w[__i] = (__val & __mask) >> (__i * _S_bits_per_block);
+	    __mask <<= _S_bits_per_block;
+	  }
+      }
+
+      void
+      _M_assign(const __dynamic_bitset_base& __b)
+      { this->_M_w = __b._M_w; }
+
+      void
+      _M_swap(__dynamic_bitset_base& __b)
+      { this->_M_w.swap(__b._M_w); }
+
+      void
+      _M_clear()
+      { this->_M_w.clear(); }
+
+      void
+      _M_resize(size_t __nbits, bool __value)
+      {
+	size_t __sz = __nbits / _S_bits_per_block;
+	if (__nbits % _S_bits_per_block > 0)
+	  ++__sz;
+	if (__sz != this->_M_w.size())
+	  {
+	    block_type __val = 0;
+	    if (__value)
+	      __val = std::numeric_limits<block_type>::max();
+	    this->_M_w.resize(__sz, __val);
+	  }
+      }
+
+      allocator_type
+      _M_get_allocator() const
+      { return this->_M_w.get_allocator(); }
+
+      static size_type
+      _S_whichword(size_type __pos) noexcept
+      { return __pos / _S_bits_per_block; }
+
+      static size_type
+      _S_whichbyte(size_type __pos) noexcept
+      { return (__pos % _S_bits_per_block) / __CHAR_BIT__; }
+
+      static size_type
+      _S_whichbit(size_type __pos) noexcept
+      { return __pos % _S_bits_per_block; }
+
+      static block_type
+      _S_maskbit(size_type __pos) noexcept
+      { return (static_cast<block_type>(1)) << _S_whichbit(__pos); }
+
+      block_type&
+      _M_getword(size_type __pos)
+      { return this->_M_w[_S_whichword(__pos)]; }
+
+      block_type
+      _M_getword(size_type __pos) const
+      { return this->_M_w[_S_whichword(__pos)]; }
+
+      block_type&
+      _M_hiword()
+      { return this->_M_w[_M_w.size() - 1]; }
+
+      block_type
+      _M_hiword() const
+      { return this->_M_w[_M_w.size() - 1]; }
+
+      void
+      _M_do_and(const __dynamic_bitset_base& __x)
+      {
+	if (__x._M_w.size() == this->_M_w.size())
+	  for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	    this->_M_w[__i] &= __x._M_w[__i];
+	else
+	  return;
+      }
+
+      void
+      _M_do_or(const __dynamic_bitset_base& __x)
+      {
+	if (__x._M_w.size() == this->_M_w.size())
+	  for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	    this->_M_w[__i] |= __x._M_w[__i];
+	else
+	  return;
+      }
+
+      void
+      _M_do_xor(const __dynamic_bitset_base& __x)
+      {
+	if (__x._M_w.size() == this->_M_w.size())
+	  for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	    this->_M_w[__i] ^= __x._M_w[__i];
+	else
+	  return;
+      }
+
+      void
+      _M_do_dif(const __dynamic_bitset_base& __x)
+      {
+	if (__x._M_w.size() == this->_M_w.size())
+	  for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	    this->_M_w[__i] &= ~__x._M_w[__i];
+	else
+	  return;
+      }
+
+      void
+      _M_do_left_shift(size_t __shift);
+
+      void
+      _M_do_right_shift(size_t __shift);
+
+      void
+      _M_do_flip()
+      {
+	for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	  this->_M_w[__i] = ~this->_M_w[__i];
+      }
+
+      void
+      _M_do_set()
+      {
+	for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	  this->_M_w[__i] = ~static_cast<block_type>(0);
+      }
+
+      void
+      _M_do_reset()
+      {
+	for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	  this->_M_w[__i] = static_cast<block_type>(0);
+      }
+
+      bool
+      _M_is_equal(const __dynamic_bitset_base& __x) const
+      {
+	if (__x._M_w.size() == this->_M_w.size())
+	  {
+	    for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	      if (this->_M_w[__i] != __x._M_w[__i])
+		return false;
+	    return true;
+	  }
+	else
+	  return false;
+      }
+
+      bool
+      _M_is_less(const __dynamic_bitset_base& __x) const
+      {
+	if (__x._M_w.size() == this->_M_w.size())
+	  {
+	    for (size_t __i = this->_M_w.size(); __i > 0; --__i)
+	      {
+		if (this->_M_w[__i-1] < __x._M_w[__i-1])
+		  return true;
+		else if (this->_M_w[__i-1] > __x._M_w[__i-1])
+		  return false;
+	      }
+	    return false;
+	  }
+	else
+	  return false;
+      }
+
+      size_t
+      _M_are_all_aux() const
+      {
+	for (size_t __i = 0; __i < this->_M_w.size() - 1; ++__i)
+	  if (_M_w[__i] != ~static_cast<block_type>(0))
+	    return 0;
+	return ((this->_M_w.size() - 1) * _S_bits_per_block
+		+ __builtin_popcountll(this->_M_hiword()));
+      }
+
+      bool
+      _M_is_any() const
+      {
+	for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	  if (this->_M_w[__i] != static_cast<block_type>(0))
+	    return true;
+	return false;
+      }
+
+      bool
+      _M_is_subset_of(const __dynamic_bitset_base& __b)
+      {
+	if (__b._M_w.size() == this->_M_w.size())
+	  {
+	    for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	      if (this->_M_w[__i] != (this->_M_w[__i] | __b._M_w[__i]))
+		return false;
+	    return true;
+	  }
+	else
+	  return false;
+      }
+
+      bool
+      _M_is_proper_subset_of(const __dynamic_bitset_base& __b) const
+      {
+	if (this->is_subset_of(__b))
+	  {
+	    if (*this == __b)
+	      return false;
+	    else
+	      return true;
+	  }
+	else
+	  return false;
+      }
+
+      size_t
+      _M_do_count() const
+      {
+	size_t __result = 0;
+	for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	  __result += __builtin_popcountll(this->_M_w[__i]);
+	return __result;
+      }
+
+      size_type
+      _M_size() const noexcept
+      { return this->_M_w.size(); }
+
+      unsigned long
+      _M_do_to_ulong() const;
+
+      unsigned long long
+      _M_do_to_ullong() const;
+
+      // find first "on" bit
+      size_type
+      _M_do_find_first(size_t __not_found) const;
+
+      // find the next "on" bit that follows "prev"
+      size_type
+      _M_do_find_next(size_t __prev, size_t __not_found) const;
+
+      // do append of block
+      void
+      _M_do_append_block(block_type __block, size_type __pos)
+      {
+	size_t __offset = __pos % _S_bits_per_block;
+	if (__offset == 0)
+	  this->_M_w.push_back(__block);
+	else
+	  {
+	    this->_M_hiword() |= (__block << __offset);
+	    this->_M_w.push_back(__block >> (_S_bits_per_block - __offset));
+	  }
+      }
+    };
+
+  /**
+   *  @brief  The %dynamic_bitset class represents a sequence of bits.
+   *
+   *  @ingroup containers
+   *
+   *  (Note that %dynamic_bitset does @e not meet the formal
+   *  requirements of a <a href="tables.html#65">container</a>.
+   *  Mainly, it lacks iterators.)
+   *
+   *  The template argument, @a Nb, may be any non-negative number,
+   *  specifying the number of bits (e.g., "0", "12", "1024*1024").
+   *
+   *  In the general unoptimized case, storage is allocated in
+   *  word-sized blocks.  Let B be the number of bits in a word, then
+   *  (Nb+(B-1))/B words will be used for storage.  B - Nb%B bits are
+   *  unused.  (They are the high-order bits in the highest word.)  It
+   *  is a class invariant that those unused bits are always zero.
+   *
+   *  If you think of %dynamic_bitset as "a simple array of bits," be
+   *  aware that your mental picture is reversed: a %dynamic_bitset
+   *  behaves the same way as bits in integers do, with the bit at
+   *  index 0 in the "least significant / right-hand" position, and
+   *  the bit at index Nb-1 in the "most significant / left-hand"
+   *  position.  Thus, unlike other containers, a %dynamic_bitset's
+   *  index "counts from right to left," to put it very loosely.
+   *
+   *  This behavior is preserved when translating to and from strings.
+   *  For example, the first line of the following program probably
+   *  prints "b('a') is 0001100001" on a modern ASCII system.
+   *
+   *  @code
+   *     #include <dynamic_bitset>
+   *     #include <iostream>
+   *     #include <sstream>
+   *
+   *     using namespace std;
+   *
+   *     int main()
+   *     {
+   *         long         a = 'a';
+   *         dynamic_bitset   b(a);
+   *
+   *         cout << "b('a') is " << b << endl;
+   *
+   *         ostringstream s;
+   *         s << b;
+   *         string  str = s.str();
+   *         cout << "index 3 in the string is " << str[3] << " but\n"
+   *              << "index 3 in the bitset is " << b[3] << endl;
+   *     }
+   *  @endcode
+   *
+   *  Also see:
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch33s02.html
+   *  for a description of extensions.
+   *
+   *  Most of the actual code isn't contained in %dynamic_bitset<>
+   *  itself, but in the base class __dynamic_bitset_base.  The base
+   *  class works with whole words, not with individual bits.  This
+   *  allows us to specialize __dynamic_bitset_base for the important
+   *  special case where the %dynamic_bitset is only a single word.
+   *
+   *  Extra confusion can result due to the fact that the storage for
+   *  __dynamic_bitset_base @e is a vector, and is indexed as such.  This is
+   *  carefully encapsulated.
+   */
+  template<typename _WordT = unsigned long long,
+	   typename _Alloc = std::allocator<_WordT>>
+    class dynamic_bitset
+    : private __dynamic_bitset_base<_WordT, _Alloc>
+    {
+      static_assert(std::is_unsigned<_WordT>::value, "template argument "
+		    "_WordT not an unsigned integral type");
+
+    public:
+
+      typedef __dynamic_bitset_base<_WordT, _Alloc> _Base;
+      typedef _WordT block_type;
+      typedef _Alloc allocator_type;
+      typedef size_t size_type;
+
+      static const size_type bits_per_block = __CHAR_BIT__ * sizeof(block_type);
+      // Use this: constexpr size_type std::numeric_limits<size_type>::max().
+      static const size_type npos = static_cast<size_type>(-1);
+
+    private:
+
+      //  Clear the unused bits in the uppermost word.
+      void
+      _M_do_sanitize()
+      {
+	size_type __shift = this->_M_Nb % bits_per_block;
+	if (__shift > 0)
+	  this->_M_hiword() &= ~((~static_cast<block_type>(0)) << __shift);
+      }
+
+      //  Set the unused bits in the uppermost word.
+      void
+      _M_do_fill()
+      {
+	size_type __shift = this->_M_Nb % bits_per_block;
+	if (__shift > 0)
+	  this->_M_hiword() |= ((~static_cast<block_type>(0)) << __shift);
+      }
+
+      /**
+       *  These versions of single-bit set, reset, flip, and test
+       *  do no range checking.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      _M_unchecked_set(size_type __pos)
+      {
+	this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      _M_unchecked_set(size_type __pos, int __val)
+      {
+	if (__val)
+	  this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+	else
+	  this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      _M_unchecked_reset(size_type __pos)
+      {
+	this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      _M_unchecked_flip(size_type __pos)
+      {
+	this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
+	return *this;
+      }
+
+      bool
+      _M_unchecked_test(size_type __pos) const
+      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
+		!= static_cast<_WordT>(0)); }
+
+      size_type _M_Nb;
+
+    public:
+      /**
+       *  This encapsulates the concept of a single bit.  An instance
+       *  of this class is a proxy for an actual bit; this way the
+       *  individual bit operations are done as faster word-size
+       *  bitwise instructions.
+       *
+       *  Most users will never need to use this class directly;
+       *  conversions to and from bool are automatic and should be
+       *  transparent.  Overloaded operators help to preserve the
+       *  illusion.
+       *
+       *  (On a typical system, this "bit %reference" is 64 times the
+       *  size of an actual bit.  Ha.)
+       */
+      class reference
+      {
+	friend class dynamic_bitset;
+
+	block_type *_M_wp;
+	size_type _M_bpos;
+
+	// left undefined
+	reference();
+
+      public:
+	reference(dynamic_bitset& __b, size_type __pos)
+	{
+	  this->_M_wp = &__b._M_getword(__pos);
+	  this->_M_bpos = _Base::_S_whichbit(__pos);
+	}
+
+	~reference()
+	{ }
+
+	// For b[i] = __x;
+	reference&
+	operator=(bool __x)
+	{
+	  if (__x)
+	    *this->_M_wp |= _Base::_S_maskbit(this->_M_bpos);
+	  else
+	    *this->_M_wp &= ~_Base::_S_maskbit(this->_M_bpos);
+	  return *this;
+	}
+
+	// For b[i] = b[__j];
+	reference&
+	operator=(const reference& __j)
+	{
+	  if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
+	    *this->_M_wp |= _Base::_S_maskbit(this->_M_bpos);
+	  else
+	    *this->_M_wp &= ~_Base::_S_maskbit(this->_M_bpos);
+	  return *this;
+	}
+
+	// Flips the bit
+	bool
+	operator~() const
+	{ return (*(_M_wp) & _Base::_S_maskbit(this->_M_bpos)) == 0; }
+
+	// For __x = b[i];
+	operator bool() const
+	{ return (*(this->_M_wp) & _Base::_S_maskbit(this->_M_bpos)) != 0; }
+
+	// For b[i].flip();
+	reference&
+	flip()
+	{
+	  *this->_M_wp ^= _Base::_S_maskbit(this->_M_bpos);
+	  return *this;
+	}
+      };
+
+      friend class reference;
+
+      typedef bool const_reference;
+
+      // 23.3.5.1 constructors:
+      /// All bits set to zero.
+      explicit
+      dynamic_bitset(const allocator_type& __alloc = allocator_type())
+      : _Base(__alloc), _M_Nb(0)
+      { }
+
+      /// Initial bits bitwise-copied from a single word (others set to zero).
+      explicit
+      dynamic_bitset(size_type __nbits, unsigned long long __val = 0ULL,
+		     const allocator_type& __alloc = allocator_type())
+      : _Base(__nbits, __val, __alloc),
+	_M_Nb(__nbits)
+      { }
+
+      dynamic_bitset(initializer_list<block_type> __il,
+		     const allocator_type& __alloc = allocator_type())
+      : _Base(__alloc), _M_Nb(0)
+      { this->append(__il); }
+
+      /**
+       *  @brief  Use a subset of a string.
+       *  @param  __str  A string of '0' and '1' characters.
+       *  @param  __pos  Index of the first character in @p __str to use.
+       *  @param  __n    The number of characters to copy.
+       *  @throw  std::out_of_range  If @p __pos is bigger the size of @p __str.
+       *  @throw  std::invalid_argument  If a character appears in the string
+       *                                 which is neither '0' nor '1'.
+       */
+      template<typename _CharT, typename _Traits, typename _Alloc1>
+	explicit
+	dynamic_bitset(const std::basic_string<_CharT, _Traits, _Alloc1>& __str,
+		       typename basic_string<_CharT,_Traits,_Alloc1>::size_type
+		       __pos = 0,
+		       typename basic_string<_CharT,_Traits,_Alloc1>::size_type
+		       __n = std::basic_string<_CharT, _Traits, _Alloc1>::npos,
+		       _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'),
+		       const allocator_type& __alloc = allocator_type())
+	: _Base(__alloc),
+	  _M_Nb(0) // Watch for npos.
+	{
+	  if (__pos > __str.size())
+	    __throw_out_of_range(__N("dynamic_bitset::bitset initial position "
+				     "not valid"));
+
+	  // Watch for npos.
+	  this->_M_Nb = (__n > __str.size() ? __str.size() - __pos : __n);
+	  this->resize(this->_M_Nb);
+	  this->_M_copy_from_string(__str, __pos, __n,
+				    _CharT('0'), _CharT('1'));
+	}
+
+      /**
+       *  @brief  Construct from a string.
+       *  @param  __str  A string of '0' and '1' characters.
+       *  @throw  std::invalid_argument  If a character appears in the string
+       *                                 which is neither '0' nor '1'.
+       */
+      explicit
+      dynamic_bitset(const char* __str,
+		     const allocator_type& __alloc = allocator_type())
+      : _Base(__alloc)
+      {
+	size_t __len = 0;
+	if (__str)
+	  while (__str[__len] != '\0')
+	    ++__len;
+	this->resize(__len);
+	this->_M_copy_from_ptr<char,std::char_traits<char>>
+		   (__str, __len, 0, __len, '0', '1');
+      }
+
+      /**
+       *  @brief  Copy constructor.
+       */
+      dynamic_bitset(const dynamic_bitset& __b)
+      : _Base(__b), _M_Nb(__b.size())
+      { }
+
+      /**
+       *  @brief  Move constructor.
+       */
+      dynamic_bitset(dynamic_bitset&& __b)
+      : _Base(std::forward<_Base>(__b)), _M_Nb(__b.size())
+      { }
+
+      /**
+       *  @brief  Swap with another bitset.
+       */
+      void
+      swap(dynamic_bitset& __b)
+      {
+	this->_M_swap(__b);
+	std::swap(this->_M_Nb, __b._M_Nb);
+      }
+
+      /**
+       *  @brief  Assignment.
+       */
+      dynamic_bitset&
+      operator=(const dynamic_bitset& __b)
+      {
+	if (&__b != this)
+	  {
+	    this->_M_assign(__b);
+	    this->_M_Nb = __b._M_Nb;
+	  }
+      }
+
+      /**
+       *  @brief  Move assignment.
+       */
+      dynamic_bitset&
+      operator=(dynamic_bitset&& __b)
+      {
+	this->swap(__b);
+	return *this;
+      }
+
+      /**
+       *  @brief  Return the allocator for the bitset.
+       */
+      allocator_type
+      get_allocator() const
+      { return this->_M_get_allocator(); }
+
+      /**
+       *  @brief  Resize the bitset.
+       */
+      void
+      resize(size_type __nbits, bool __value = false)
+      {
+	if (__value)
+	  this->_M_do_fill();
+	this->_M_resize(__nbits, __value);
+	this->_M_Nb = __nbits;
+	this->_M_do_sanitize();
+      }
+
+      /**
+       *  @brief  Clear the bitset.
+       */
+      void
+      clear()
+      {
+	this->_M_clear();
+	this->_M_Nb = 0;
+      }
+
+      /**
+       *  @brief  Push a bit onto the high end of the bitset.
+       */
+      void
+      push_back(bool __bit)
+      {
+	if (size_t __offset = this->size() % bits_per_block == 0)
+	  this->_M_do_append_block(block_type(0), this->_M_Nb);
+	++this->_M_Nb;
+	this->_M_unchecked_set(this->_M_Nb, __bit);
+      }
+
+      /**
+       *  @brief  Append a block.
+       */
+      void
+      append(block_type __block)
+      {
+	this->_M_do_append_block(__block, this->_M_Nb);
+	this->_M_Nb += bits_per_block;
+      }
+
+      /**
+       *  @brief
+       */
+      void
+      append(initializer_list<block_type> __il)
+      { this->append(__il.begin(), __il.end()); }
+
+      /**
+       *  @brief  Append an iterator range of blocks.
+       */
+      template <typename _BlockInputIterator>
+	void
+	append(_BlockInputIterator __first, _BlockInputIterator __last)
+	{
+	  for (; __first != __last; ++__first)
+	    this->append(*__first);
+	}
+
+      // 23.3.5.2 dynamic_bitset operations:
+      //@{
+      /**
+       *  @brief  Operations on dynamic_bitsets.
+       *  @param  __rhs  A same-sized dynamic_bitset.
+       *
+       *  These should be self-explanatory.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      operator&=(const dynamic_bitset<_WordT, _Alloc>& __rhs)
+      {
+	this->_M_do_and(__rhs);
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      operator&=(dynamic_bitset<_WordT, _Alloc>&& __rhs)
+      {
+	this->_M_do_and(std::move(__rhs));
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      operator|=(const dynamic_bitset<_WordT, _Alloc>& __rhs)
+      {
+	this->_M_do_or(__rhs);
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      operator^=(const dynamic_bitset<_WordT, _Alloc>& __rhs)
+      {
+	this->_M_do_xor(__rhs);
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      operator-=(const dynamic_bitset<_WordT, _Alloc>& __rhs)
+      {
+	this->_M_do_dif(__rhs);
+	return *this;
+      }
+      //@}
+
+      //@{
+      /**
+       *  @brief  Operations on dynamic_bitsets.
+       *  @param  __pos The number of places to shift.
+       *
+       *  These should be self-explanatory.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      operator<<=(size_type __pos)
+      {
+	if (__builtin_expect(__pos < this->_M_Nb, 1))
+	  {
+	    this->_M_do_left_shift(__pos);
+	    this->_M_do_sanitize();
+	  }
+	else
+	  this->_M_do_reset();
+	return *this;
+      }
+
+      dynamic_bitset<_WordT, _Alloc>&
+      operator>>=(size_type __pos)
+      {
+	if (__builtin_expect(__pos < this->_M_Nb, 1))
+	  {
+	    this->_M_do_right_shift(__pos);
+	    this->_M_do_sanitize();
+	  }
+	else
+	  this->_M_do_reset();
+	return *this;
+      }
+      //@}
+
+      // Set, reset, and flip.
+      /**
+       *  @brief Sets every bit to true.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      set()
+      {
+	this->_M_do_set();
+	this->_M_do_sanitize();
+	return *this;
+      }
+
+      /**
+       *  @brief Sets a given bit to a particular value.
+       *  @param  __pos  The index of the bit.
+       *  @param  __val  Either true or false, defaults to true.
+       *  @throw  std::out_of_range  If @a __pos is bigger the size of the %set.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      set(size_type __pos, bool __val = true)
+      {
+	if (__pos >= _M_Nb)
+	  __throw_out_of_range(__N("dynamic_bitset::set"));
+	return this->_M_unchecked_set(__pos, __val);
+      }
+
+      /**
+       *  @brief Sets every bit to false.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      reset()
+      {
+	this->_M_do_reset();
+	return *this;
+      }
+
+      /**
+       *  @brief Sets a given bit to false.
+       *  @param  __pos  The index of the bit.
+       *  @throw  std::out_of_range  If @a __pos is bigger the size of the %set.
+       *
+       *  Same as writing @c set(__pos, false).
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      reset(size_type __pos)
+      {
+	if (__pos >= _M_Nb)
+	  __throw_out_of_range(__N("dynamic_bitset::reset"));
+	return this->_M_unchecked_reset(__pos);
+      }
+
+      /**
+       *  @brief Toggles every bit to its opposite value.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      flip()
+      {
+	this->_M_do_flip();
+	this->_M_do_sanitize();
+	return *this;
+      }
+
+      /**
+       *  @brief Toggles a given bit to its opposite value.
+       *  @param  __pos  The index of the bit.
+       *  @throw  std::out_of_range  If @a __pos is bigger the size of the %set.
+       */
+      dynamic_bitset<_WordT, _Alloc>&
+      flip(size_type __pos)
+      {
+	if (__pos >= _M_Nb)
+	  __throw_out_of_range(__N("dynamic_bitset::flip"));
+	return this->_M_unchecked_flip(__pos);
+      }
+
+      /// See the no-argument flip().
+      dynamic_bitset<_WordT, _Alloc>
+      operator~() const
+      { return dynamic_bitset<_WordT, _Alloc>(*this).flip(); }
+
+      //@{
+      /**
+       *  @brief  Array-indexing support.
+       *  @param  __pos  Index into the %dynamic_bitset.
+       *  @return A bool for a 'const %dynamic_bitset'.  For non-const
+       *           bitsets, an instance of the reference proxy class.
+       *  @note These operators do no range checking and throw no
+       *         exceptions, as required by DR 11 to the standard.
+       */
+      reference
+      operator[](size_type __pos)
+      { return reference(*this,__pos); }
+
+      const_reference
+      operator[](size_type __pos) const
+      { return _M_unchecked_test(__pos); }
+      //@}
+
+      /**
+       *  @brief Returns a numerical interpretation of the %dynamic_bitset.
+       *  @return  The integral equivalent of the bits.
+       *  @throw  std::overflow_error  If there are too many bits to be
+       *                               represented in an @c unsigned @c long.
+       */
+      unsigned long
+      to_ulong() const
+      { return this->_M_do_to_ulong(); }
+
+      /**
+       *  @brief Returns a numerical interpretation of the %dynamic_bitset.
+       *  @return  The integral equivalent of the bits.
+       *  @throw  std::overflow_error  If there are too many bits to be
+       *                               represented in an @c unsigned @c long.
+       */
+      unsigned long long
+      to_ullong() const
+      { return this->_M_do_to_ullong(); }
+
+      /**
+       *  @brief Returns a character interpretation of the %dynamic_bitset.
+       *  @return  The string equivalent of the bits.
+       *
+       *  Note the ordering of the bits:  decreasing character positions
+       *  correspond to increasing bit positions (see the main class notes for
+       *  an example).
+       */
+      template<typename _CharT = char,
+	       typename _Traits = std::char_traits<_CharT>,
+	       typename _Alloc1 = std::allocator<_CharT>>
+	std::basic_string<_CharT, _Traits, _Alloc1>
+	to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const
+	{
+	  std::basic_string<_CharT, _Traits, _Alloc1> __result;
+	  _M_copy_to_string(__result, __zero, __one);
+	  return __result;
+	}
+
+      // Helper functions for string operations.
+      template<typename _CharT, typename _Traits>
+	void
+	_M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
+			 _CharT, _CharT);
+
+      template<typename _CharT, typename _Traits, typename _Alloc1>
+	void
+	_M_copy_from_string(const std::basic_string<_CharT,
+			    _Traits, _Alloc1>& __str, size_t __pos, size_t __n,
+			    _CharT __zero = _CharT('0'),
+			    _CharT __one = _CharT('1'))
+	{ _M_copy_from_ptr<_CharT, _Traits>(__str.data(), __str.size(),
+					    __pos, __n, __zero, __one); }
+
+      template<typename _CharT, typename _Traits, typename _Alloc1>
+	void
+	_M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc1>& __str,
+			  _CharT __zero = _CharT('0'),
+			  _CharT __one = _CharT('1')) const;
+
+      /// Returns the number of bits which are set.
+      size_type
+      count() const noexcept
+      { return this->_M_do_count(); }
+
+      /// Returns the total number of bits.
+      size_type
+      size() const noexcept
+      { return this->_M_Nb; }
+
+      /// Returns the total number of blocks.
+      size_type
+      num_blocks() const noexcept
+      { return this->_M_size(); }
+
+      /// Returns true if the dynamic_bitset is empty.
+      bool
+      empty() const noexcept
+      { return (this->_M_Nb == 0); }
+
+      /// Returns the maximum size of a dynamic_bitset object having the same
+      /// type as *this.
+      /// The real answer is max() * bits_per_block but is likely to overflow.
+      constexpr size_type
+      max_size() noexcept
+      { return std::numeric_limits<block_type>::max(); }
+
+      /**
+       *  @brief Tests the value of a bit.
+       *  @param  __pos  The index of a bit.
+       *  @return  The value at @a __pos.
+       *  @throw  std::out_of_range  If @a __pos is bigger the size of the %set.
+       */
+      bool
+      test(size_type __pos) const
+      {
+	if (__pos >= _M_Nb)
+	  __throw_out_of_range(__N("dynamic_bitset::test"));
+	return _M_unchecked_test(__pos);
+      }
+
+      /**
+       *  @brief Tests whether all the bits are on.
+       *  @return  True if all the bits are set.
+       */
+      bool
+      all() const
+      { return this->_M_are_all_aux() == _M_Nb; }
+
+      /**
+       *  @brief Tests whether any of the bits are on.
+       *  @return  True if at least one bit is set.
+       */
+      bool
+      any() const
+      { return this->_M_is_any(); }
+
+      /**
+       *  @brief Tests whether any of the bits are on.
+       *  @return  True if none of the bits are set.
+       */
+      bool
+      none() const
+      { return !this->_M_is_any(); }
+
+      //@{
+      /// Self-explanatory.
+      dynamic_bitset<_WordT, _Alloc>
+      operator<<(size_type __pos) const
+      { return dynamic_bitset<_WordT, _Alloc>(*this) <<= __pos; }
+
+      dynamic_bitset<_WordT, _Alloc>
+      operator>>(size_type __pos) const
+      { return dynamic_bitset<_WordT, _Alloc>(*this) >>= __pos; }
+      //@}
+
+      /**
+       *  @brief  Finds the index of the first "on" bit.
+       *  @return  The index of the first bit set, or size() if not found.
+       *  @sa  find_next
+       */
+      size_type
+      find_first() const
+      { return this->_M_do_find_first(this->_M_Nb); }
+
+      /**
+       *  @brief  Finds the index of the next "on" bit after prev.
+       *  @return  The index of the next bit set, or size() if not found.
+       *  @param  __prev  Where to start searching.
+       *  @sa  find_first
+       */
+      size_type
+      find_next(size_t __prev) const
+      { return this->_M_do_find_next(__prev, this->_M_Nb); }
+
+      bool
+      is_subset_of(const dynamic_bitset& __b) const
+      { return this->_M_is_subset_of(__b); }
+
+      bool
+      is_proper_subset_of(const dynamic_bitset& __b) const
+      { return this->_M_is_proper_subset_of(__b); }
+
+      friend bool
+      operator==(const dynamic_bitset<_WordT, _Alloc>& __lhs,
+		 const dynamic_bitset<_WordT, _Alloc>& __rhs)
+      { return __lhs._M_is_equal(__rhs); }
+
+      friend bool
+      operator<(const dynamic_bitset<_WordT, _Alloc>& __lhs,
+		const dynamic_bitset<_WordT, _Alloc>& __rhs)
+      { return __lhs._M_is_less(__rhs); }
+    };
+
+  template<typename _WordT, typename _Alloc>
+    template<typename _CharT, typename _Traits, typename _Alloc1>
+      inline void
+      dynamic_bitset<_WordT, _Alloc>::
+      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc1>& __str,
+			_CharT __zero, _CharT __one) const
+      {
+	__str.assign(_M_Nb, __zero);
+	for (size_t __i = _M_Nb; __i > 0; --__i)
+	  if (_M_unchecked_test(__i - 1))
+	    _Traits::assign(__str[_M_Nb - __i], __one);
+      }
+
+
+  //@{
+  /// These comparisons for equality/inequality are, well, @e bitwise.
+
+  template<typename _WordT, typename _Alloc>
+    inline bool
+    operator!=(const dynamic_bitset<_WordT, _Alloc>& __lhs,
+	       const dynamic_bitset<_WordT, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+  template<typename _WordT, typename _Alloc>
+    inline bool
+    operator<=(const dynamic_bitset<_WordT, _Alloc>& __lhs,
+	       const dynamic_bitset<_WordT, _Alloc>& __rhs)
+    { return !(__lhs > __rhs); }
+
+  template<typename _WordT, typename _Alloc>
+    inline bool
+    operator>(const dynamic_bitset<_WordT, _Alloc>& __lhs,
+	      const dynamic_bitset<_WordT, _Alloc>& __rhs)
+    { return __rhs < __lhs; }
+
+  template<typename _WordT, typename _Alloc>
+    inline bool
+    operator>=(const dynamic_bitset<_WordT, _Alloc>& __lhs,
+	       const dynamic_bitset<_WordT, _Alloc>& __rhs)
+    { return !(__lhs < __rhs); }
+  //@}
+
+  // 23.3.5.3 bitset operations:
+  //@{
+  /**
+   *  @brief  Global bitwise operations on bitsets.
+   *  @param  __x  A bitset.
+   *  @param  __y  A bitset of the same size as @a __x.
+   *  @return  A new bitset.
+   *
+   *  These should be self-explanatory.
+   */
+  template<typename _WordT, typename _Alloc>
+    inline dynamic_bitset<_WordT, _Alloc>
+    operator&(const dynamic_bitset<_WordT, _Alloc>& __x,
+	      const dynamic_bitset<_WordT, _Alloc>& __y)
+    {
+      dynamic_bitset<_WordT, _Alloc> __result(__x);
+      __result &= __y;
+      return __result;
+    }
+
+  template<typename _WordT, typename _Alloc>
+    inline dynamic_bitset<_WordT, _Alloc>
+    operator|(const dynamic_bitset<_WordT, _Alloc>& __x,
+	      const dynamic_bitset<_WordT, _Alloc>& __y)
+    {
+      dynamic_bitset<_WordT, _Alloc> __result(__x);
+      __result |= __y;
+      return __result;
+    }
+
+  template <typename _WordT, typename _Alloc>
+    inline dynamic_bitset<_WordT, _Alloc>
+    operator^(const dynamic_bitset<_WordT, _Alloc>& __x,
+	      const dynamic_bitset<_WordT, _Alloc>& __y)
+    {
+      dynamic_bitset<_WordT, _Alloc> __result(__x);
+      __result ^= __y;
+      return __result;
+    }
+
+  template <typename _WordT, typename _Alloc>
+    inline dynamic_bitset<_WordT, _Alloc>
+    operator-(const dynamic_bitset<_WordT, _Alloc>& __x,
+	      const dynamic_bitset<_WordT, _Alloc>& __y)
+    {
+      dynamic_bitset<_WordT, _Alloc> __result(__x);
+      __result -= __y;
+      return __result;
+    }
+  //@}
+
+  /**
+   *  @defgroup Global I/O operators for bitsets.
+   *  @{
+   *  @brief Global I/O operators for bitsets.
+   *
+   *  Direct I/O between streams and bitsets is supported.  Output is
+   *  straightforward.  Input will skip whitespace and only accept '0'
+   *  and '1' characters.  The %dynamic_bitset will grow as necessary
+   *  to hold the string of bits.
+   */
+  template <typename _CharT, typename _Traits,
+	    typename _WordT, typename _Alloc>
+    inline std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       const dynamic_bitset<_WordT, _Alloc>& __x)
+    {
+      std::basic_string<_CharT, _Traits> __tmp;
+
+      const ctype<_CharT>& __ct = use_facet<ctype<_CharT>>(__os.getloc());
+      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
+      return __os << __tmp;
+    }
+  /**
+   *  @}
+   */
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // tr2
+} // std
+
+#include <tr2/dynamic_bitset.tcc>
+
+#endif /* _GLIBCXX_TR2_DYNAMIC_BITSET */
diff --git a/gcc-4.9/libstdc++-v3/include/tr2/dynamic_bitset.tcc b/gcc-4.9/libstdc++-v3/include/tr2/dynamic_bitset.tcc
new file mode 100644
index 0000000..d5b55ce
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr2/dynamic_bitset.tcc
@@ -0,0 +1,286 @@
+// TR2 <dynamic_bitset> -*- C++ -*-
+
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr2/dynamic_bitset.tcc
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{tr2/dynamic_bitset}
+ */
+
+#ifndef _GLIBCXX_TR2_DYNAMIC_BITSET_TCC
+#define _GLIBCXX_TR2_DYNAMIC_BITSET_TCC 1
+
+#pragma GCC system_header
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  // Definitions of non-inline functions from __dynamic_bitset_base.
+  template<typename _WordT, typename _Alloc>
+    void
+    __dynamic_bitset_base<_WordT, _Alloc>::_M_do_left_shift(size_t __shift)
+    {
+      if (__builtin_expect(__shift != 0, 1))
+	{
+	  const size_t __wshift = __shift / _S_bits_per_block;
+	  const size_t __offset = __shift % _S_bits_per_block;
+
+	  if (__offset == 0)
+	    for (size_t __n = this->_M_w.size() - 1; __n >= __wshift; --__n)
+	      this->_M_w[__n] = this->_M_w[__n - __wshift];
+	  else
+	    {
+	      const size_t __sub_offset = _S_bits_per_block - __offset;
+	      for (size_t __n = _M_w.size() - 1; __n > __wshift; --__n)
+		this->_M_w[__n] = ((this->_M_w[__n - __wshift] << __offset)
+			     | (this->_M_w[__n - __wshift - 1] >> __sub_offset));
+	      this->_M_w[__wshift] = this->_M_w[0] << __offset;
+	    }
+
+	  //// std::fill(this->_M_w.begin(), this->_M_w.begin() + __wshift,
+	  ////          static_cast<_WordT>(0));
+	}
+    }
+
+  template<typename _WordT, typename _Alloc>
+    void
+    __dynamic_bitset_base<_WordT, _Alloc>::_M_do_right_shift(size_t __shift)
+    {
+      if (__builtin_expect(__shift != 0, 1))
+	{
+	  const size_t __wshift = __shift / _S_bits_per_block;
+	  const size_t __offset = __shift % _S_bits_per_block;
+	  const size_t __limit = this->_M_w.size() - __wshift - 1;
+
+	  if (__offset == 0)
+	    for (size_t __n = 0; __n <= __limit; ++__n)
+	      this->_M_w[__n] = this->_M_w[__n + __wshift];
+	  else
+	    {
+	      const size_t __sub_offset = (_S_bits_per_block
+					   - __offset);
+	      for (size_t __n = 0; __n < __limit; ++__n)
+		this->_M_w[__n] = ((this->_M_w[__n + __wshift] >> __offset)
+			     | (this->_M_w[__n + __wshift + 1] << __sub_offset));
+	      this->_M_w[__limit] = this->_M_w[_M_w.size()-1] >> __offset;
+	    }
+
+	  ////std::fill(this->_M_w.begin() + __limit + 1, this->_M_w.end(),
+	  ////          static_cast<_WordT>(0));
+	}
+    }
+
+  template<typename _WordT, typename _Alloc>
+    unsigned long
+    __dynamic_bitset_base<_WordT, _Alloc>::_M_do_to_ulong() const
+    {
+      size_t __n = sizeof(unsigned long) / sizeof(block_type);
+      for (size_t __i = __n; __i < this->_M_w.size(); ++__i)
+	if (this->_M_w[__i])
+	  __throw_overflow_error(__N("__dynamic_bitset_base::_M_do_to_ulong"));
+      unsigned long __res = 0UL;
+      for (size_t __i = 0; __i < __n && __i < this->_M_w.size(); ++__i)
+	__res += this->_M_w[__i] << (__i * _S_bits_per_block);
+      return __res;
+    }
+
+  template<typename _WordT, typename _Alloc>
+    unsigned long long
+    __dynamic_bitset_base<_WordT, _Alloc>::_M_do_to_ullong() const
+    {
+      size_t __n = sizeof(unsigned long long) / sizeof(block_type);
+      for (size_t __i = __n; __i < this->_M_w.size(); ++__i)
+	if (this->_M_w[__i])
+	  __throw_overflow_error(__N("__dynamic_bitset_base::_M_do_to_ullong"));
+      unsigned long long __res = 0ULL;
+      for (size_t __i = 0; __i < __n && __i < this->_M_w.size(); ++__i)
+	__res += this->_M_w[__i] << (__i * _S_bits_per_block);
+      return __res;
+    }
+
+  template<typename _WordT, typename _Alloc>
+    size_t
+    __dynamic_bitset_base<_WordT, _Alloc>
+    ::_M_do_find_first(size_t __not_found) const
+    {
+      for (size_t __i = 0; __i < this->_M_w.size(); ++__i)
+	{
+	  _WordT __thisword = this->_M_w[__i];
+	  if (__thisword != static_cast<_WordT>(0))
+	    return (__i * _S_bits_per_block
+		    + __builtin_ctzll(__thisword));
+	}
+      // not found, so return an indication of failure.
+      return __not_found;
+    }
+
+  template<typename _WordT, typename _Alloc>
+    size_t
+    __dynamic_bitset_base<_WordT, _Alloc>
+    ::_M_do_find_next(size_t __prev, size_t __not_found) const
+    {
+      // make bound inclusive
+      ++__prev;
+
+      // check out of bounds
+      if (__prev >= this->_M_w.size() * _S_bits_per_block)
+	return __not_found;
+
+      // search first word
+      size_t __i = _S_whichword(__prev);
+      _WordT __thisword = this->_M_w[__i];
+
+      // mask off bits below bound
+      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
+
+      if (__thisword != static_cast<_WordT>(0))
+	return (__i * _S_bits_per_block
+		+ __builtin_ctzll(__thisword));
+
+      // check subsequent words
+      for (++__i; __i < this->_M_w.size(); ++__i)
+	{
+	  __thisword = this->_M_w[__i];
+	  if (__thisword != static_cast<_WordT>(0))
+	    return (__i * _S_bits_per_block
+		    + __builtin_ctzll(__thisword));
+	}
+      // not found, so return an indication of failure.
+      return __not_found;
+    } // end _M_do_find_next
+
+  // Definitions of non-inline member functions.
+  template<typename _WordT, typename _Alloc>
+    template<typename _CharT, typename _Traits>
+      void
+      dynamic_bitset<_WordT, _Alloc>::
+      _M_copy_from_ptr(const _CharT* __str, size_t __len,
+		       size_t __pos, size_t __n, _CharT __zero, _CharT __one)
+      {
+	reset();
+	const size_t __nbits = std::min(_M_Nb, std::min(__n, __len - __pos));
+	for (size_t __i = __nbits; __i > 0; --__i)
+	  {
+	    const _CharT __c = __str[__pos + __nbits - __i];
+	    if (_Traits::eq(__c, __zero))
+	      ;
+	    else if (_Traits::eq(__c, __one))
+	      _M_unchecked_set(__i - 1);
+	    else
+	      __throw_invalid_argument(__N("dynamic_bitset::_M_copy_from_ptr"));
+	  }
+      }
+
+  /**
+   *  @defgroup Global I/O operators for bitsets.
+   *  @{
+   *  @brief Global I/O operators for bitsets.
+   *
+   *  Direct I/O between streams and bitsets is supported.  Output is
+   *  straightforward.  Input will skip whitespace and only accept '0'
+   *  and '1' characters.  The %dynamic_bitset will grow as necessary
+   *  to hold the string of bits.
+   */
+  template<typename _CharT, typename _Traits,
+	   typename _WordT, typename _Alloc>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+	       dynamic_bitset<_WordT, _Alloc>& __x)
+    {
+      typedef typename _Traits::char_type          char_type;
+      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
+      typedef typename __istream_type::ios_base    __ios_base;
+
+      std::basic_string<_CharT, _Traits> __tmp;
+      __tmp.reserve(__x.size());
+
+      const char_type __zero = __is.widen('0');
+      const char_type __one = __is.widen('1');
+
+      typename __ios_base::iostate __state = __ios_base::goodbit;
+      typename __istream_type::sentry __sentry(__is);
+      if (__sentry)
+	{
+	  __try
+	    {
+	      while (1)
+		{
+		  static typename _Traits::int_type __eof = _Traits::eof();
+
+		  typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
+		  if (_Traits::eq_int_type(__c1, __eof))
+		    {
+		      __state |= __ios_base::eofbit;
+		      break;
+		    }
+		  else
+		    {
+		      const char_type __c2 = _Traits::to_char_type(__c1);
+		      if (_Traits::eq(__c2, __zero))
+			__tmp.push_back(__zero);
+		      else if (_Traits::eq(__c2, __one))
+			__tmp.push_back(__one);
+		      else if (_Traits::
+			       eq_int_type(__is.rdbuf()->sputbackc(__c2),
+					   __eof))
+			{
+			  __state |= __ios_base::failbit;
+			  break;
+			}
+		      else
+			break;
+		    }
+		}
+	    }
+	  __catch(__cxxabiv1::__forced_unwind&)
+	    {
+	      __is._M_setstate(__ios_base::badbit);
+	      __throw_exception_again;
+	    }
+	  __catch(...)
+	    { __is._M_setstate(__ios_base::badbit); }
+	}
+
+      __x.resize(__tmp.size());
+
+      if (__tmp.empty() && __x.size())
+	__state |= __ios_base::failbit;
+      else
+	__x._M_copy_from_string(__tmp, static_cast<size_t>(0), __x.size(),
+				__zero, __one);
+      if (__state)
+	__is.setstate(__state);
+      return __is;
+    }
+  /**
+   *  @}
+   */
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // tr2
+} // std
+
+#endif /* _GLIBCXX_TR2_DYNAMIC_BITSET_TCC */
diff --git a/gcc-4.9/libstdc++-v3/include/tr2/ratio b/gcc-4.9/libstdc++-v3/include/tr2/ratio
new file mode 100644
index 0000000..1f653a9
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr2/ratio
@@ -0,0 +1,59 @@
+// TR2 <ratio> -*- C++ -*-
+
+// Copyright (C) 2010-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr2/ratio
+ *  This is a TR2 C++ Library header.
+ */
+
+#include <ratio>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  template<intmax_t _Pn, size_t _Bit,
+	     bool = _Bit < static_cast<size_t>
+			  (std::numeric_limits<intmax_t>::digits)>
+    struct __safe_lshift
+    { static const intmax_t __value = 0; };
+
+    template<intmax_t _Pn, size_t _Bit>
+      struct __safe_lshift<_Pn, _Bit, true>
+      { static const intmax_t __value = _Pn << _Bit; };
+
+  /// Add binary prefixes (IEC 60027-2 A.2 and ISO/IEC 80000).
+  typedef ratio<__safe_lshift<1, 10>::__value, 1> kibi;
+  typedef ratio<__safe_lshift<1, 20>::__value, 1> mebi;
+  typedef ratio<__safe_lshift<1, 30>::__value, 1> gibi;
+  typedef ratio<__safe_lshift<1, 40>::__value, 1> tebi;
+  typedef ratio<__safe_lshift<1, 50>::__value, 1> pebi;
+  typedef ratio<__safe_lshift<1, 60>::__value, 1> exbi;
+  //typedef ratio<__safe_lshift<1, 70>::__value, 1> zebi;
+  //typedef ratio<__safe_lshift<1, 80>::__value, 1> yobi;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
diff --git a/gcc-4.9/libstdc++-v3/include/tr2/type_traits b/gcc-4.9/libstdc++-v3/include/tr2/type_traits
new file mode 100644
index 0000000..fc4c919
--- /dev/null
+++ b/gcc-4.9/libstdc++-v3/include/tr2/type_traits
@@ -0,0 +1,106 @@
+// TR2 <type_traits> -*- C++ -*-
+
+// Copyright (C) 2011-2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file tr2/type_traits
+ *  This is a TR2 C++ Library header.
+ */
+
+#ifndef _GLIBCXX_TR2_TYPE_TRAITS
+#define _GLIBCXX_TR2_TYPE_TRAITS 1
+
+#pragma GCC system_header
+#include <type_traits>
+#include <bits/c++config.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace tr2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  /**
+   * @addtogroup metaprogramming
+   * @{
+   */
+
+  /**
+   *  See N2965: Type traits and base classes
+   *  by Michael Spertus
+   */
+
+  /**
+   *  Simple typelist. Compile-time list of types.
+   */
+  template<typename... _Elements>
+    struct __reflection_typelist;
+
+  /// Specialization for an empty typelist.
+  template<>
+    struct __reflection_typelist<>
+    {
+      typedef std::true_type					empty;
+    };
+
+  /// Partial specialization.
+  template<typename _First, typename... _Rest>
+    struct __reflection_typelist<_First, _Rest...>
+    {
+      typedef std::false_type					empty;
+
+      struct first
+      {
+	typedef _First						type;
+      };
+
+      struct rest
+      {
+	typedef __reflection_typelist<_Rest...>			type;
+      };
+    };
+
+  /// Sequence abstraction metafunctions for manipulating a typelist.
+
+
+
+  /// Enumerate all the base classes of a class. Form of a typelist.
+  template<typename _Tp>
+    struct bases
+    {
+      typedef __reflection_typelist<__bases(_Tp)...>		type;
+    };
+
+  /// Enumerate all the direct base classes of a class. Form of a typelist.
+  template<typename _Tp>
+    struct direct_bases
+    {
+      typedef __reflection_typelist<__direct_bases(_Tp)...>	type;
+    };
+
+  /// @} group metaprogramming
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+}
+
+#endif // _GLIBCXX_TR2_TYPE_TRAITS