2006-09-27 Benjamin Kosnik <bkoz@redhat.com>

	* include/ext/typelist.h (type_to_type): Remove.
	* include/ext/throw_allocator.h (assert_allocatod): Remove.
	(check_allocated(label)): New.
	(print_to_string): Print numerical output correctly.

	* testsuite/ext/pb_ds/example/hash_resize_neg.cc: Adjust line numbers.

	* testsuite/util/regression/rand/priority_queue/detail/
	operator_fn_imps.hpp: Set and clear label, throw
        probability. Check only allocations of the marked label.
	* testsuite/util/regression/rand/assoc/detail/
	operator_fn_imps.hpp: Same.

	* testsuite/performance/ext/pb_ds/text_find_timing.cc: Adjustments for
        removal of type_to_type.
	* testsuite/performance/ext/pb_ds/
	hash_random_int_erase_mem_usage.cc: Same.
	* testsuite/performance/ext/pb_ds/tree_text_insert_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	priority_queue_text_push_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	random_int_subscript_find_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/tree_split_join_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/random_int_find_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	multimap_text_insert_mem_usage.hpp: Same.
	* testsuite/performance/ext/pb_ds/
	priority_queue_random_int_push_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/multimap_text_find_timing.hpp: Same.
	* testsuite/performance/ext/pb_ds/
	priority_queue_text_modify_timing.hpp: Same.
	* testsuite/performance/ext/pb_ds/
	tree_order_statistics_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	priority_queue_text_push_pop_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	priority_queue_text_join_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	priority_queue_random_int_push_pop_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	random_int_subscript_insert_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/tree_text_lor_find_timing.cc: Same.
	* testsuite/performance/ext/pb_ds/
	multimap_text_insert_timing.hpp: Same.
	* testsuite/performance/ext/pb_ds/
	priority_queue_text_pop_mem_usage.cc: Same.
	* testsuite/performance/ext/pb_ds/
	hash_zlob_random_int_find_timing.cc: Same. 
	* testsuite/util/regression/trait/assoc/type_trait.hpp: Same.
	* testsuite/util/regression/rand/priority_queue/
	rand_regression_test.hpp: Same.
	* testsuite/util/regression/rand/assoc/detail/
	constructor_destructor_fn_imps.hpp: Same.
	* testsuite/util/regression/rand/assoc/detail/insert_fn_imps.hpp: Same.
	* testsuite/util/regression/rand/assoc/rand_regression_test.hpp: Same.
	* testsuite/util/regression/rand/assoc/
	container_rand_regression_test.hpp: Same.
	* testsuite/util/regression/assoc/common_type.hpp: Same.
	* testsuite/util/regression/basic_type.hpp: Same.
	* testsuite/util/common_type/assoc/common_type.hpp: Same.
	* testsuite/util/common_type/assoc/string_form.hpp: Same.
	* testsuite/util/common_type/assoc/template_policy.hpp: Same.
	* testsuite/util/common_type/assoc/native_set.hpp: Same.
	* testsuite/util/performance/priority_queue/mem_usage/
	pop_test.hpp: Same.
	* testsuite/util/performance/priority_queue/timing/
	push_pop_test.hpp: Same.
	* testsuite/util/performance/priority_queue/timing/join_test.hpp: Same.
	* testsuite/util/performance/priority_queue/timing/push_test.hpp: Same.
	* testsuite/util/performance/priority_queue/timing/
	modify_test.hpp: Same.
	* testsuite/util/performance/assoc/mem_usage/
	multimap_insert_test.hpp: Same.
	* testsuite/util/performance/assoc/mem_usage/erase_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/
	multimap_insert_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/
	subscript_find_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/find_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/
	subscript_insert_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/insert_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/
	tree_order_statistics_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/multimap_find_test.hpp: Same.
	* testsuite/util/performance/assoc/timing/
	tree_split_join_test.hpp: Same.
	* testsuite/util/performance/assoc/multimap_common_type.hpp: Same.
	* testsuite/util/testsuite_common_types.h: Same.

	* include/ext/pb_ds/detail/cc_hash_table_map_/
	constructor_destructor_no_store_hash_fn_imps.hpp: Typedef
        normalization, consistency in member names between cc and gp hash
        tables, formatting fixes.
	* include/ext/pb_ds/detail/cc_hash_table_map_/
	erase_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/
	insert_no_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/
	constructor_destructor_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/
	insert_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/
	constructor_destructor_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/cc_hash_table_map_/
	erase_no_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/
	constructor_destructor_no_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/
	erase_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/
	insert_no_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/
	constructor_destructor_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/
	insert_store_hash_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/
	constructor_destructor_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/gp_hash_table_map_/
	erase_no_store_hash_fn_imps.hpp: Same.

	* include/ext/pb_ds/assoc_container.hpp: Formatting fixes.
	* include/ext/pb_ds/detail/resize_policy/
	hash_prime_size_policy_imp.hpp: Same.
	* include/ext/pb_ds/detail/resize_policy/
	hash_standard_resize_policy_imp.hpp: Same.
	* include/ext/pb_ds/detail/types_traits.hpp: Same.
	* include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp: Same.
	* include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp: Same.
	* include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp: Same.
	* include/ext/pb_ds/detail/hash_fn/
	direct_mod_range_hashing_imp.hpp: Same.
	* include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp: Same.
	* include/ext/pb_ds/detail/hash_fn/
	direct_mask_range_hashing_imp.hpp: Same.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@117268 138bc75d-0d04-0410-961f-82ee72b054a4

35 files changed, 610 insertions, 1116 deletions

diff --git a/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp b/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp
index 4491768cb47..271cc7600f1 100644
--- a/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp
@@ -184,14 +184,14 @@ namespace pb_ds
     // 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) { }
+    : 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) { }
+    : 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
@@ -199,7 +199,7 @@ namespace pb_ds
     // 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) { }
+    : 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
@@ -209,7 +209,7 @@ namespace pb_ds
     // 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) { }
+    : 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
@@ -223,7 +223,7 @@ namespace pb_ds
     // 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)
+    : base_type(h)
     { copy_from_range(first, last); }
 
     // Constructor taking __iterators to a range of value_types and
@@ -234,7 +234,7 @@ namespace pb_ds
     // object.
     template<typename It>
     cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e)
-      : base_type(h, e)
+    : base_type(h, e)
     { copy_from_range(first, last); }
 
     // Constructor taking __iterators to a range of value_types and
@@ -247,7 +247,7 @@ namespace pb_ds
     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)
+    : base_type(h, e, ch)
     { copy_from_range(first, last); }
 
     // Constructor taking __iterators to a range of value_types and
@@ -261,11 +261,11 @@ namespace pb_ds
     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)
+    : base_type(h, e, ch, rp)
     { copy_from_range(first, last); }
 
     cc_hash_table(const cc_hash_table& other)
-      : base_type((const base_type&)other)
+    : base_type((const base_type&)other)
     { }
 
     virtual
