Index: libcxx/include/map 
===================================================================
--- libcxx/include/map 
+++ libcxx/include/map 
@@ -1228,7 +1228,7 @@
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
-    count(const _K2& __k) const {return __tree_.__count_unique(__k);}
+    count(const _K2& __k) const {return __tree_.__count_multi(__k);}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
@@ -1275,11 +1275,11 @@
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
-    equal_range(const _K2& __k)       {return __tree_.__equal_range_unique(__k);}
+    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
-    equal_range(const _K2& __k) const {return __tree_.__equal_range_unique(__k);}
+    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
 #endif
 
 private:
Index: libcxx/include/set 
===================================================================
--- libcxx/include/set 
+++ libcxx/include/set 
@@ -668,7 +668,7 @@
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
-    count(const _K2& __k) const                    {return __tree_.__count_unique(__k);}
+    count(const _K2& __k) const                    {return __tree_.__count_multi(__k);}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
@@ -715,11 +715,11 @@
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
-    equal_range(const _K2& __k)       {return __tree_.__equal_range_unique(__k);}
+    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
-    equal_range(const _K2& __k) const {return __tree_.__equal_range_unique(__k);}
+    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
 #endif
 };
 
Index: libcxx/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <map>
+
+// class map
+
+// template<typename K>
+//   size_type count(const K& x) const;        // C++14
+
+#include <cassert>
+#include <map>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::map<std::pair<int, int>, int, Comp> s{
+      {{2, 1}, 1}, {{1, 2}, 2}, {{1, 3}, 3}, {{1, 4}, 4}, {{2, 2}, 5}};
+
+  auto cnt = s.count(1);
+  assert(cnt == 3);
+}
Index: libcxx/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <map>
+
+// class map
+
+// template<typename K>
+//         pair<iterator,iterator>             equal_range(const K& x); // C++14
+// template<typename K>
+//         pair<const_iterator,const_iterator> equal_range(const K& x) const;
+//         // C++14
+
+#include <cassert>
+#include <map>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::map<std::pair<int, int>, int, Comp> s{
+      {{2, 1}, 1}, {{1, 2}, 2}, {{1, 3}, 3}, {{1, 4}, 4}, {{2, 2}, 5}};
+
+  auto er = s.equal_range(1);
+  long nels = 0;
+
+  for (auto it = er.first; it != er.second; it++) {
+    assert(it->first.first == 1);
+    nels++;
+  }
+
+  assert(nels == 3);
+}
Index: libcxx/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <map>
+
+// class multimap
+
+// template<typename K>
+//   size_type count(const K& x) const;        // C++14
+
+#include <cassert>
+#include <map>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::multimap<std::pair<int, int>, int, Comp> s{
+      {{2, 1}, 1}, {{1, 1}, 2}, {{1, 1}, 3}, {{1, 1}, 4}, {{2, 2}, 5}};
+
+  auto cnt = s.count(1);
+  assert(cnt == 3);
+}
Index: libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <map>
+
+// class multimap
+
+// template<typename K>
+//         pair<iterator,iterator>             equal_range(const K& x); // C++14
+// template<typename K>
+//         pair<const_iterator,const_iterator> equal_range(const K& x) const;
+//         // C++14
+
+#include <cassert>
+#include <map>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::multimap<std::pair<int, int>, int, Comp> s{
+      {{2, 1}, 1}, {{1, 1}, 2}, {{1, 1}, 3}, {{1, 1}, 4}, {{2, 2}, 5}};
+
+  auto er = s.equal_range(1);
+  long nels = 0;
+
+  for (auto it = er.first; it != er.second; it++) {
+    assert(it->first.first == 1);
+    nels++;
+  }
+
+  assert(nels == 3);
+}
Index: libcxx/test/std/containers/associative/multiset/count_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/multiset/count_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/multiset/count_transparent.pass.cpp
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <set>
+
+// class multiset
+
+// template<typename K>
+//     iterator lower_bound(const K& x);              // C++14
+// template<typename K>
+//     const_iterator lower_bound(const K& x) const;  // C++14
+
+#include <cassert>
+#include <set>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::multiset<std::pair<int, int>, Comp> s{{2, 1}, {1, 1}, {1, 1}, {1, 1}, {2, 2}};
+
+  auto cnt = s.count(1);
+  assert(cnt == 3);
+}
Index: libcxx/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <set>
+
+// class multiset
+
+// template<typename K>
+//     pair<iterator,iterator>             equal_range(const K& x);        //
+//     C++14
+// template<typename K>
+//     pair<const_iterator,const_iterator> equal_range(const K& x) const;  //
+//     C++14
+
+#include <cassert>
+#include <set>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::multiset<std::pair<int, int>, Comp> s{{2, 1}, {1, 1}, {1, 1}, {1, 1}, {2, 2}};
+
+  auto er = s.equal_range(1);
+  long nels = 0;
+
+  for (auto it = er.first; it != er.second; it++) {
+    assert(it->first == 1);
+    nels++;
+  }
+
+  assert(nels == 3);
+}
Index: libcxx/test/std/containers/associative/set/count_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/set/count_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/set/count_transparent.pass.cpp
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <set>
+
+// class set
+
+// template<typename K>
+//     iterator lower_bound(const K& x);              // C++14
+// template<typename K>
+//     const_iterator lower_bound(const K& x) const;  // C++14
+
+#include <cassert>
+#include <set>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::set<std::pair<int, int>, Comp> s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
+
+  auto cnt = s.count(1);
+  assert(cnt == 3);
+}
Index: libcxx/test/std/containers/associative/set/equal_range_transparent.pass.cpp
===================================================================
--- libcxx/test/std/containers/associative/set/equal_range_transparent.pass.cpp
+++ libcxx/test/std/containers/associative/set/equal_range_transparent.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <set>
+
+// class set
+
+// template<typename K>
+//     pair<iterator,iterator>             equal_range(const K& x);        //
+//     C++14
+// template<typename K>
+//     pair<const_iterator,const_iterator> equal_range(const K& x) const;  //
+//     C++14
+
+#include <cassert>
+#include <set>
+#include <utility>
+
+#include "min_allocator.h"
+#include "private_constructor.hpp"
+#include "test_macros.h"
+
+struct Comp {
+  using is_transparent = void;
+
+  bool operator()(const std::pair<int, int> &lhs,
+                  const std::pair<int, int> &rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const std::pair<int, int> &lhs, int rhs) const {
+    return lhs.first < rhs;
+  }
+
+  bool operator()(int lhs, const std::pair<int, int> &rhs) const {
+    return lhs < rhs.first;
+  }
+};
+
+int main() {
+  std::set<std::pair<int, int>, Comp> s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
+
+  auto er = s.equal_range(1);
+  long nels = 0;
+
+  for (auto it = er.first; it != er.second; it++) {
+    assert(it->first == 1);
+    nels++;
+  }
+
+  assert(nels == 3);
+}