@@ -274,7 +274,7 @@ namespace pb_ds
     cc_hash_table& 
     operator=(const cc_hash_table& other)
     {
-      if (this !=& other)
+      if (this != &other)
 	{
 	  cc_hash_table tmp(other);
 	  swap(tmp);
@@ -323,14 +323,14 @@ namespace pb_ds
     // 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) { }
+    : 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) { }
+    : 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
@@ -338,7 +338,7 @@ namespace pb_ds
     // 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) { }
+    : 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
@@ -348,7 +348,7 @@ namespace pb_ds
     // 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) { }
+    : 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
@@ -359,7 +359,7 @@ namespace pb_ds
     // 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) { }
+    : 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
@@ -374,7 +374,7 @@ namespace pb_ds
     // 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(h)
     { base_type::copy_from_range(first, last); }
 
     // Constructor taking __iterators to a range of value_types and
@@ -385,7 +385,7 @@ namespace pb_ds
     // 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(h, e)
     { base_type::copy_from_range(first, last); }
 
     // Constructor taking __iterators to a range of value_types and
@@ -398,7 +398,7 @@ namespace pb_ds
     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(h, e, cp)
     { base_type::copy_from_range(first, last); }
 
     // Constructor taking __iterators to a range of value_types and
@@ -412,7 +412,7 @@ namespace pb_ds
     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(h, e, cp, p)
     { base_type::copy_from_range(first, last); }
 
     // Constructor taking __iterators to a range of value_types and
@@ -429,11 +429,11 @@ namespace pb_ds
     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(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)
+    : base_type((const base_type&)other)
     { }
 
     virtual
@@ -442,7 +442,7 @@ namespace pb_ds
     gp_hash_table& 
     operator=(const gp_hash_table& other)
     {
-      if (this !=& other)
+      if (this != &other)
 	{
 	  gp_hash_table tmp(other);
 	  swap(tmp);
@@ -458,7 +458,7 @@ namespace pb_ds
 #undef PB_DS_BASE_C_DEC
 
 
-#define PB_DS_BASE_C_DEC					\
+#define PB_DS_BASE_C_DEC \
   container_base<Key, Mapped, Tag, Policy_Tl, Allocator>
 
   // An abstract basic tree-like (tree, trie) associative container.
@@ -484,10 +484,10 @@ namespace pb_ds
 #undef PB_DS_BASE_C_DEC
 
 
-#define PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC				\
+#define PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC \
   detail::tree_traits<Key, Mapped,Cmp_Fn,Node_Update,Tag, Allocator>
 
-#define PB_DS_BASE_C_DEC						\
+#define PB_DS_BASE_C_DEC \
   basic_tree<Key,Mapped,Tag,typename PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC::node_update, \
 	     typename __gnu_cxx::typelist::create2<Cmp_Fn, PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC >::type, Allocator>
 
@@ -511,7 +511,7 @@ namespace pb_ds
     // 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) { }
+    : 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
@@ -530,7 +530,7 @@ namespace pb_ds
     { base_type::copy_from_range(first, last); }
 
     tree(const tree& other)
-      : base_type((const base_type&)other) { }
+    : base_type((const base_type&)other) { }
 
     virtual
     ~tree() { }
@@ -538,7 +538,7 @@ namespace pb_ds
     tree& 
     operator=(const tree& other)
     {
-      if (this !=& other)
+      if (this != &other)
 	{
 	  tree tmp(other);
 	  swap(tmp);
@@ -555,10 +555,10 @@ namespace pb_ds
 #undef PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC
 
 
-#define PB_DS_TRIE_NODE_AND_ITS_TRAITS					\
+#define PB_DS_TRIE_NODE_AND_ITS_TRAITS \
   detail::trie_traits<Key,Mapped,E_Access_Traits,Node_Update,Tag,Allocator>
 
-#define PB_DS_BASE_C_DEC						\
+#define PB_DS_BASE_C_DEC \
   basic_tree<Key,Mapped,Tag, typename PB_DS_TRIE_NODE_AND_ITS_TRAITS::node_update, \
 	     typename __gnu_cxx::typelist::create2<E_Access_Traits, PB_DS_TRIE_NODE_AND_ITS_TRAITS >::type, Allocator>
 
@@ -588,7 +588,7 @@ namespace pb_ds
     // be copied by the E_Access_Traits object of the container
     // object.
     trie(const e_access_traits& t)
-      : base_type(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
@@ -602,11 +602,11 @@ namespace pb_ds
     // last_it will be inserted into the container object.
     template<typename It>
     trie(It first, It last, const e_access_traits& t)
-      : base_type(t)
+    : base_type(t)
     { base_type::copy_from_range(first, last); }
 
     trie(const trie& other)
-      : base_type((const base_type&)other) { }
+    : base_type((const base_type&)other) { }
 
     virtual
     ~trie() { }
@@ -614,7 +614,7 @@ namespace pb_ds
     trie& 
     operator=(const trie& other)
     {
-      if (this !=& other)
+      if (this != &other)
 	{
 	  trie tmp(other);
 	  swap(tmp);
@@ -661,7 +661,7 @@ namespace pb_ds
     { base_type::copy_from_range(first, last); }
 
     list_update(const list_update& other)
-      : base_type((const base_type&)other) { }
+    : base_type((const base_type&)other) { }
 
     virtual
     ~list_update() { }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
index 2659a0bb347..93035e86079 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
@@ -66,9 +66,9 @@ namespace pb_ds
   {
 
 #define PB_DS_CLASS_T_DEC \
-    template<typename Key, typename Mapped, class Hash_Fn, \
-	     class Eq_Fn, class Allocator, bool Store_Hash, \
-	     class Comb_Hash_Fn, class Resize_Policy>
+    template<typename Key, typename Mapped, typename Hash_Fn, \
+	     typename Eq_Fn, typename Allocator, bool Store_Hash, \
+	     typename Comb_Hash_Fn, typename Resize_Policy>
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
 #define PB_DS_CLASS_NAME cc_ht_map_data_
@@ -113,12 +113,12 @@ namespace pb_ds
     // <011i$i0|\|-<|-|4i|\|i|\|g |-|4$|-| 74813.
     template<typename Key,
 	     typename Mapped,
-	     class Hash_Fn,
-	     class Eq_Fn,
-	     class Allocator,
+	     typename Hash_Fn,
+	     typename Eq_Fn,
+	     typename Allocator,
 	     bool Store_Hash,
-	     class Comb_Hash_Fn,
-	     class Resize_Policy >
+	     typename Comb_Hash_Fn,
+	     typename Resize_Policy >
     class PB_DS_CLASS_NAME:
 #ifdef _GLIBCXX_DEBUG
       protected PB_DS_MAP_DEBUG_BASE_C_DEC,
@@ -128,48 +128,42 @@ namespace pb_ds
       public PB_DS_RANGED_HASH_FN_C_DEC,
       public PB_DS_TYPES_TRAITS_C_DEC
     {
-
     private:
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::comp_hash comp_hash;
-
-      struct entry : public PB_DS_TYPES_TRAITS_C_DEC::stored_value_type
+      typedef PB_DS_TYPES_TRAITS_C_DEC 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_;
+      typedef typename traits_base::store_extra_false_type store_hash_false_type;
+      typedef typename traits_base::store_extra_true_type store_hash_true_type;
+      typedef typename traits_base::no_throw_copies_false_type no_throw_copies_false_type;
+      typedef typename traits_base::no_throw_copies_true_type no_throw_copies_true_type;
+
+      struct entry : public traits_base::stored_value_type
       {
 	typename Allocator::template rebind<entry>::other::pointer m_p_next;
       };
 
-      typedef
-      typename Allocator::template rebind<entry>::other
-      entry_allocator;
+      typedef cond_dealtor<entry, Allocator> cond_dealtor_t;
 
+      typedef typename Allocator::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::const_reference
-      const_entry_reference;
-
-      typedef
-      typename Allocator::template rebind<entry_pointer>::other
-      entry_pointer_allocator;
-
+      typedef typename Allocator::template rebind<entry_pointer>::other entry_pointer_allocator;
       typedef typename entry_pointer_allocator::pointer entry_pointer_array;
 
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type_;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer_;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer
-      const_pointer_;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference_;
+      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;
 
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_reference
-      const_reference_;
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+#endif 
 
 #define PB_DS_GEN_POS std::pair<entry_pointer, typename Allocator::size_type>
 
@@ -181,19 +175,12 @@ namespace pb_ds
 #undef PB_DS_GEN_POS
 
     public:
-
+      typedef Allocator allocator;
       typedef typename Allocator::size_type size_type;
-
       typedef typename Allocator::difference_type difference_type;
-
       typedef Hash_Fn hash_fn;
-
       typedef Eq_Fn eq_fn;
-
-      typedef Allocator allocator;
-
       typedef Comb_Hash_Fn comb_hash_fn;
-
       typedef Resize_Policy resize_policy;
 
       enum
@@ -201,49 +188,21 @@ namespace pb_ds
 	  store_hash = Store_Hash
 	};
 
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_type key_type;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_pointer key_pointer;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_key_pointer
-      const_key_pointer;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_reference key_reference;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_key_reference
-      const_key_reference;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::mapped_type mapped_type;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::mapped_pointer
-      mapped_pointer;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_pointer
-      const_mapped_pointer;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::mapped_reference
-      mapped_reference;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_reference
-      const_mapped_reference;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer const_pointer;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_reference
-      const_reference;
+      typedef typename traits_base::key_type key_type;
+      typedef typename traits_base::key_pointer key_pointer;
+      typedef typename traits_base::const_key_pointer const_key_pointer;
+      typedef typename traits_base::key_reference key_reference;
+      typedef typename traits_base::const_key_reference const_key_reference;
+      typedef typename traits_base::mapped_type mapped_type;
+      typedef typename traits_base::mapped_pointer mapped_pointer;
+      typedef typename traits_base::const_mapped_pointer const_mapped_pointer;
+      typedef typename traits_base::mapped_reference mapped_reference;
+      typedef typename traits_base::const_mapped_reference const_mapped_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;
@@ -265,29 +224,28 @@ namespace pb_ds
 
       typedef const_iterator_ const_iterator;
 
-    public:
-
       PB_DS_CLASS_NAME();
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn);
+      PB_DS_CLASS_NAME(const Hash_Fn&);
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn);
+      PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&);
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Hash_Fn& r_comb_hash_fn);
+      PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&);
 
-      PB_DS_CLASS_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_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Hash_Fn&, 
+		       const Resize_Policy&);
 
-      PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other);
+      PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC&);
 
       virtual
       ~PB_DS_CLASS_NAME();
 
       void
-      swap(PB_DS_CLASS_C_DEC& other);
+      swap(PB_DS_CLASS_C_DEC&);
 
       template<typename It>
       void
-      copy_from_range(It first_it, It last_it);
+      copy_from_range(It, It);
 
       void
       initialize();
@@ -327,9 +285,7 @@ namespace pb_ds
 
       inline std::pair<point_iterator, bool>
       insert(const_reference r_val)
-      {
-	return insert_imp(r_val, traits_base::m_store_extra_indicator);
-      }
+      { return insert_imp(r_val, traits_base::m_store_extra_indicator); }
 
       inline mapped_reference
       operator[](const_key_reference r_key)
@@ -343,10 +299,10 @@ namespace pb_ds
       }
 
       inline point_iterator
-      find(const_key_reference r_key);
+      find(const_key_reference);
 
       inline const_point_iterator
-      find(const_key_reference r_key) const;
+      find(const_key_reference) const;
 
       inline point_iterator
       find_end();
@@ -355,11 +311,11 @@ namespace pb_ds
       find_end() const;
 
       inline bool
-      erase(const_key_reference r_key);
+      erase(const_key_reference);
 
       template<typename Pred>
       inline size_type
-      erase_if(Pred pred);
+      erase_if(Pred);
 
       void
       clear();
@@ -387,38 +343,6 @@ namespace pb_ds
 #endif 
 
     private:
-      typedef PB_DS_TYPES_TRAITS_C_DEC traits_base;
-
-      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_MAP_DEBUG_BASE_C_DEC map_debug_base;
-#endif 
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_false_type
-      store_hash_false_type;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_true_type
-      store_hash_true_type;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::
-      no_throw_copies_false_type
-      no_throw_copies_false_type;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::
-      no_throw_copies_true_type
-      no_throw_copies_true_type;
-
-    private:
-
       void
       deallocate_all();
 
@@ -441,19 +365,19 @@ namespace pb_ds
       resize_imp_no_exceptions_reassign_pointer(entry_pointer, entry_pointer_array, store_hash_false_type);
 
       inline entry_pointer
-      resize_imp_no_exceptions_reassign_pointer(entry_pointer p_e, entry_pointer_array a_p_entries_resized, store_hash_true_type);
+      resize_imp_no_exceptions_reassign_pointer(entry_pointer, entry_pointer_array, store_hash_true_type);
 
       void
-      deallocate_links_in_list(entry_pointer p_e);
+      deallocate_links_in_list(entry_pointer);
 
       inline entry_pointer
-      get_entry(const_reference r_val, no_throw_copies_false_type);
+      get_entry(const_reference, no_throw_copies_false_type);
 
       inline entry_pointer
-      get_entry(const_reference r_val, no_throw_copies_true_type);
+      get_entry(const_reference, no_throw_copies_true_type);
 
       inline void
-      rels_entry(entry_pointer p_e);
+      rels_entry(entry_pointer);
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
       inline mapped_reference
@@ -461,7 +385,7 @@ namespace pb_ds
       {
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
         const size_type pos = ranged_hash_fn_base::operator()(r_key);
-	entry_pointer p_e = m_a_p_entries[pos];
+	entry_pointer p_e = m_entries[pos];
 	resize_base::notify_insert_search_start();
 
 	while (p_e != NULL 
@@ -487,7 +411,7 @@ namespace pb_ds
       {
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 	comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key);
-	entry_pointer p_e = m_a_p_entries[pos_hash_pair.first];
+	entry_pointer p_e = m_entries[pos_hash_pair.first];
 	resize_base::notify_insert_search_start();
 	while (p_e != NULL && 
 	       !hash_eq_fn_base::operator()(p_e->m_value.first, p_e->m_hash, r_key, pos_hash_pair.second))
@@ -504,15 +428,16 @@ namespace pb_ds
 	  }
 
 	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
-	return insert_new_imp(value_type(r_key, mapped_type()), pos_hash_pair)->second;
+	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 r_val, store_hash_false_type);
+      insert_imp(const_reference, store_hash_false_type);
 
       inline std::pair<point_iterator, bool>
-      insert_imp(const_reference r_val, store_hash_true_type);
+      insert_imp(const_reference, store_hash_true_type);
 
       inline pointer
       insert_new_imp(const_reference r_val, size_type pos)
@@ -521,11 +446,11 @@ namespace pb_ds
 	  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, PB_DS_TYPES_TRAITS_C_DEC::m_no_throw_copies_indicator);
+	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_a_p_entries[pos];
-	m_a_p_entries[pos] = p_e;
+	p_e->m_p_next = m_entries[pos];
+	m_entries[pos] = p_e;
 	resize_base::notify_inserted(++m_num_used_e);
 
 	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));)
@@ -540,12 +465,12 @@ namespace pb_ds
 	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, PB_DS_TYPES_TRAITS_C_DEC::m_no_throw_copies_indicator);
+	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_a_p_entries[r_pos_hash_pair.first];
-	m_a_p_entries[r_pos_hash_pair.first] = p_e;
+	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(map_debug_base::insert_new(PB_DS_V2F(r_val));)
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -555,7 +480,7 @@ namespace pb_ds
       inline pointer
       find_key_pointer(const_key_reference r_key, store_hash_false_type)
       {
-	entry_pointer p_e = m_a_p_entries[ranged_hash_fn_base::operator()(r_key)];
+	entry_pointer p_e = m_entries[ranged_hash_fn_base::operator()(r_key)];
 	resize_base::notify_find_search_start();
 	while (p_e != NULL && 
 	       !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
@@ -579,7 +504,7 @@ namespace pb_ds
       find_key_pointer(const_key_reference r_key, store_hash_true_type)
       {
 	comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key);
-	entry_pointer p_e = m_a_p_entries[pos_hash_pair.first];
+	entry_pointer p_e = m_entries[pos_hash_pair.first];
 	resize_base::notify_find_search_start();
 	while (p_e != NULL && 
 	       !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
@@ -602,17 +527,18 @@ namespace pb_ds
       }
 
       inline bool
-      erase_in_pos_imp(const_key_reference r_key, size_type pos);
+      erase_in_pos_imp(const_key_reference, size_type);
 
       inline bool
-      erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair);
+      erase_in_pos_imp(const_key_reference, const comp_hash&);
 
       inline void
-      erase_entry_pointer(entry_pointer& r_p_e);
+      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(pointer& r_p_value, 
+		   std::pair<entry_pointer, size_type>& r_pos) const
       {
 	inc_it_state((const_mapped_pointer& )r_p_value, r_pos);
       }
@@ -626,15 +552,15 @@ namespace pb_ds
 	r_pos.first = r_pos.first->m_p_next;
 	if (r_pos.first != NULL)
 	  {
-	    r_p_value =& r_pos.first->m_value;
+	    r_p_value = &r_pos.first->m_value;
 	    return;
 	  }
 
-	for (++r_pos.second; r_pos.second < m_num_e_p; ++r_pos.second)
-	  if (m_a_p_entries[r_pos.second] != NULL)
+	for (++r_pos.second; r_pos.second < m_num_e; ++r_pos.second)
+	  if (m_entries[r_pos.second] != NULL)
 	    {
-	      r_pos.first = m_a_p_entries[r_pos.second];
-	      r_p_value =& r_pos.first->m_value;
+	      r_pos.first = m_entries[r_pos.second];
+	      r_p_value = &r_pos.first->m_value;
 	      return;
 	    }
 	r_p_value = NULL;
@@ -644,11 +570,11 @@ namespace pb_ds
       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_p; ++r_pos.second)
-	  if (m_a_p_entries[r_pos.second] != NULL)
+	for (r_pos.second = 0; r_pos.second < m_num_e; ++r_pos.second)
+	  if (m_entries[r_pos.second] != NULL)
 	    {
-	      r_pos.first = m_a_p_entries[r_pos.second];
-	      r_p_value =& r_pos.first->m_value;
+	      r_pos.first = m_entries[r_pos.second];
+	      r_p_value = &r_pos.first->m_value;
 	      return;
 	    }
 	r_p_value = NULL;
@@ -673,31 +599,22 @@ namespace pb_ds
 #endif 
 
     private:
-      static entry_allocator s_entry_allocator;
-
-      static entry_pointer_allocator s_entry_pointer_allocator;
-
-      typedef cond_dealtor< entry, Allocator> cond_dealtor_t;
-
-      entry_pointer_array m_a_p_entries;
-
-      size_type m_num_e_p;
-
-      size_type m_num_used_e;
-
 #ifdef PB_DS_DATA_TRUE_INDICATOR
       friend class iterator_;
 #endif 
 
       friend class const_iterator_;
 
-      static iterator s_end_it;
+      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 const_point_iterator 	s_const_find_end_it;
 
-      static const_iterator s_const_end_it;
-
-      static point_iterator s_find_end_it;
-
-      static const_point_iterator s_const_find_end_it;
+      size_type 			m_num_e;
+      size_type 			m_num_used_e;
+      entry_pointer_array 		m_entries;
 
       enum
 	{
@@ -727,10 +644,8 @@ namespace pb_ds
 #undef PB_DS_TYPES_TRAITS_C_DEC
 #undef PB_DS_MAP_DEBUG_BASE_C_DEC
 #undef PB_DS_CLASS_NAME
-
 #undef PB_DS_V2F
 #undef PB_DS_V2S
-
 #undef PB_DS_STATIC_ASSERT
 
   } // namespace detail
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
index 9d6ee01efff..7273b0ff522 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
@@ -67,9 +67,8 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_NAME() :
   ranged_hash_fn_base(resize_base::get_nearest_larger_size(1)),
-  m_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e_p(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+  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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -79,9 +78,8 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn) :
   ranged_hash_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn),
-  m_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e_p(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+  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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -92,13 +90,12 @@ PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_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_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e_p(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+  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_a_p_entries, m_a_p_entries + m_num_e_p, (entry_pointer)NULL);
+  std::fill(m_entries, m_entries + m_num_e, (entry_pointer)NULL);
   Resize_Policy::notify_cleared();
-  ranged_hash_fn_base::notify_resized(m_num_e_p);
+  ranged_hash_fn_base::notify_resized(m_num_e);
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
 }
 
@@ -107,11 +104,9 @@ PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_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_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e_p(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+		      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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -123,11 +118,9 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Hash
   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_a_p_entries(s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e_p(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+		      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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -140,11 +133,9 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
   map_debug_base(other),
 #endif 
   PB_DS_HASH_EQ_FN_C_DEC(other),
-  resize_base(other),
-  ranged_hash_fn_base(other),
-  m_a_p_entries(m_a_p_entries = s_entry_pointer_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e_p(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+  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(m_entries = s_entry_pointer_allocator.allocate(m_num_e))
 {
   initialize();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -152,7 +143,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
       {
         copy_from_range(other.begin(), other.end());
       }
-    catch(...)
+    catch (...)
       {
         deallocate_all();
         throw;
@@ -173,8 +164,8 @@ swap(PB_DS_CLASS_C_DEC& other)
   _GLIBCXX_DEBUG_ONLY(assert_valid());
   _GLIBCXX_DEBUG_ONLY(other.assert_valid());
 
-  std::swap(m_a_p_entries, other.m_a_p_entries);
-  std::swap(m_num_e_p, other.m_num_e_p);
+  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);
@@ -191,7 +182,7 @@ PB_DS_CLASS_C_DEC::
 deallocate_all()
 {
   clear();
-  s_entry_pointer_allocator.deallocate(m_a_p_entries, m_num_e_p);
+  s_entry_pointer_allocator.deallocate(m_entries, m_num_e);
 }
 
 PB_DS_CLASS_T_DEC
@@ -199,8 +190,8 @@ void
 PB_DS_CLASS_C_DEC::
 initialize()
 {
-  std::fill(m_a_p_entries, m_a_p_entries + m_num_e_p, entry_pointer(NULL));
-  Resize_Policy::notify_resized(m_num_e_p);
+  std::fill(m_entries, m_entries + m_num_e, entry_pointer(NULL));
+  Resize_Policy::notify_resized(m_num_e);
   Resize_Policy::notify_cleared();
-  ranged_hash_fn_base::notify_resized(m_num_e_p);
+  ranged_hash_fn_base::notify_resized(m_num_e);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
index 3bf820f94e6..7c38d1092e2 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
@@ -55,7 +55,7 @@ constructor_insert_new_imp(const_mapped_reference r_val, size_type pos, integral
 
   // At this point no exceptions can be thrown.
 
-  p_e->m_p_next = m_a_p_entries[pos];
-  m_a_p_entries[pos] = p_e;
+  p_e->m_p_next = m_entries[pos];
+  m_entries[pos] = p_e;
   _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(r_key);)
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
index 8dbbe5cbf99..6ebd1f722b7 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
@@ -55,9 +55,9 @@ constructor_insert_new_imp(const_reference r_val, size_type pos, true_type)
 				traits_base::s_no_throw_copies_indicator);
 
   // At this point no exceptions can be thrown.
-  p_e->m_p_next = m_a_p_entries[pos];
+  p_e->m_p_next = m_entries[pos];
   p_e->m_hash = ranged_hash_fn_base::operator()((const_key_reference)(PB_DS_V2F(p_e->m_value))).second;
 
-  m_a_p_entries[pos] = p_e;
+  m_entries[pos] = p_e;
   _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(r_key);)
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
index 9de8696c422..61cbfa90d2e 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
@@ -52,7 +52,7 @@ PB_DS_CLASS_C_DEC::
 assert_valid() const
 {
   map_debug_base::check_size(m_num_used_e);
-  assert_entry_pointer_array_valid(m_a_p_entries);
+  assert_entry_pointer_array_valid(m_entries);
 }
 
 PB_DS_CLASS_T_DEC
@@ -61,7 +61,7 @@ PB_DS_CLASS_C_DEC::
 assert_entry_pointer_array_valid(const entry_pointer_array a_p_entries) const
 {
   size_type iterated_num_used_e = 0;
-  for (size_type pos = 0; pos < m_num_e_p; ++pos)
+  for (size_type pos = 0; pos < m_num_e; ++pos)
     {
       entry_pointer p_e = a_p_entries[pos];
       while (p_e != NULL)
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
index be92f2f9c8d..3a821385028 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
@@ -70,25 +70,25 @@ erase_if(Pred pred)
 {
   size_type num_ersd = 0;
 
-  for (size_type pos = 0; pos < m_num_e_p; ++pos)
+  for (size_type pos = 0; pos < m_num_e; ++pos)
     {
       typedef
 	typename PB_DS_TYPES_TRAITS_C_DEC::const_reference
 	const_reference;
 
-      while (m_a_p_entries[pos] != NULL&& 
-	     pred(m_a_p_entries[pos]->m_value))
+      while (m_entries[pos] != NULL&& 
+	     pred(m_entries[pos]->m_value))
         {
 	  ++num_ersd;
 
-	  entry_pointer p_next_e = m_a_p_entries[pos]->m_p_next;
+	  entry_pointer p_next_e = m_entries[pos]->m_p_next;
 
-	  erase_entry_pointer(m_a_p_entries[pos]);
+	  erase_entry_pointer(m_entries[pos]);
 
-	  m_a_p_entries[pos] = p_next_e;
+	  m_entries[pos] = p_next_e;
         }
 
-      entry_pointer p_e = m_a_p_entries[pos];
+      entry_pointer p_e = m_entries[pos];
 
       while (p_e != NULL&&  p_e->m_p_next != NULL)
         {
@@ -113,9 +113,9 @@ void
 PB_DS_CLASS_C_DEC::
 clear()
 {
-  for (size_type pos = 0; pos < m_num_e_p; ++pos)
-    while (m_a_p_entries[pos] != NULL)
-      erase_entry_pointer(m_a_p_entries[pos]);
+  for (size_type pos = 0; pos < m_num_e; ++pos)
+    while (m_entries[pos] != NULL)
+      erase_entry_pointer(m_entries[pos]);
 
   do_resize_if_needed_no_throw();
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
index 3d3dd9d1f81..298c580c34e 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
@@ -63,7 +63,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
 
-    entry_pointer p_e = m_a_p_entries[pos];
+    entry_pointer p_e = m_entries[pos];
 
   resize_base::notify_erase_search_start();
 
@@ -88,7 +88,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
       _GLIBCXX_DEBUG_ONLY(map_debug_base::
 		     check_key_exists(r_key);)
 
-        erase_entry_pointer(m_a_p_entries[pos]);
+        erase_entry_pointer(m_entries[pos]);
 
       do_resize_if_needed_no_throw();
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
index 490c365c9fd..ddd898bdc7c 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
@@ -52,7 +52,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
 
-    entry_pointer p_e = m_a_p_entries[r_pos_hash_pair.first];
+    entry_pointer p_e = m_entries[r_pos_hash_pair.first];
 
   resize_base::notify_erase_search_start();
 
@@ -80,7 +80,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
       _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(
 						      r_key);)
 
-        erase_entry_pointer(m_a_p_entries[r_pos_hash_pair.first]);
+        erase_entry_pointer(m_entries[r_pos_hash_pair.first]);
 
       do_resize_if_needed_no_throw();
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
index 64ce3928f6a..41815c86608 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
@@ -58,7 +58,7 @@ insert_imp(const_reference r_val, store_hash_false_type)
 
   const size_type pos = ranged_hash_fn_base::operator()(r_key);
 
-  entry_pointer p_e = m_a_p_entries[pos];
+  entry_pointer p_e = m_entries[pos];
 
   resize_base::notify_insert_search_start();
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
index b3841391d89..73a0aa9a02b 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
@@ -58,7 +58,7 @@ insert_imp(const_reference r_val, store_hash_true_type)
 
   comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key);
 
-  entry_pointer p_e = m_a_p_entries[pos_hash_pair.first];
+  entry_pointer p_e = m_entries[pos_hash_pair.first];
 
   resize_base::notify_insert_search_start();
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp
index b508d4da138..fb692b50940 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp
@@ -52,7 +52,7 @@ do_resize_if_needed()
   if (!resize_base::is_resize_needed())
     return (false);
 
-  resize_imp(resize_base::get_new_size(        m_num_e_p, m_num_used_e));
+  resize_imp(resize_base::get_new_size(        m_num_e, m_num_used_e));
 
   return (true);
 }
@@ -76,7 +76,7 @@ do_resize_if_needed_no_throw()
 
   try
     {
-      resize_imp(resize_base::get_new_size(            m_num_e_p, m_num_used_e));
+      resize_imp(resize_base::get_new_size(            m_num_e, m_num_used_e));
     }
   catch(...)
     { }
@@ -91,10 +91,10 @@ resize_imp(size_type new_size)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
 
-    if (new_size == m_num_e_p)
+    if (new_size == m_num_e)
       return;
 
-  const size_type old_size = m_num_e_p;
+  const size_type old_size = m_num_e;
 
   entry_pointer_array a_p_entries_resized;
 
@@ -108,7 +108,7 @@ resize_imp(size_type new_size)
 
       a_p_entries_resized = s_entry_pointer_allocator.allocate(new_size);
 
-      m_num_e_p = new_size;
+      m_num_e = new_size;
     }
   catch(...)
     {
@@ -131,23 +131,23 @@ 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_p,(entry_pointer)NULL);
+  std::fill(a_p_entries_resized, a_p_entries_resized + m_num_e,(entry_pointer)NULL);
 
   for (size_type pos = 0; pos < old_size; ++pos)
     {
-      entry_pointer p_e = m_a_p_entries[pos];
+      entry_pointer p_e = m_entries[pos];
 
       while (p_e != NULL)
 	p_e = resize_imp_no_exceptions_reassign_pointer(p_e,  a_p_entries_resized,  traits_base::m_store_extra_indicator);
     }
 
-  m_num_e_p = new_size;
+  m_num_e = new_size;
 
   _GLIBCXX_DEBUG_ONLY(assert_entry_pointer_array_valid(a_p_entries_resized);)
 
-    s_entry_pointer_allocator.deallocate(m_a_p_entries, old_size);
+    s_entry_pointer_allocator.deallocate(m_entries, old_size);
 
-  m_a_p_entries = a_p_entries_resized;
+  m_entries = a_p_entries_resized;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp
index 4c3e095ed26..e40a45c60ab 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp
@@ -51,14 +51,14 @@ void
 PB_DS_CLASS_C_DEC::
 trace() const
 {
-  std::cerr << static_cast<unsigned long>(m_num_e_p) << " " <<
+  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_p; ++i)
+  for (size_type i = 0; i < m_num_e; ++i)
     {
       std::cerr << static_cast<unsigned long>(i) << " ";
 
-      trace_list(m_a_p_entries[i]);
+      trace_list(m_entries[i]);
 
       std::cerr << std::endl;
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp
index 8a673e7c08b..91763669c76 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp
@@ -49,7 +49,8 @@ PB_DS_CLASS_NAME()
 { }
 
 inline
-PB_DS_CLASS_NAME(const PB_DS_CLASS_NAME& other) : base_type((const base_type&)other)
+PB_DS_CLASS_NAME(const PB_DS_CLASS_NAME& other) 
+: base_type((const base_type&)other)
 { }
 
 template<typename T0>
@@ -69,60 +70,40 @@ PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2) : base_type(t0, t1, t2)
 
 template<typename T0, typename T1, typename T2, typename T3>
 inline
-PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3) : base_type(t0, t1, t2, t3)
+PB_DS_CLASS_NAME(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>
+template<typename T0, typename T1, typename T2, typename T3, typename T4>
 inline
-PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) : base_type(t0, t1, t2, t3, t4)
+PB_DS_CLASS_NAME(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,
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
 	 typename T5>
 inline
-PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) : base_type(t0, t1, t2, t3, t4, t5)
+PB_DS_CLASS_NAME(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>
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	 typename T5, typename T6>
 inline
-PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) : base_type(t0, t1, t2, t3, t4, t5, t6)
+PB_DS_CLASS_NAME(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>
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	 typename T5, typename T6, typename T7>
 inline
-PB_DS_CLASS_NAME(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)
+PB_DS_CLASS_NAME(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>
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	 typename T5, typename T6, typename T7, typename T8>
 inline
-PB_DS_CLASS_NAME(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)
+PB_DS_CLASS_NAME(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)
 { }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
index 817bcd0ca70..fa1d9b204e9 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
@@ -61,11 +61,10 @@ copy_from_range(It first_it, It last_it)
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_NAME() :
-  ranged_probe_fn_base(resize_base::get_nearest_larger_size(1)),
-  m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+PB_DS_CLASS_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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -73,11 +72,10 @@ PB_DS_CLASS_NAME() :
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn)    :
-  ranged_probe_fn_base(resize_base::get_nearest_larger_size(1), r_hash_fn),
-  m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+PB_DS_CLASS_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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -85,12 +83,11 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn)    :
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) :
-  hash_eq_fn_base(r_eq_fn),
+PB_DS_CLASS_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_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+  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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -98,13 +95,13 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) :
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_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),
+PB_DS_CLASS_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_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+  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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -112,13 +109,13 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Prob
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_hash_fn, const Probe_Fn& r_probe_fn) :
-  hash_eq_fn_base(r_eq_fn),
+PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, 
+		 const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& probe_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, r_probe_fn),
-  m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+		       r_hash_fn, comb_hash_fn, probe_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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -126,14 +123,14 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Prob
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_hash_fn, const Probe_Fn& r_probe_fn, const Resize_Policy& r_resize_policy) :
-  hash_eq_fn_base(r_eq_fn),
-  resize_base(r_resize_policy),
+PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, 
+		 const Comb_Probe_Fn& comb_hash_fn, const Probe_Fn& probe_fn, 
+		 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, r_comb_hash_fn, r_probe_fn),
-  m_a_entries(s_entry_allocator.allocate(resize_base::get_nearest_larger_size(1))),
-  m_num_e(resize_base::get_nearest_larger_size(1)),
-  m_num_used_e(0)
+		       r_hash_fn, comb_hash_fn, probe_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();
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
@@ -148,37 +145,34 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
   hash_eq_fn_base(other),
   resize_base(other),
   ranged_probe_fn_base(other),
-  m_a_entries(s_entry_allocator.allocate(other.m_num_e)),
   m_num_e(other.m_num_e),
-  m_num_used_e(other.m_num_used_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_a_entries[i].m_stat = (entry_status)empty_entry_status;
+    m_entries[i].m_stat = (entry_status)empty_entry_status;
 
   try
     {
       for (size_type i = 0; i < m_num_e; ++i)
         {
-	  m_a_entries[i].m_stat = other.m_a_entries[i].m_stat;
-	  if (m_a_entries[i].m_stat == valid_entry_status)
-	    new (m_a_entries + i) entry(other.m_a_entries[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(...)
+  catch (...)
     {
       deallocate_all();
       throw;
     }
-
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
-    }
+}
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 ~PB_DS_CLASS_NAME()
-{
-  deallocate_all();
-}
+{ deallocate_all(); }
 
 PB_DS_CLASS_T_DEC
 void
@@ -187,9 +181,9 @@ swap(PB_DS_CLASS_C_DEC& other)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid());
   _GLIBCXX_DEBUG_ONLY(other.assert_valid());
-  std::swap(m_a_entries, other.m_a_entries);
   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);
@@ -204,8 +198,8 @@ PB_DS_CLASS_C_DEC::
 deallocate_all()
 {
   clear();
-  erase_all_valid_entries(m_a_entries, m_num_e);
-  s_entry_allocator.deallocate(m_a_entries, m_num_e);
+  erase_all_valid_entries(m_entries, m_num_e);
+  s_entry_allocator.deallocate(m_entries, m_num_e);
 }
 
 PB_DS_CLASS_T_DEC
@@ -215,7 +209,7 @@ erase_all_valid_entries(entry_array a_entries_resized, size_type size)
 {
   for (size_type pos = 0; pos < size; ++pos)
     {
-      entry_pointer p_e =& a_entries_resized[pos];
+      entry_pointer p_e = &a_entries_resized[pos];
       if (p_e->m_stat == valid_entry_status)
 	p_e->m_value.~value_type();
     }
@@ -230,6 +224,6 @@ initialize()
   Resize_Policy::notify_cleared();
   ranged_probe_fn_base::notify_resized(m_num_e);
   for (size_type i = 0; i < m_num_e; ++i)
-    m_a_entries[i].m_stat = (entry_status)empty_entry_status;
+    m_entries[i].m_stat = empty_entry_status;
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
index c7a3d403ff4..72d2a19f3bc 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
@@ -50,9 +50,9 @@ inline void
 PB_DS_CLASS_C_DEC::
 constructor_insert_new_imp(const_mapped_reference r_val, size_type pos, integral_constant<int,false>)
 {
-  _GLIBCXX_DEBUG_ASSERT(m_a_entries[pos].m_stat != valid_entry_status);
+  _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status);
 
-  entry* const p_e = m_a_entries + pos;
+  entry* const p_e = m_entries + pos;
 
   new (&p_e->m_value) mapped_value_type(r_val);
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
index 74e5429b420..d532b84b0b8 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
@@ -50,9 +50,9 @@ inline void
 PB_DS_CLASS_C_DEC::
 constructor_insert_new_imp(const_mapped_reference r_val, size_type pos, true_type)
 {
-  _GLIBCXX_DEBUG_ASSERT(m_a_entries[pos].m_stat != valid_entry_status);
+  _GLIBCXX_DEBUG_ASSERT(m_entries[pos].m_stat != valid_entry_status);
 
-  entry* const p_e = m_a_entries + pos;
+  entry* const p_e = m_entries + pos;
 
   new (&p_e->m_value) mapped_value_type(r_val);
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
index 1efdd183b80..fd8ca9abe12 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
@@ -52,7 +52,7 @@ PB_DS_CLASS_C_DEC::
 assert_valid() const
 {
   map_debug_base::check_size(m_num_used_e);
-  assert_entry_array_valid(m_a_entries, traits_base::m_store_extra_indicator);
+  assert_entry_array_valid(m_entries, traits_base::m_store_extra_indicator);
 }
 
 #include <ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp>
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
index df4f673bb5f..9da85072586 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
@@ -50,18 +50,9 @@ PB_DS_CLASS_C_DEC::
 erase_entry(entry_pointer p_e)
 {
   _GLIBCXX_DEBUG_ASSERT(p_e->m_stat = valid_entry_status);
-
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::erase_existing(
-						PB_DS_V2F(p_e->m_value));)
-
-    typedef
-    typename PB_DS_TYPES_TRAITS_C_DEC::stored_value_type
-    stored_value_type;
-
+  _GLIBCXX_DEBUG_ONLY(map_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);
 }
@@ -73,14 +64,11 @@ clear()
 {
   for (size_type pos = 0; pos < m_num_e; ++pos)
     {
-      entry_pointer p_e =& m_a_entries[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();
 }
 
@@ -91,36 +79,28 @@ PB_DS_CLASS_C_DEC::
 erase_if(Pred pred)
 {
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
-
-    size_type num_ersd = 0;
-
+  size_type num_ersd = 0;
   for (size_type pos = 0; pos < m_num_e; ++pos)
     {
-      entry_pointer p_e =& m_a_entries[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();
-
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
-
-    return (num_ersd);
+  return num_ersd;
 }
 
 PB_DS_CLASS_T_DEC
 inline bool
 PB_DS_CLASS_C_DEC::
 erase(const_key_reference r_key)
-{
-  return (erase_imp(r_key, traits_base::m_store_extra_indicator));
-}
+{ 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/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
index 0f6949a912d..94d1f871b9a 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
@@ -63,7 +63,7 @@ erase_imp(const_key_reference r_key,  false_type)
       const size_type pos =
 	ranged_probe_fn_base::operator()(                r_key,  hash, i);
 
-      entry* const p_e = m_a_entries + pos;
+      entry* const p_e = m_entries + pos;
 
       switch(p_e->m_stat)
         {
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
index d4eda6bda58..77f1aa31de8 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
@@ -61,7 +61,7 @@ erase_imp(const_key_reference r_key,  true_type)
     {
       const size_type pos = ranged_probe_fn_base::operator()(            r_key, pos_hash_pair.second, i);
 
-      entry* const p_e = m_a_entries + pos;
+      entry* const p_e = m_entries + pos;
 
       switch(p_e->m_stat)
         {
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp
index 2f89522744e..604dc40043f 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp
@@ -50,8 +50,7 @@ PB_DS_CLASS_C_DEC::
 find(const_key_reference r_key)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
-
-    return ((find_key_pointer(r_key, traits_base::m_store_extra_indicator)));
+   return find_key_pointer(r_key, traits_base::m_store_extra_indicator);
 }
 
 PB_DS_CLASS_T_DEC
@@ -60,24 +59,18 @@ PB_DS_CLASS_C_DEC::
 find(const_key_reference r_key) const
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
-
-    return (const_cast<PB_DS_CLASS_C_DEC& >(*this).
-	    find_key_pointer(r_key, traits_base::m_store_extra_indicator));
+  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 (NULL);
-}
+{ return NULL; }
 
 PB_DS_CLASS_T_DEC
 inline typename PB_DS_CLASS_C_DEC::const_point_iterator
 PB_DS_CLASS_C_DEC::
 find_end() const
-{
-  return (NULL);
-}
+{ return NULL; }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
index 0497fbc8619..4d527bad2cc 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
@@ -62,18 +62,10 @@ namespace pb_ds
 {
   namespace detail
   {
-
-#define PB_DS_CLASS_T_DEC						\
-    template<								\
-						typename Key,		\
-						typename Mapped,	\
-						class Hash_Fn,		\
-						class Eq_Fn,		\
-						class Allocator,	\
-						bool Store_Hash,	\
-						class Comb_Probe_Fn,	\
-						class Probe_Fn,		\
-						class Resize_Policy>
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Mapped, typename Hash_Fn, typename Eq_Fn, \
+	     typename Allocator, bool Store_Hash, typename Comb_Probe_Fn, \
+	     typename Probe_Fn,	typename Resize_Policy>
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
 #define PB_DS_CLASS_NAME gp_ht_map_data_
@@ -83,43 +75,21 @@ namespace pb_ds
 #define PB_DS_CLASS_NAME gp_ht_map_no_data_
 #endif 
 
-#define PB_DS_CLASS_C_DEC					\
-    PB_DS_CLASS_NAME<						\
-						Key,		\
-						Mapped,		\
-						Hash_Fn,	\
-						Eq_Fn,		\
-						Allocator,	\
-						Store_Hash,	\
-						Comb_Probe_Fn,	\
-						Probe_Fn,	\
-						Resize_Policy>
-
-#define PB_DS_HASH_EQ_FN_C_DEC					\
-    hash_eq_fn<					\
-						Key,		\
-						Eq_Fn,		\
-						Allocator,	\
-						Store_Hash>
-
-#define PB_DS_RANGED_PROBE_FN_C_DEC					\
-    ranged_probe_fn<					\
-							Key,		\
-							Hash_Fn,	\
-							Allocator,	\
-							Comb_Probe_Fn,	\
-							Probe_Fn,	\
-							Store_Hash>
-
-#define PB_DS_TYPES_TRAITS_C_DEC				\
-    types_traits<						\
-						Key,		\
-						Mapped,		\
-						Allocator,	\
-						Store_Hash>
+#define PB_DS_CLASS_C_DEC \
+    PB_DS_CLASS_NAME<Key, Mapped, Hash_Fn, Eq_Fn, Allocator,	\
+		     Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy>
+
+#define PB_DS_HASH_EQ_FN_C_DEC \
+    hash_eq_fn<Key, Eq_Fn, Allocator, Store_Hash>
+
+#define PB_DS_RANGED_PROBE_FN_C_DEC \
+    ranged_probe_fn<Key, Hash_Fn, Allocator, Comb_Probe_Fn, Probe_Fn, Store_Hash>
+
+#define PB_DS_TYPES_TRAITS_C_DEC \
+    types_traits<Key, Mapped, Allocator, Store_Hash>
 
 #ifdef _GLIBCXX_DEBUG
-#define PB_DS_MAP_DEBUG_BASE_C_DEC					\
+#define PB_DS_MAP_DEBUG_BASE_C_DEC \
     map_debug_base<Key, Eq_Fn, typename Allocator::template rebind<Key>::other::const_reference>
 #endif 
 
@@ -133,21 +103,19 @@ namespace pb_ds
 #define PB_DS_V2S(X) Mapped()
 #endif 
 
-#define PB_DS_STATIC_ASSERT(UNIQUE, E)					\
-    typedef								\
-    static_assert_dumclass<				\
-									sizeof(static_assert<(bool)(E)>)> \
+#define PB_DS_STATIC_ASSERT(UNIQUE, E) \
+    typedef static_assert_dumclass<sizeof(static_assert<(bool)(E)>)> \
     UNIQUE##static_assert_type
 
     template<typename Key,
 	     typename Mapped,
-	     class Hash_Fn,
-	     class Eq_Fn,
-	     class Allocator,
+	     typename Hash_Fn,
+	     typename Eq_Fn,
+	     typename Allocator,
 	     bool Store_Hash,
-	     class Comb_Probe_Fn,
-	     class Probe_Fn,
-	     class Resize_Policy>
+	     typename Comb_Probe_Fn,
+	     typename Probe_Fn,
+	     typename Resize_Policy>
     class PB_DS_CLASS_NAME :
 #ifdef _GLIBCXX_DEBUG
       protected PB_DS_MAP_DEBUG_BASE_C_DEC,
@@ -157,33 +125,46 @@ namespace pb_ds
       public PB_DS_RANGED_PROBE_FN_C_DEC,
       public PB_DS_TYPES_TRAITS_C_DEC
     {
-
     private:
+      typedef PB_DS_TYPES_TRAITS_C_DEC traits_base;
+      typedef typename traits_base::store_extra_false_type store_hash_false_type;
+      typedef typename traits_base::store_extra_true_type store_hash_true_type;
+      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));
 
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_false_type
-      store_hash_false_type;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::store_extra_true_type
-      store_hash_true_type;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type_;
+      struct entry : public traits_base::stored_value_type
+      {
+	entry_status m_stat;
+      };
 
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer_;
+      typedef typename Allocator::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
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer
-      const_pointer_;
+      typedef PB_DS_RANGED_PROBE_FN_C_DEC ranged_probe_fn_base;
 
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference_;
+#ifdef _GLIBCXX_DEBUG
+      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+#endif 
 
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_reference
-      const_reference_;
+      typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base;
+      typedef Resize_Policy resize_base;
 
-#define PB_DS_GEN_POS				\
-      typename Allocator::size_type
+#define PB_DS_GEN_POS typename Allocator::size_type
 
 #include <ext/pb_ds/detail/unordered_iterator/const_point_iterator.hpp>
 #include <ext/pb_ds/detail/unordered_iterator/point_iterator.hpp>
@@ -193,21 +174,13 @@ namespace pb_ds
 #undef PB_DS_GEN_POS
 
     public:
-
+      typedef Allocator allocator;
       typedef typename Allocator::size_type size_type;
-
       typedef typename Allocator::difference_type difference_type;
-
       typedef Hash_Fn hash_fn;
-
       typedef Eq_Fn eq_fn;
-
-      typedef Allocator allocator;
-
       typedef Probe_Fn probe_fn;
-
       typedef Comb_Probe_Fn comb_probe_fn;
-
       typedef Resize_Policy resize_policy;
 
       enum
@@ -215,85 +188,57 @@ namespace pb_ds
 	  store_hash = Store_Hash
 	};
 
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_type key_type;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_pointer key_pointer;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_key_pointer
-      const_key_pointer;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::key_reference key_reference;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_key_reference
-      const_key_reference;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::mapped_type mapped_type;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::mapped_pointer
-      mapped_pointer;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_pointer
-      const_mapped_pointer;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::mapped_reference
-      mapped_reference;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_mapped_reference
-      const_mapped_reference;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::value_type value_type;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::pointer pointer;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::const_pointer const_pointer;
-
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::reference reference;
-
-      typedef
-      typename PB_DS_TYPES_TRAITS_C_DEC::const_reference
-      const_reference;
+      typedef typename traits_base::key_type key_type;
+      typedef typename traits_base::key_pointer key_pointer;
+      typedef typename traits_base::const_key_pointer const_key_pointer;
+      typedef typename traits_base::key_reference key_reference;
+      typedef typename traits_base::const_key_reference const_key_reference;
+      typedef typename traits_base::mapped_type mapped_type;
+      typedef typename traits_base::mapped_pointer mapped_pointer;
+      typedef typename traits_base::const_mapped_pointer const_mapped_pointer;
+      typedef typename traits_base::mapped_reference mapped_reference;
+      typedef typename traits_base::const_mapped_reference const_mapped_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_TRUE_INDICATOR
+#endif 
 
 #ifdef PB_DS_DATA_FALSE_INDICATOR
       typedef const_point_iterator_ point_iterator;
-#endif // #ifdef PB_DS_DATA_FALSE_INDICATOR
+#endif 
 
       typedef const_point_iterator_ const_point_iterator;
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
       typedef iterator_ iterator;
-#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
+#endif 
 
 #ifdef PB_DS_DATA_FALSE_INDICATOR
       typedef const_iterator_ iterator;
-#endif // #ifdef PB_DS_DATA_FALSE_INDICATOR
+#endif 
 
       typedef const_iterator_ const_iterator;
 
-    public:
-
       PB_DS_CLASS_NAME();
 
-      PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other);
+      PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC&);
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn);
+      PB_DS_CLASS_NAME(const Hash_Fn&);
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn);
+      PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&);
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_probe_fn);
+      PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&);
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn);
+      PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, 
+		       const Probe_Fn&);
 
-      PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn, const Comb_Probe_Fn& r_comb_probe_fn, const Probe_Fn& r_probe_fn, const Resize_Policy& r_resize_policy);
+      PB_DS_CLASS_NAME(const Hash_Fn&, const Eq_Fn&, const Comb_Probe_Fn&, 
+		       const Probe_Fn&, const Resize_Policy&);
 
       template<typename It>
       void
@@ -348,20 +293,18 @@ namespace pb_ds
       insert(const_reference r_val)
       {
 	_GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
-
-	  return (insert_imp(r_val, traits_base::m_store_extra_indicator));
+        return insert_imp(r_val, traits_base::m_store_extra_indicator);
       }
 
       inline mapped_reference
       operator[](const_key_reference r_key)
       {
 #ifdef PB_DS_DATA_TRUE_INDICATOR
-	return (subscript_imp(r_key, traits_base::m_store_extra_indicator));
-#else // #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_mapped);
-#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
+        return traits_base::s_null_mapped;
+#endif
       }
 
       inline point_iterator
@@ -409,58 +352,12 @@ namespace pb_ds
 #endif 
 
     private:
-      typedef PB_DS_TYPES_TRAITS_C_DEC traits_base;
-
-      enum ENTRY_STATUS
-	{
-	  empty_entry_status,
-	  valid_entry_status,
-	  erased_entry_status
-	};
-
-      typedef char entry_status;
-
-      struct entry : public PB_DS_TYPES_TRAITS_C_DEC::stored_value_type
-      {
-	entry_status m_stat;
-      };
-
-      typedef
-      typename Allocator::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_MAP_DEBUG_BASE_C_DEC map_debug_base;
-#endif 
-
-      typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base;
-
-      typedef Resize_Policy resize_base;
-
 #ifdef PB_DS_DATA_TRUE_INDICATOR
       friend class iterator_;
-#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
+#endif 
 
       friend class const_iterator_;
 
-      typedef typename PB_DS_TYPES_TRAITS_C_DEC::comp_hash comp_hash;
-
-    private:
-
       void
       deallocate_all();
 
@@ -468,7 +365,7 @@ namespace pb_ds
       initialize();
 
       void
-      erase_all_valid_entries(entry_array a_entries_resized, size_type size);
+      erase_all_valid_entries(entry_array, size_type);
 
       inline bool
       do_resize_if_needed();
@@ -477,175 +374,145 @@ namespace pb_ds
       do_resize_if_needed_no_throw();
 
       void
-      resize_imp(size_type new_size);
+      resize_imp(size_type);
 
       virtual void
-      do_resize(size_type new_size);
+      do_resize(size_type);
 
       void
-      resize_imp(entry_array a_entries_resized, size_type old_size);
+      resize_imp(entry_array, size_type);
 
       inline void
-      resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, store_hash_false_type);
+      resize_imp_reassign(entry_pointer, entry_array, store_hash_false_type);
 
       inline void
-      resize_imp_reassign(entry_pointer p_e, entry_array a_entries_resized, store_hash_true_type);
+      resize_imp_reassign(entry_pointer, entry_array, store_hash_true_type);
 
       inline size_type
-      find_ins_pos(const_key_reference r_key, store_hash_false_type);
+      find_ins_pos(const_key_reference, store_hash_false_type);
 
       inline comp_hash
-      find_ins_pos(const_key_reference r_key, store_hash_true_type);
+      find_ins_pos(const_key_reference, store_hash_true_type);
 
       inline std::pair<point_iterator, bool>
-      insert_imp(const_reference r_val, store_hash_false_type);
+      insert_imp(const_reference, store_hash_false_type);
 
       inline std::pair<point_iterator, bool>
-      insert_imp(const_reference r_val, store_hash_true_type);
+      insert_imp(const_reference, store_hash_true_type);
 
       inline pointer
       insert_new_imp(const_reference r_val, size_type pos)
       {
-	_GLIBCXX_DEBUG_ASSERT(m_a_entries[pos].m_stat != valid_entry_status);
+	_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_a_entries[pos].m_stat != valid_entry_status);
-
-	entry* const p_e = m_a_entries + pos;
+	_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(map_debug_base::
-		       insert_new(PB_DS_V2F(p_e->m_value));)
+	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
 
-	  _GLIBCXX_DEBUG_ONLY(assert_valid();)
-
-	  return (&p_e->m_value);
+	_GLIBCXX_DEBUG_ONLY(assert_valid();)
+	return &p_e->m_value;
       }
 
       inline pointer
       insert_new_imp(const_reference r_val, comp_hash& r_pos_hash_pair)
       {
-	_GLIBCXX_DEBUG_ASSERT(m_a_entries[r_pos_hash_pair.first].m_stat !=
+	_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),
+	  r_pos_hash_pair = find_ins_pos(PB_DS_V2F(r_val),
 					 traits_base::m_store_extra_indicator);
 
-	_GLIBCXX_DEBUG_ASSERT(m_a_entries[r_pos_hash_pair.first].m_stat !=
-			 valid_entry_status);
-
-	entry* const p_e = m_a_entries + r_pos_hash_pair.first;
+	_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(map_debug_base::insert_new(
-						  PB_DS_V2F(p_e->m_value));)
-
-	  _GLIBCXX_DEBUG_ONLY(assert_valid();)
+	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
 
-	  return (&p_e->m_value);
+	_GLIBCXX_DEBUG_ONLY(assert_valid();)
+	return &p_e->m_value;
       }
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
       inline mapped_reference
-      subscript_imp(const_key_reference r_key, store_hash_false_type)
+      subscript_imp(const_key_reference key, store_hash_false_type)
       {
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 
-	  const size_type pos =
-	  find_ins_pos(r_key, traits_base::m_store_extra_indicator);
+	const size_type pos = find_ins_pos(key, 
+					 traits_base::m_store_extra_indicator);
 
-	entry_pointer p_e =& m_a_entries[pos];
+	entry_pointer p_e =& m_entries[pos];
 
 	if (p_e->m_stat != valid_entry_status)
-	  return (insert_new_imp(
-				 value_type(
-					    r_key,
-					    mapped_type()),
-				 pos)->second);
-
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+	  return insert_new_imp(value_type(key, mapped_type()), pos)->second;
 
-	  return (p_e->m_value.second);
+	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);)	  
+	return p_e->m_value.second;
       }
 
       inline mapped_reference
-      subscript_imp(const_key_reference r_key, store_hash_true_type)
+      subscript_imp(const_key_reference key, store_hash_true_type)
       {
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 
-	  comp_hash pos_hash_pair =
-	  find_ins_pos(r_key, traits_base::m_store_extra_indicator);
+	comp_hash pos_hash_pair =
+	  find_ins_pos(key, traits_base::m_store_extra_indicator);
 
-	if (m_a_entries[pos_hash_pair.first].m_stat != valid_entry_status)
-	  return (insert_new_imp(
-				 value_type(
-					    r_key,
-					    mapped_type()),
-				 pos_hash_pair)->second);
+	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;
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
-
-	return ((m_a_entries + pos_hash_pair.first)->m_value.second);
+	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key));
+	return (m_entries + pos_hash_pair.first)->m_value.second;
       }
-#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
+#endif
 
       inline pointer
-      find_key_pointer(const_key_reference r_key, store_hash_false_type)
+      find_key_pointer(const_key_reference key, store_hash_false_type)
       {
-	const size_type hash = ranged_probe_fn_base::operator()(r_key);
-
+	const size_type hash = ranged_probe_fn_base::operator()(key);
 	size_type i;
-
 	resize_base::notify_find_search_start();
 
 	// Loop until entry is found or until all possible entries accessed.
-
 	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_a_entries + pos;
+	    const size_type pos = ranged_probe_fn_base::operator()(key, hash, i);
 
-	    switch(p_e->m_stat)
+	    entry* const p_e = m_entries + pos;
+	    switch (p_e->m_stat)
 	      {
 	      case empty_entry_status:
 		{
 		  resize_base::notify_find_search_end();
+		  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
 
-		  _GLIBCXX_DEBUG_ONLY(map_debug_base::
-				 check_key_does_not_exist(r_key);)
-
-		    return (NULL);
+		    return NULL;
 		}
 		break;
 	      case valid_entry_status:
-		if (hash_eq_fn_base::operator()(
-						PB_DS_V2F(p_e->m_value),
-						r_key))
+		if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), key))
 		  {
 		    resize_base::notify_find_search_end();
+		    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);)
 
-		    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
-
-		      return ((pointer)&p_e->m_value);
+		    return pointer(&p_e->m_value);
 		  }
 		break;
 	      case erased_entry_status:
@@ -657,55 +524,44 @@ namespace pb_ds
 	    resize_base::notify_find_search_collision();
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::
-		       check_key_does_not_exist(r_key);)
-
-	  resize_base::notify_find_search_end();
-
-	return (NULL);
+	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
+	resize_base::notify_find_search_end();
+	return NULL;
       }
 
       inline pointer
-      find_key_pointer(const_key_reference r_key, store_hash_true_type)
+      find_key_pointer(const_key_reference key, store_hash_true_type)
       {
-	comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key);
-
+	comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(key);
 	size_type i;
-
 	resize_base::notify_find_search_start();
 
 	// Loop until entry is found or until all possible entries accessed.
-
 	for (i = 0; i < m_num_e; ++i)
 	  {
 	    const size_type pos =
-	      ranged_probe_fn_base::operator()(                    r_key, pos_hash_pair.second, i);
+	      ranged_probe_fn_base::operator()(key, pos_hash_pair.second, i);
 
-	    entry* const p_e = m_a_entries + pos;
+	    entry* const p_e = m_entries + pos;
 
 	    switch(p_e->m_stat)
 	      {
 	      case empty_entry_status:
 		{
 		  resize_base::notify_find_search_end();
+		  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
 
-		  _GLIBCXX_DEBUG_ONLY(map_debug_base::
-				 check_key_does_not_exist(r_key);)
-
-		    return (NULL);
+		  return NULL;
 		}
 		break;
 	      case valid_entry_status:
-		if (hash_eq_fn_base::operator()(
-						PB_DS_V2F(p_e->m_value),
+		if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value),
 						p_e->m_hash,
-						r_key, pos_hash_pair.second))
+						key, pos_hash_pair.second))
 		  {
 		    resize_base::notify_find_search_end();
-
-		    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
-
-		      return ((pointer)&p_e->m_value);
+		    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);)
+		    return pointer(&p_e->m_value);
 		  }
 		break;
 	      case erased_entry_status:
@@ -717,19 +573,16 @@ namespace pb_ds
 	    resize_base::notify_find_search_collision();
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::
-		       check_key_does_not_exist(r_key);)
-
-	  resize_base::notify_find_search_end();
-
-	return (NULL);
+	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
+	resize_base::notify_find_search_end();
+	return NULL;
       }
 
       inline bool
-      erase_imp(const_key_reference r_key,  true_type);
+      erase_imp(const_key_reference, true_type);
 
       inline bool
-      erase_imp(const_key_reference r_key,  false_type);
+      erase_imp(const_key_reference, false_type);
 
       inline void
       erase_entry(entry_pointer p_e);
@@ -737,28 +590,22 @@ namespace pb_ds
 #ifdef PB_DS_DATA_TRUE_INDICATOR
       void
       inc_it_state(pointer& r_p_value, size_type& r_pos) const
-      {
-	inc_it_state((const_mapped_pointer& )r_p_value, r_pos);
-      }
-#endif // #ifdef PB_DS_DATA_TRUE_INDICATOR
+      { inc_it_state((const_mapped_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 != NULL);
-
 	for (++r_pos; r_pos < m_num_e; ++r_pos)
 	  {
-	    const_entry_pointer p_e =& m_a_entries[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 = NULL;
       }
 
@@ -767,16 +614,13 @@ namespace pb_ds
       {
 	for (r_pos = 0; r_pos < m_num_e; ++r_pos)
 	  {
-	    const_entry_pointer p_e =& m_a_entries[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;
-
+		r_p_value = &p_e->m_value;
 		return;
 	      }
 	  }
-
 	r_p_value = NULL;
       }
 
@@ -785,49 +629,36 @@ namespace pb_ds
       {
 	for (r_pos = 0; r_pos < m_num_e; ++r_pos)
 	  {
-	    entry_pointer p_e =& m_a_entries[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;
-
+		r_p_value = &p_e->m_value;
 		return;
 	      }
 	  }
-
 	r_p_value = NULL;
       }
 
 #ifdef _GLIBCXX_DEBUG
       void
-      assert_entry_array_valid(const entry_array a_entries, 
-			       store_hash_false_type) const;
+      assert_entry_array_valid(const entry_array, store_hash_false_type) const;
 
       void
-      assert_entry_array_valid(const entry_array a_entries, 
-			       store_hash_true_type) const;
+      assert_entry_array_valid(const entry_array, store_hash_true_type) const;
 #endif 
 
-    private:
-      static entry_allocator s_entry_allocator;
-
-      entry_pointer m_a_entries;
-
-      size_type m_num_e;
-
-      size_type m_num_used_e;
+      static entry_allocator 	s_entry_allocator;
+      static iterator 		s_end_it;
+      static const_iterator 	s_const_end_it;
 
-      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,
-	  pb_ds::null_hash_fn>::value
+	  store_hash_ok = !Store_Hash 
+	                  || !is_same<Hash_Fn, pb_ds::null_hash_fn>::value
 	};
 
       PB_DS_STATIC_ASSERT(sth, store_hash_ok);
@@ -845,22 +676,14 @@ namespace pb_ds
 #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_TYPES_TRAITS_C_DEC
-
 #undef PB_DS_MAP_DEBUG_BASE_C_DEC
-
 #undef PB_DS_CLASS_NAME
-
 #undef PB_DS_V2F
 #undef PB_DS_V2S
-
 #undef PB_DS_STATIC_ASSERT
 
   } // namespace detail
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
index ef5ea837ff7..dcb712e303d 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
@@ -68,7 +68,7 @@ find_ins_pos(const_key_reference r_key, store_hash_false_type)
 
       _GLIBCXX_DEBUG_ASSERT(pos < m_num_e);
 
-      entry* const p_e = m_a_entries + pos;
+      entry* const p_e = m_entries + pos;
 
       switch(p_e->m_stat)
         {
@@ -122,12 +122,12 @@ insert_imp(const_reference r_val, store_hash_false_type)
   const size_type pos =
     find_ins_pos(r_key, traits_base::m_store_extra_indicator);
 
-  if (m_a_entries[pos].m_stat == valid_entry_status)
+  if (m_entries[pos].m_stat == valid_entry_status)
     {
       _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
 
         return (std::make_pair(
-			       & (m_a_entries + pos)->m_value,
+			       & (m_entries + pos)->m_value,
 			       false));
     }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
index 4f2ae016ed8..4ef9b202d79 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
@@ -51,8 +51,7 @@ PB_DS_CLASS_C_DEC::
 find_ins_pos(const_key_reference r_key, store_hash_true_type)
 {
   _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
-
-    comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key);
+  comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key);
 
   size_type i;
 
@@ -60,26 +59,21 @@ find_ins_pos(const_key_reference r_key, store_hash_true_type)
    *     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_a_entries + pos;
+      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();
 
-            _GLIBCXX_DEBUG_ONLY(
-			   map_debug_base::check_key_does_not_exist(r_key);)
+            _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
 
-	      return ((ins_pos == m_num_e)?
+	      return ((ins_pos == m_num_e) ?
 		      std::make_pair(pos, pos_hash_pair.second) :
 		      std::make_pair(ins_pos, pos_hash_pair.second));
 	  }
@@ -89,32 +83,23 @@ find_ins_pos(const_key_reference r_key, store_hash_true_type)
 	    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))
+	  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();
-
 	      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
-
-                return (std::make_pair(pos, pos_hash_pair.second));
+              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));
+  return std::make_pair(ins_pos, pos_hash_pair.second);
 }
 
 PB_DS_CLASS_T_DEC
@@ -123,25 +108,18 @@ PB_DS_CLASS_C_DEC::
 insert_imp(const_reference r_val, store_hash_true_type)
 {
   const_key_reference r_key = PB_DS_V2F(r_val);
-
-  comp_hash pos_hash_pair =
-    find_ins_pos(r_key, traits_base::m_store_extra_indicator);
+  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_a_entries[pos_hash_pair.first];
-
+  entry_pointer p_e =& m_entries[pos_hash_pair.first];
   if (p_e->m_stat == valid_entry_status)
     {
       _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
-
-      return (std::make_pair(&p_e->m_value, false));
+      return std::make_pair(&p_e->m_value, false);
     }
 
   _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
-
-  return (std::make_pair(
-			 insert_new_imp(r_val, pos_hash_pair),
-			 true));
+  return std::make_pair(insert_new_imp(r_val, pos_hash_pair), true);
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp
index fb31e2b0d1f..d7998048cfe 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp
@@ -50,21 +50,16 @@ 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);
+    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 size)
-{
-  resize_imp(resize_base::get_nearest_larger_size(
-						  size));
-}
+do_resize(size_type n)
+{ resize_imp(resize_base::get_nearest_larger_size(n)); }
 
 PB_DS_CLASS_T_DEC
 inline void
@@ -76,13 +71,13 @@ do_resize_if_needed_no_throw()
 
   try
     {
-      resize_imp(resize_base::get_new_size(            m_num_e, m_num_used_e));
+      resize_imp(resize_base::get_new_size(m_num_e, m_num_used_e));
     }
-  catch(...)
+  catch (...)
     { }
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
-    }
+}
 
 PB_DS_CLASS_T_DEC
 void
@@ -91,23 +86,19 @@ resize_imp(size_type new_size)
 {
 #ifdef PB_DS_REGRESSION
   typename Allocator::group_throw_prob_adjustor adjust(m_num_e);
-#endif // #ifdef PB_DS_REGRESSION
+#endif 
 
   if (new_size == m_num_e)
     return;
 
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
-
-    const size_type old_size = m_num_e;
-
+  const size_type old_size = m_num_e;
   entry_array a_entries_resized = NULL;
 
   // 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)
@@ -117,33 +108,24 @@ resize_imp(size_type new_size)
     {
       resize_imp(a_entries_resized, old_size);
     }
-  catch(...)
+  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;
     }
 
   // At this point no exceptions can be thrown.
-
   _GLIBCXX_DEBUG_ONLY(assert_entry_array_valid(a_entries_resized, traits_base::m_store_extra_indicator);)
 
-    Resize_Policy::notify_resized(new_size);
-
-  erase_all_valid_entries(m_a_entries, old_size);
-
-  s_entry_allocator.deallocate(m_a_entries, old_size);
-
-  m_a_entries = a_entries_resized;
-
+  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;
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
-    }
+}
 
 PB_DS_CLASS_T_DEC
 void
@@ -151,8 +133,9 @@ 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_a_entries[pos].m_stat == valid_entry_status)
-      resize_imp_reassign(m_a_entries + pos,  a_entries_resized,  traits_base::m_store_extra_indicator);
+    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>
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp
index f41e38040e1..78240c4219c 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp
@@ -58,7 +58,7 @@ trace() const
     {
       std::cerr << static_cast<unsigned long>(i) << " ";
 
-      switch(m_a_entries[i].m_stat)
+      switch(m_entries[i].m_stat)
         {
 	case empty_entry_status:
 	  std::cerr << "<empty>";
@@ -67,7 +67,7 @@ trace() const
 	  std::cerr << "<erased>";
 	  break;
 	case valid_entry_status:
-	  std::cerr << PB_DS_V2F(m_a_entries[i].m_value);
+	  std::cerr << PB_DS_V2F(m_entries[i].m_value);
 	  break;
 	default:
 	  _GLIBCXX_DEBUG_ASSERT(0);
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp
index c12901c8641..5295134a5c9 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp
@@ -48,23 +48,17 @@ PB_DS_CLASS_T_DEC
 void
 PB_DS_CLASS_C_DEC::
 swap(PB_DS_CLASS_C_DEC& other)
-{
-  mask_based_base::swap(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);
-}
+{ 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));
-}
+{ return mask_based_base::range_hash(hash); }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp
index e6f2fe9bec1..5edff69aa95 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp
@@ -48,23 +48,17 @@ PB_DS_CLASS_T_DEC
 void
 PB_DS_CLASS_C_DEC::
 swap(PB_DS_CLASS_C_DEC& other)
-{
-  mod_based_base::swap(other);
-}
+{ mod_based_base::swap(other); }
 
 PB_DS_CLASS_T_DEC
 void
 PB_DS_CLASS_C_DEC::
-notify_resized(size_type size)
-{
-  mod_based_base::notify_resized(size);
-}
+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));
-}
+{ return mod_based_base::range_hash(hash); }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp
index 68d0c2b973b..4aa1894bade 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp
@@ -49,16 +49,10 @@
 
 namespace pb_ds
 {
-
   namespace detail
   {
-
-#define PB_DS_CLASS_T_DEC			\
-    template<typename Size_Type>
-
-#define PB_DS_CLASS_C_DEC					\
-    mask_based_range_hashing<					\
-						Size_Type>
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC mask_based_range_hashing<Size_Type>
 
     template<typename Size_Type>
     class mask_based_range_hashing
@@ -66,22 +60,21 @@ namespace pb_ds
     protected:
       typedef Size_Type size_type;
 
-    protected:
       void
-      swap(PB_DS_CLASS_C_DEC& other);
+      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;
+      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;
+      size_type 		m_mask;
+      const static size_type 	s_num_bits_in_size_type;
+      const static size_type 	s_highest_bit_1;
     };
 
     PB_DS_CLASS_T_DEC
@@ -90,52 +83,31 @@ namespace pb_ds
       sizeof(typename PB_DS_CLASS_C_DEC::size_type) << 3;
 
     PB_DS_CLASS_T_DEC
-    const typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC::s_highest_bit_1 =
-						       static_cast<typename PB_DS_CLASS_C_DEC::size_type>(1) << (s_num_bits_in_size_type - 1);
-
-    PB_DS_CLASS_T_DEC
-    void
-    PB_DS_CLASS_C_DEC::
-    swap(PB_DS_CLASS_C_DEC& other)
-    {
-      std::swap(m_mask, other.m_mask);
-    }
+    const typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC::s_highest_bit_1 = static_cast<typename PB_DS_CLASS_C_DEC::size_type>(1) << (s_num_bits_in_size_type - 1);
 
+ 
     PB_DS_CLASS_T_DEC
     void
     PB_DS_CLASS_C_DEC::
     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;
     }
 
-    PB_DS_CLASS_T_DEC
-    inline typename PB_DS_CLASS_C_DEC::size_type
-    PB_DS_CLASS_C_DEC::
-    range_hash(size_type hash) const
-    {
-      return (hash&  m_mask);
-    }
-
 #undef PB_DS_CLASS_T_DEC
 #undef PB_DS_CLASS_C_DEC
 
   } // namespace detail
-
 } // namespace pb_ds
 
-#endif // #ifndef PB_DS_MASK_BASED_RANGE_HASHING_HPP
+#endif
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp
index 6fddfeb9d28..d4b834dd34f 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp
@@ -57,48 +57,29 @@ namespace pb_ds
   namespace detail
   {
     template<typename Key,
-	     class Hash_Fn,
-	     class Allocator,
-	     class Comb_Probe_Fn,
-	     class Probe_Fn,
+	     typename Hash_Fn,
+	     typename Allocator,
+	     typename Comb_Probe_Fn,
+	     typename Probe_Fn,
 	     bool Store_Hash>
     class ranged_probe_fn;
 
-#define PB_DS_CLASS_T_DEC						\
-    template<								\
-						typename Key,		\
-						class Hash_Fn,		\
-						class Allocator,	\
-						class Comb_Probe_Fn,	\
-						class Probe_Fn>
-
-#define PB_DS_CLASS_C_DEC					\
-    ranged_probe_fn<						\
-						Key,		\
-						Hash_Fn,	\
-						Allocator,	\
-						Comb_Probe_Fn,	\
-						Probe_Fn,	\
-						false>
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Hash_Fn, typename Allocator, \
+	     typename Comb_Probe_Fn, typename Probe_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_probe_fn<Key, Hash_Fn, Allocator, 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,
-	     class Hash_Fn,
-	     class Allocator,
-	     class Comb_Probe_Fn,
-	     class Probe_Fn>
-    class ranged_probe_fn<
-      Key,
-      Hash_Fn,
-      Allocator,
-      Comb_Probe_Fn,
-      Probe_Fn,
-      false> : public Hash_Fn,
-	       public Comb_Probe_Fn,
-	       public Probe_Fn
+    template<typename Key, typename Hash_Fn, typename Allocator,
+	     typename Comb_Probe_Fn, typename Probe_Fn>
+    class ranged_probe_fn<Key, Hash_Fn, Allocator, Comb_Probe_Fn,
+			  Probe_Fn, false> 
+    : public Hash_Fn, public Comb_Probe_Fn, public Probe_Fn
     {
     protected:
       typedef typename Allocator::size_type size_type;
@@ -138,26 +119,20 @@ namespace pb_ds
     PB_DS_CLASS_T_DEC
     PB_DS_CLASS_C_DEC::
     ranged_probe_fn(size_type size)
-    {
-      Comb_Probe_Fn::notify_resized(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);
-    }
+    { 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);
-    }
+    { comb_probe_fn_base::notify_resized(size); }
 
     PB_DS_CLASS_T_DEC
     PB_DS_CLASS_C_DEC::
@@ -165,9 +140,7 @@ namespace pb_ds
       Hash_Fn(r_hash_fn),
       Comb_Probe_Fn(r_comb_probe_fn),
       Probe_Fn(r_probe_fn)
-    {
-      comb_probe_fn_base::notify_resized(size);
-    }
+    { comb_probe_fn_base::notify_resized(size); }
 
     PB_DS_CLASS_T_DEC
     void
@@ -175,75 +148,48 @@ namespace pb_ds
     swap(PB_DS_CLASS_C_DEC& other)
     {
       comb_probe_fn_base::swap(other);
-
-      std::swap((Hash_Fn& )(*this), (Hash_Fn& )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);
-    }
+    { 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()(const_key_reference r_key) const
-    {
-      return (comb_probe_fn_base::operator()(
-					     hash_fn_base::operator()(r_key)));
-    }
+    { 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()(const_key_reference /*r_key*/, size_type hash, size_type i) const
+    operator()(const_key_reference, size_type hash, size_type i) const
     {
-      return (comb_probe_fn_base::operator()(
-					     hash + probe_fn_base::operator()(i)));
+      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,		\
-						class Hash_Fn,		\
-						class Allocator,	\
-						class Comb_Probe_Fn,	\
-						class Probe_Fn>
-
-#define PB_DS_CLASS_C_DEC					\
-    ranged_probe_fn<						\
-						Key,		\
-						Hash_Fn,	\
-						Allocator,	\
-						Comb_Probe_Fn,	\
-						Probe_Fn,	\
-						true>
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, class Hash_Fn, class Allocator,	\
+	     class Comb_Probe_Fn, class Probe_Fn>
+
+#define PB_DS_CLASS_C_DEC \
+    ranged_probe_fn<Key, Hash_Fn, Allocator, 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,
-	     class Hash_Fn,
-	     class Allocator,
-	     class Comb_Probe_Fn,
-	     class Probe_Fn>
-    class ranged_probe_fn<
-      Key,
-      Hash_Fn,
-      Allocator,
-      Comb_Probe_Fn,
-      Probe_Fn,
-      true> :
-      public Hash_Fn,
-      public Comb_Probe_Fn,
-      public Probe_Fn
+    template<typename Key, typename Hash_Fn, typename Allocator,
+	     typename Comb_Probe_Fn, typename Probe_Fn>
+    class ranged_probe_fn<Key, Hash_Fn, Allocator, Comb_Probe_Fn, 
+			  Probe_Fn, true> 
+    : public Hash_Fn, public Comb_Probe_Fn, public Probe_Fn
     {
     protected:
       typedef typename Allocator::size_type size_type;
@@ -260,14 +206,16 @@ namespace pb_ds
 
       typedef typename key_allocator::const_reference const_key_reference;
 
-    protected:
       ranged_probe_fn(size_type size);
 
       ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn);
 
-      ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn);
+      ranged_probe_fn(size_type size, const Hash_Fn& r_hash_fn, 
+		      const Comb_Probe_Fn& r_comb_probe_fn);
 
-      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);
+      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);
 
       void
       swap(PB_DS_CLASS_C_DEC& other);
@@ -298,14 +246,17 @@ namespace pb_ds
 
     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) :
+    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) :
+    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)
@@ -338,7 +289,7 @@ namespace pb_ds
     PB_DS_CLASS_T_DEC
     inline typename PB_DS_CLASS_C_DEC::size_type
     PB_DS_CLASS_C_DEC::
-    operator()(const_key_reference /*r_key*/, size_type hash, size_type i) const
+    operator()(const_key_reference, size_type hash, size_type i) const
     {
       return comb_probe_fn_base::operator()(hash + probe_fn_base::operator()(i));
     }
@@ -360,33 +311,14 @@ namespace pb_ds
 #undef PB_DS_CLASS_T_DEC
 #undef PB_DS_CLASS_C_DEC
 
-#define PB_DS_CLASS_T_DEC						\
-    template<typename Key, class Allocator, class Comb_Probe_Fn>
-
-#define PB_DS_CLASS_C_DEC					\
-    ranged_probe_fn<						\
-						Key,		\
-						null_hash_fn,	\
-						Allocator,	\
-						Comb_Probe_Fn,	\
-						null_probe_fn,	\
-						false>
-
     /**
      * 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, class Allocator, class Comb_Probe_Fn>
-    class ranged_probe_fn<
-      Key,
-      null_hash_fn,
-      Allocator,
-      Comb_Probe_Fn,
-      null_probe_fn,
-      false> :
-      public Comb_Probe_Fn,
-      public null_hash_fn,
-      public null_probe_fn
+    template<typename Key, typename Allocator, typename Comb_Probe_Fn>
+    class ranged_probe_fn<Key, null_hash_fn, Allocator, Comb_Probe_Fn, 
+			  null_probe_fn, false> 
+    : public Comb_Probe_Fn, public null_hash_fn, public null_probe_fn
     {
     protected:
       typedef typename Allocator::size_type size_type;
@@ -397,42 +329,23 @@ namespace pb_ds
 
       typedef typename key_allocator::const_reference const_key_reference;
 
-    protected:
-      ranged_probe_fn(size_type size);
+      ranged_probe_fn(size_type size)
+      { Comb_Probe_Fn::notify_resized(size); }
 
-      ranged_probe_fn(size_type size, const Comb_Probe_Fn& r_comb_probe_fn);
+      ranged_probe_fn(size_type size, const Comb_Probe_Fn& r_comb_probe_fn)
+      : Comb_Probe_Fn(r_comb_probe_fn)
+      { }
 
-      ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const null_probe_fn& r_null_probe_fn);
+      ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, 
+		      const Comb_Probe_Fn& r_comb_probe_fn, 
+		      const null_probe_fn& r_null_probe_fn)
+      : Comb_Probe_Fn(r_comb_probe_fn)
+      { }
 
       void
-      swap(PB_DS_CLASS_C_DEC& other);
+      swap(ranged_probe_fn& other)
+      { comb_probe_fn_base::swap(other); }
     };
-
-    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 Comb_Probe_Fn& r_comb_probe_fn) :
-      Comb_Probe_Fn(r_comb_probe_fn)
-    { }
-
-    PB_DS_CLASS_T_DEC
-    PB_DS_CLASS_C_DEC::
-    ranged_probe_fn(size_type size, const null_hash_fn& r_null_hash_fn, const Comb_Probe_Fn& r_comb_probe_fn, const null_probe_fn& r_null_probe_fn) :
-      Comb_Probe_Fn(r_comb_probe_fn)
-    { }
-
-    PB_DS_CLASS_T_DEC
-    void
-    PB_DS_CLASS_C_DEC::
-    swap(PB_DS_CLASS_C_DEC& other)
-    { comb_probe_fn_base::swap(other); }
-
-#undef PB_DS_CLASS_T_DEC
-#undef PB_DS_CLASS_C_DEC
   } // namespace detail
 } // namespace pb_ds
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
index 242169cd7ba..b3854318bf0 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
@@ -353,7 +353,7 @@ namespace pb_ds
 	if (pot_it != end()&&  !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it)))
 	  {
 	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
-	    return (++pot_it);
+	    return ++pot_it;
 	  }
 
 	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
@@ -362,17 +362,17 @@ namespace pb_ds
 
       inline const_point_iterator
       upper_bound(const_key_reference r_key) const
-      { return const_cast<PB_DS_CLASS_C_DEC& >(*this).upper_bound(r_key); }
+      { return const_cast<PB_DS_CLASS_C_DEC&>(*this).upper_bound(r_key); }
 
       inline point_iterator
       find(const_key_reference r_key)
       {
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 	iterator pot_it = lower_bound(r_key);
-	if (pot_it != end()&&  !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it)))
+	if (pot_it != end() && !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it)))
 	  {
 	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
-	    return (pot_it);
+	    return pot_it;
 	  }
 
 	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp
index 8303c3fd3de..18f24bd7b29 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp
@@ -127,8 +127,8 @@ namespace detail
 PB_DS_CLASS_T_DEC
 inline
 PB_DS_CLASS_C_DEC::
-hash_prime_size_policy(size_type start_size) : m_start_size(start_size)
-{ m_start_size = get_nearest_larger_size(start_size); }
+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
@@ -139,10 +139,10 @@ swap(PB_DS_CLASS_C_DEC& other)
 PB_DS_CLASS_T_DEC
 inline PB_DS_CLASS_C_DEC::size_type
 PB_DS_CLASS_C_DEC::
-get_nearest_larger_size(size_type size) const
+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, size);
+		     detail::g_a_sizes + detail::num_distinct_sizes, n);
 
   if (p_upper == detail::g_a_sizes + detail::num_distinct_sizes)
     throw resize_error();
@@ -152,12 +152,12 @@ get_nearest_larger_size(size_type size) const
 PB_DS_CLASS_T_DEC
 inline PB_DS_CLASS_C_DEC::size_type
 PB_DS_CLASS_C_DEC::
-get_nearest_smaller_size(size_type size) const
+get_nearest_smaller_size(size_type n) const
 {
   const size_t* p_lower = std::lower_bound(detail::g_a_sizes, 
-		       detail::g_a_sizes + detail::num_distinct_sizes, size);
+		       detail::g_a_sizes + detail::num_distinct_sizes, n);
 
-  if (*p_lower >= size&&  p_lower != detail::g_a_sizes)
+  if (*p_lower >= n &&  p_lower != detail::g_a_sizes)
     --p_lower;
   if (*p_lower < m_start_size)
     return m_start_size;
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp
index bbea0b2a364..e6edf0254b8 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp
@@ -49,23 +49,21 @@
 
 PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
-hash_standard_resize_policy() :
-  m_size(Size_Policy::get_nearest_larger_size(1))
+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))
+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),
+			    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); }
 
@@ -167,8 +165,7 @@ 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))
+  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);
 }
@@ -197,24 +194,23 @@ PB_DS_CLASS_C_DEC::
 resize(size_type new_size)
 {
   PB_DS_STATIC_ASSERT(access, external_size_access);
-  size_type actual_new_size = size_policy_base::get_nearest_larger_size(1);
-  while (actual_new_size < new_size)
+  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_new_size);
+      const size_type pot = size_policy_base::get_nearest_larger_size(actual_size);
 
-      if (pot == actual_new_size&&  pot < new_size)
+      if (pot == actual_size && pot < new_size)
 	throw resize_error();
-      actual_new_size = pot;
+      actual_size = pot;
     }
 
-  if (actual_new_size > 0)
-    --actual_new_size;
+  if (actual_size > 0)
+    --actual_size;
 
   const size_type old_size = m_size;
   try
     {
-      do_resize(actual_new_size - 1);
+      do_resize(actual_size - 1);
     }
   catch(insert_error& )
     {
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp b/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
index 88f8757ce41..b51e252cd29 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
@@ -55,47 +55,34 @@ namespace pb_ds
 {
   namespace detail
   {
-
-    template<typename Key, typename Mapped, class Allocator, bool Store_Extra>
+    template<typename Key, typename Mapped, typename Alloc, bool Store_Extra>
     struct vt_base_selector
     {
-      typedef value_type_base< Key, Mapped, Allocator, Store_Extra> type;
+      typedef value_type_base<Key, Mapped, Alloc, Store_Extra> type;
     };
 
-    template<typename Key, typename Mapped, class Allocator, bool Store_Extra>
+    template<typename Key, typename Mapped, typename Alloc, bool Store_Extra>
     struct types_traits 
-    : public vt_base_selector<Key, Mapped, Allocator, Store_Extra>::type
+    : public vt_base_selector<Key, Mapped, Alloc, Store_Extra>::type
     {
 
-      typedef typename Allocator::template rebind< Key>::other key_allocator;
-
+      typedef typename Alloc::template rebind< Key>::other key_allocator;
       typedef typename key_allocator::value_type key_type;
-
       typedef typename key_allocator::pointer key_pointer;
-
       typedef typename key_allocator::const_pointer const_key_pointer;
-
       typedef typename key_allocator::reference key_reference;
-
       typedef typename key_allocator::const_reference const_key_reference;
-
-      typedef typename Allocator::size_type size_type;
-
+      typedef typename Alloc::size_type size_type;
       typedef false_type store_extra_false_type;
-
       typedef true_type store_extra_true_type;
-
-      integral_constant<int,Store_Extra> m_store_extra_indicator;
-
       typedef false_type no_throw_copies_false_type;
-
       typedef true_type no_throw_copies_true_type;
 
-      typename no_throw_copies<Key, Mapped>::indicator
-      m_no_throw_copies_indicator;
+      integral_constant<int, Store_Extra> m_store_extra_indicator;
+      typename no_throw_copies<Key, Mapped>::indicator m_no_throw_copies_indicator;
 
       // Extra value (used when the extra value is stored with each value).
-      typedef typename comp_hash_< size_type>::comp_hash comp_hash;
+      typedef typename comp_hash_<size_type>::comp_hash comp_hash;
     };
 
   } // namespace detail