Patch Detail

HTTP 200 OK
Allow: GET, PUT, PATCH, HEAD, OPTIONS
Content-Type: application/json
Vary: Accept

{
    "id": 2226298,
    "url": "http://patchwork.ozlabs.org/api/1.2/patches/2226298/?format=api",
    "web_url": "http://patchwork.ozlabs.org/project/gcc/patch/bmm.hhubpmz4v8.gcc.gcc-TEST.fdumont.30.1.1@forge-stage.sourceware.org/",
    "project": {
        "id": 17,
        "url": "http://patchwork.ozlabs.org/api/1.2/projects/17/?format=api",
        "name": "GNU Compiler Collection",
        "link_name": "gcc",
        "list_id": "gcc-patches.gcc.gnu.org",
        "list_email": "gcc-patches@gcc.gnu.org",
        "web_url": null,
        "scm_url": null,
        "webscm_url": null,
        "list_archive_url": "",
        "list_archive_url_format": "",
        "commit_url_format": ""
    },
    "msgid": "<bmm.hhubpmz4v8.gcc.gcc-TEST.fdumont.30.1.1@forge-stage.sourceware.org>",
    "list_archive_url": null,
    "date": "2026-04-22T10:42:29",
    "name": "[v1,1/1] libstdc++: Reimplement __gnu_cxx::__ops operators",
    "commit_ref": null,
    "pull_url": null,
    "state": "new",
    "archived": false,
    "hash": "7cc36ab78c92afab58785457a63e644342ed7baf",
    "submitter": {
        "id": 93220,
        "url": "http://patchwork.ozlabs.org/api/1.2/people/93220/?format=api",
        "name": "François Dumont via Sourceware Forge",
        "email": "forge-bot+fdumont@forge-stage.sourceware.org"
    },
    "delegate": null,
    "mbox": "http://patchwork.ozlabs.org/project/gcc/patch/bmm.hhubpmz4v8.gcc.gcc-TEST.fdumont.30.1.1@forge-stage.sourceware.org/mbox/",
    "series": [
        {
            "id": 500989,
            "url": "http://patchwork.ozlabs.org/api/1.2/series/500989/?format=api",
            "web_url": "http://patchwork.ozlabs.org/project/gcc/list/?series=500989",
            "date": "2026-04-22T10:42:28",
            "name": "libstdc++: Reimplement __gnu_cxx::__ops functors",
            "version": 1,
            "mbox": "http://patchwork.ozlabs.org/series/500989/mbox/"
        }
    ],
    "comments": "http://patchwork.ozlabs.org/api/patches/2226298/comments/",
    "check": "pending",
    "checks": "http://patchwork.ozlabs.org/api/patches/2226298/checks/",
    "tags": {},
    "related": [],
    "headers": {
        "Return-Path": "<gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org>",
        "X-Original-To": [
            "incoming@patchwork.ozlabs.org",
            "gcc-patches@gcc.gnu.org"
        ],
        "Delivered-To": [
            "patchwork-incoming@legolas.ozlabs.org",
            "gcc-patches@gcc.gnu.org"
        ],
        "Authentication-Results": [
            "legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=2620:52:6:3111::32; helo=vm01.sourceware.org;\n envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org;\n receiver=patchwork.ozlabs.org)",
            "sourceware.org; dmarc=none (p=none dis=none)\n header.from=forge-stage.sourceware.org",
            "sourceware.org;\n spf=pass smtp.mailfrom=forge-stage.sourceware.org",
            "server2.sourceware.org;\n arc=none smtp.remote-ip=38.145.34.39"
        ],
        "Received": [
            "from vm01.sourceware.org (vm01.sourceware.org\n [IPv6:2620:52:6:3111::32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4g0xb44K0Wz1y2d\n\tfor <incoming@patchwork.ozlabs.org>; Wed, 22 Apr 2026 21:20:00 +1000 (AEST)",
            "from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id BB295427C769\n\tfor <incoming@patchwork.ozlabs.org>; Wed, 22 Apr 2026 11:19:58 +0000 (GMT)",
            "from forge-stage.sourceware.org (vm08.sourceware.org [38.145.34.39])\n by sourceware.org (Postfix) with ESMTPS id 34DEB4BB3BE5\n for <gcc-patches@gcc.gnu.org>; Wed, 22 Apr 2026 10:43:19 +0000 (GMT)",
            "from forge-stage.sourceware.org (localhost [IPv6:::1])\n (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n key-exchange x25519 server-signature ECDSA (prime256v1) server-digest SHA256)\n (No client certificate requested)\n by forge-stage.sourceware.org (Postfix) with ESMTPS id 0DD1E42B84\n for <gcc-patches@gcc.gnu.org>; Wed, 22 Apr 2026 10:43:19 +0000 (UTC)"
        ],
        "DKIM-Filter": [
            "OpenDKIM Filter v2.11.0 sourceware.org BB295427C769",
            "OpenDKIM Filter v2.11.0 sourceware.org 34DEB4BB3BE5"
        ],
        "DMARC-Filter": "OpenDMARC Filter v1.4.2 sourceware.org 34DEB4BB3BE5",
        "ARC-Filter": "OpenARC Filter v1.0.0 sourceware.org 34DEB4BB3BE5",
        "ARC-Seal": "i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1776854599; cv=none;\n b=B/0ThN8YwBiwJbkMi6tsbOC5AiMHkiYejds+9keBahEZladXwjQnZ1TiwhVIaxx8YkM2LHNopSsTBz47wR7gZTE6o0n92ngE5jpLWJz5K5itmtF00L7AVxnxiBiEC3NMRmjDC605/tbMMquuC/nL77WJuB+HWYeK6QyF9OpNItM=",
        "ARC-Message-Signature": "i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1776854599; c=relaxed/simple;\n bh=CTikqUUTpKTEKsgMP+ugVC2c61yRCRrOYdy1/AWlwQ4=;\n h=From:Date:Subject:MIME-Version:To:Message-ID;\n b=CHbOKSTWR3KaoKJEcAvIMOjYKrWsMGlQ5vTwOIcexIo3jAwEzy2dpDZKqOyeb4nKAIDlb/Peu+KlGwKCfYS6iL99h4rD74zVPGMVaeEhzMGzGDTGS4g5N4sT6yKmch1ruBMPX3weOxwoo36Rb6q34oAj9fu+7FVK7v6+QDxurpI=",
        "ARC-Authentication-Results": "i=1; server2.sourceware.org",
        "From": "=?utf-8?b?PT91dGYtOD9xP0ZyYW49QzM9QTdvaXNfRHVtb250X3ZpYV9Tb3VyY2V3YXJl?=\n\t=?utf-8?b?X0ZvcmdlPz0=?= <forge-bot+fdumont@forge-stage.sourceware.org>",
        "Date": "Wed, 22 Apr 2026 10:42:29 +0000",
        "Subject": "[PATCH v1 1/1] libstdc++: Reimplement __gnu_cxx::__ops operators",
        "MIME-Version": "1.0",
        "Content-Type": "text/plain; charset=UTF-8",
        "Content-Transfer-Encoding": "8bit",
        "To": "gcc-patches mailing list <gcc-patches@gcc.gnu.org>",
        "Message-ID": "\n <bmm.hhubpmz4v8.gcc.gcc-TEST.fdumont.30.1.1@forge-stage.sourceware.org>",
        "X-Mailer": "batrachomyomachia",
        "X-Pull-Request-Organization": "gcc",
        "X-Pull-Request-Repository": "gcc-TEST",
        "X-Pull-Request": "https://forge.sourceware.org/gcc/gcc-TEST/pulls/30",
        "References": "\n <bmm.hhubpmz4v8.gcc.gcc-TEST.fdumont.30.1.0@forge-stage.sourceware.org>",
        "In-Reply-To": "\n <bmm.hhubpmz4v8.gcc.gcc-TEST.fdumont.30.1.0@forge-stage.sourceware.org>",
        "X-Patch-URL": "\n https://forge.sourceware.org/fdumont/gcc-TEST/commit/7f4c93adf8d0f3b08e642b14b01df7fb87d93e96",
        "X-BeenThere": "gcc-patches@gcc.gnu.org",
        "X-Mailman-Version": "2.1.30",
        "Precedence": "list",
        "List-Id": "Gcc-patches mailing list <gcc-patches.gcc.gnu.org>",
        "List-Unsubscribe": "<https://gcc.gnu.org/mailman/options/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=unsubscribe>",
        "List-Archive": "<https://gcc.gnu.org/pipermail/gcc-patches/>",
        "List-Post": "<mailto:gcc-patches@gcc.gnu.org>",
        "List-Help": "<mailto:gcc-patches-request@gcc.gnu.org?subject=help>",
        "List-Subscribe": "<https://gcc.gnu.org/mailman/listinfo/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=subscribe>",
        "Reply-To": "gcc-patches mailing list <gcc-patches@gcc.gnu.org>,\n fdumont@gcc.gnu.org",
        "Errors-To": "gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org"
    },
    "content": "From: François Dumont <fdumont@gcc.gnu.org>\n\nReplace functors using iterators as input to adopt functors that are\nmatching the same Standard expectations as the ones imposed on functor-aware\nalgos. It forces to have iterators dereferenced at algo level and not in the\npredefined functors anymore. This way the functor used by functor-aware algos\ndo not need to be wrap anymore. Only the different flavour of '<', '==' and\n'!' operators needed to be wrapped.\n\nAlso make sure that in algos implementation helpers, functors are passed using\nperfect forwarding rather than by copy. This way we can remove usage of std::refwrap\nin std::erase_if implementations and instead use std::move.\n\nAdditionnally improve __lower_bound/__upper_bound signatures. Those internal\nfunctions have been introduced as implementation details of respectively\nstd::lower_bound/std::upper_bound. For this reason they are taking\nthe value argument as a const reference. The problem is that it's now being used\nin algos like std::inplace_merge and std::stable_sort and so forces functor used\nin those algos to take their arguments as const references. Using a rvalue references\n__lower_bound/__upper_bound will automatically adapt to the usage context. The\nlimitation still exists in C++98.\n\nlibstdc++-v3/ChangeLog:\n\n\t* include/bits/move.h\n\t(_GLIBCXX_CP_FWDREF): New macro, substituted by a copy in pre-c++11 mode.\n\t* include/std/functional: Include predefined_ops.h.\n\t(_Not_fn): Move to...\n\t* include/bits/predefined_ops.h: ...here, and expose a version\n\tin pre-C++14 mode.\n\t(__not_fn): New, use latter.\n\tInclude bits/stl_iterator_base_types.h.\n\tInclude bits/invoke.h.\n\t(_Iter_less_iter, _Iter_less_val, _Val_less_iter, _Iter_equal_to_iter)\n\t(_Iter_equal_to_val, _Iter_comp_iter, _Iter_comp_val, _Val_comp_iter)\n\t(_Iter_equals_val, _Iter_equals_iter, _Iter_pred, _Iter_comp_val)\n\t(_Iter_comp_to_val, _Iter_comp_to_iter, _Iter_negate): Remove.\n\t(__iter_less_iter, __iter_less_val, __iter_comp_val, __val_less_iter)\n\t(__val_comp_iter, __iter_equal_to_iter, __iter_equal_to_val, __iter_comp_iter)\n\t(__val_comp_iter, __iter_equals_val, __iter_comp_iter, __pred_iter): Remove.\n\t(_Less, _LessRefs<>, _LessCRef<>, _LessVal<>)\n\t(_EqualTo, _EqualToRefs<>, _EqualToVal<>, _EqualVal<>, _EqualValRef<>)\n\t(_CompVal): New.\n\t(__less, __less_val, __equal_to, __comp_val, __equal_ite): New.\n\t* include/bits/stl_algo.h: Adapt all algos to use new __gnu_cxx::__ops operators.\n\tWhen possible use std::move to pass predicates to helpers and std::forward between\n\thelpers.\n\t* include/bits/stl_algobase.h: Likewise.\n\t* include/bits/stl_heap.h: Likewise.\n\t* include/std/deque: Cleanup usage of __gnu_cxx::__ops operators. Replace usage of\n\tstd::ref by std::move to pass predicate to std::__remove_if.\n\t* include/std/inplace_vector: Likewise.\n\t* include/std/string: Likewise.\n\t* include/std/vector: Likewise.\n\t* src/c++17/memory_resource.cc: Include <functional>.\n\t* testsuite/25_algorithms/inplace_merge/1.cc (test5): New test case.\n\t* testsuite/25_algorithms/stable_sort/1.cc (test4): New test case.\n---\n libstdc++-v3/include/bits/move.h              |   2 +\n libstdc++-v3/include/bits/predefined_ops.h    | 727 +++++++++++-------\n libstdc++-v3/include/bits/stl_algo.h          | 579 +++++++-------\n libstdc++-v3/include/bits/stl_algobase.h      |  88 ++-\n libstdc++-v3/include/bits/stl_heap.h          | 103 ++-\n libstdc++-v3/include/std/deque                |   7 +-\n libstdc++-v3/include/std/functional           |  54 +-\n libstdc++-v3/include/std/inplace_vector       |   6 +-\n libstdc++-v3/include/std/string               |   7 +-\n libstdc++-v3/include/std/vector               |   7 +-\n libstdc++-v3/src/c++17/memory_resource.cc     |   1 +\n .../25_algorithms/inplace_merge/1.cc          |  15 +\n .../testsuite/25_algorithms/stable_sort/1.cc  |  24 +\n 13 files changed, 911 insertions(+), 709 deletions(-)",
    "diff": "diff --git a/libstdc++-v3/include/bits/move.h b/libstdc++-v3/include/bits/move.h\nindex 8c4f461a1105..1f3a739e2c71 100644\n--- a/libstdc++-v3/include/bits/move.h\n+++ b/libstdc++-v3/include/bits/move.h\n@@ -195,10 +195,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n   /// @} group utilities\n \n #define _GLIBCXX_FWDREF(_Tp) _Tp&&\n+#define _GLIBCXX_CP_FWDREF(_Tp) _Tp&&\n #define _GLIBCXX_MOVE(__val) std::move(__val)\n #define _GLIBCXX_FORWARD(_Tp, __val) std::forward<_Tp>(__val)\n #else\n #define _GLIBCXX_FWDREF(_Tp) const _Tp&\n+#define _GLIBCXX_CP_FWDREF(_Tp) _Tp\n #define _GLIBCXX_MOVE(__val) (__val)\n #define _GLIBCXX_FORWARD(_Tp, __val) (__val)\n #endif\ndiff --git a/libstdc++-v3/include/bits/predefined_ops.h b/libstdc++-v3/include/bits/predefined_ops.h\nindex 5759ebd0e5bc..dd3c5ebdb921 100644\n--- a/libstdc++-v3/include/bits/predefined_ops.h\n+++ b/libstdc++-v3/include/bits/predefined_ops.h\n@@ -31,377 +31,526 @@\n #define _GLIBCXX_PREDEFINED_OPS_H\t1\n \n #include <bits/move.h>\n+#include <bits/stl_iterator_base_types.h>\n+\n+#if __cplusplus >= 201103L\n+# include <bits/invoke.h>\n+#endif\n \n namespace __gnu_cxx\n {\n namespace __ops\n {\n-  struct _Iter_less_iter\n+#if __cplusplus >= 201103L\n+  struct _Less\n   {\n-    template<typename _Iterator1, typename _Iterator2>\n+    template<typename _Lhs, typename _Rhs>\n       _GLIBCXX14_CONSTEXPR\n       bool\n-      operator()(_Iterator1 __it1, _Iterator2 __it2) const\n-      { return *__it1 < *__it2; }\n+      operator()(_Lhs&& __lhs, _Rhs&& __rhs) const\n+      noexcept( noexcept(__lhs < __rhs) )\n+      { return __lhs < __rhs; }\n   };\n+#else\n+  template<typename _Ref1, typename _Ref2>\n+    struct _LessRefs\n+    {\n+      bool\n+      operator()(_Ref1 __lhs, _Ref2 __rhs) const\n+      { return __lhs < __rhs; }\n \n-  _GLIBCXX14_CONSTEXPR\n-  inline _Iter_less_iter\n-  __iter_less_iter()\n-  { return _Iter_less_iter(); }\n+      bool\n+      operator()(_Ref2 __lhs, _Ref1 __rhs) const\n+      { return __lhs < __rhs; }\n \n-  struct _Iter_less_val\n-  {\n-#if __cplusplus >= 201103L\n-    constexpr _Iter_less_val() = default;\n-#else\n-    _Iter_less_val() { }\n-#endif\n+      bool\n+      operator()(_Ref1 __lhs, _Ref1 __rhs) const\n+      { return __lhs < __rhs; }\n \n-    _GLIBCXX20_CONSTEXPR\n-    explicit\n-    _Iter_less_val(_Iter_less_iter) { }\n+      bool\n+      operator()(_Ref2 __lhs, _Ref2 __rhs) const\n+      { return __lhs < __rhs; }\n+    };\n \n-    template<typename _Iterator, typename _Value>\n-      _GLIBCXX20_CONSTEXPR\n+  template<typename _Ref>\n+    struct _LessRefs<_Ref, _Ref>\n+    {\n       bool\n-      operator()(_Iterator __it, _Value& __val) const\n-      { return *__it < __val; }\n-  };\n+      operator()(_Ref __lhs, _Ref __rhs) const\n+      { return __lhs < __rhs; }\n+    };\n \n-  _GLIBCXX20_CONSTEXPR\n-  inline _Iter_less_val\n-  __iter_less_val()\n-  { return _Iter_less_val(); }\n+  template<typename _Ite1, typename _Ite2>\n+    struct _Less\n+    : _LessRefs<typename std::iterator_traits<_Ite1>::reference,\n+\t\ttypename std::iterator_traits<_Ite2>::reference>\n+    { };\n+\n+  template<typename _Ite>\n+    struct _LessCRef\n+    : _LessRefs<typename std::iterator_traits<_Ite>::reference,\n+\t\tconst typename std::iterator_traits<_Ite>::value_type&>\n+    { };\n+#endif\n \n-  _GLIBCXX20_CONSTEXPR\n-  inline _Iter_less_val\n-  __iter_comp_val(_Iter_less_iter)\n-  { return _Iter_less_val(); }\n+#if __cplusplus >= 201103L\n+  template<typename _Ite1, typename _Ite2>\n+    constexpr _Less\n+    __less(_Ite1, _Ite2) noexcept\n+    { return _Less{}; }\n+\n+  constexpr _Less\n+  __less() noexcept\n+  { return _Less{}; }\n+#else\n+  template<typename _Ite1, typename _Ite2>\n+    inline _Less<_Ite1, _Ite2>\n+    __less(_Ite1, _Ite2)\n+    { return _Less<_Ite1, _Ite2>(); }\n+#endif\n \n-  struct _Val_less_iter\n-  {\n #if __cplusplus >= 201103L\n-    constexpr _Val_less_iter() = default;\n+  template<typename _Ite>\n+    constexpr _Less\n+    __less(_Ite) noexcept\n+    { return _Less{}; }\n #else\n-    _Val_less_iter() { }\n+  template<typename _Ite>\n+    inline _LessCRef<_Ite>\n+    __less(_Ite)\n+    { return _LessCRef<_Ite>(); }\n #endif\n \n-    _GLIBCXX20_CONSTEXPR\n-    explicit\n-    _Val_less_iter(_Iter_less_iter) { }\n+#if __cplusplus >= 201103L\n+  template<typename _Comp, typename _Ite1, typename _Ite2>\n+    constexpr auto\n+    __less(_Comp&& __comp, _Ite1, _Ite2) noexcept\n+    -> decltype(std::forward<_Comp>(__comp))\n+    { return std::forward<_Comp>(__comp); }\n+#else\n+  template<typename _Comp, typename _Ite1, typename _Ite2>\n+    inline _Comp\n+    __less(_Comp __comp, _Ite1, _Ite2)\n+    { return __comp; }\n+\n+  template<typename _LessRef1, typename _LessRef2, typename _Ite1, typename _Ite2>\n+    inline _Less<_Ite1, _Ite2>\n+    __less(const _LessRefs<_LessRef1, _LessRef2>&, _Ite1, _Ite2)\n+    { return _Less<_Ite1, _Ite2>(); }\n+#endif\n \n-    template<typename _Value, typename _Iterator>\n-      _GLIBCXX20_CONSTEXPR\n-      bool\n-      operator()(_Value& __val, _Iterator __it) const\n-      { return __val < *__it; }\n-  };\n+#if __cplusplus < 201103L\n+  template<typename _Ite, typename _Val>\n+    struct _LessVal : _LessRefs<typename std::iterator_traits<_Ite>::reference,\n+\t\t\t      _Val&>\n+    { };\n+#endif\n \n-  _GLIBCXX20_CONSTEXPR\n-  inline _Val_less_iter\n-  __val_less_iter()\n-  { return _Val_less_iter(); }\n+#if __cplusplus >= 201103L\n+  template<typename _Ite, typename _Val>\n+    constexpr _Less\n+    __less_val(_Ite, _Val&&) noexcept\n+    { return _Less{}; }\n+#else\n+  template<typename _Ite, typename _Val>\n+    inline _LessVal<_Ite, _Val>\n+    __less_val(_Ite, _Val&)\n+    { return _LessVal<_Ite, _Val>(); }\n+#endif\n \n-  _GLIBCXX20_CONSTEXPR\n-  inline _Val_less_iter\n-  __val_comp_iter(_Iter_less_iter)\n-  { return _Val_less_iter(); }\n+#if __cplusplus >= 201103L\n+  template<typename _Comp, typename _Ite, typename _Val>\n+    constexpr auto\n+    __less_val(_Comp&& __comp, _Ite, _Val&&) noexcept\n+    -> decltype(std::forward<_Comp>(__comp))\n+    { return std::forward<_Comp>(__comp); }\n+#else\n+  template<typename _Comp, typename _Ite, typename _Val>\n+    inline _Comp\n+    __less_val(_Comp __comp, _Ite, _Val&)\n+    { return __comp; }\n+\n+  template<typename _Ref1, typename _Ref2, typename _Ite, typename _Val>\n+    inline _LessVal<_Ite, _Val>\n+    __less_val(const _LessRefs<_Ref1, _Ref2>&, _Ite, _Val&)\n+    { return _LessVal<_Ite, _Val>(); }\n+#endif\n \n-  struct _Iter_equal_to_iter\n+#if __cplusplus >= 201103L\n+  struct _EqualTo\n   {\n-    template<typename _Iterator1, typename _Iterator2>\n+    template<typename _Lhs, typename _Rhs>\n       _GLIBCXX20_CONSTEXPR\n       bool\n-      operator()(_Iterator1 __it1, _Iterator2 __it2) const\n-      { return *__it1 == *__it2; }\n+      operator()(_Lhs&& __lhs, _Rhs&& __rhs) const\n+      noexcept( noexcept(__lhs == __rhs) )\n+      { return __lhs == __rhs; }\n   };\n-\n-  _GLIBCXX20_CONSTEXPR\n-  inline _Iter_equal_to_iter\n-  __iter_equal_to_iter()\n-  { return _Iter_equal_to_iter(); }\n-\n-  struct _Iter_equal_to_val\n-  {\n-    template<typename _Iterator, typename _Value>\n-      _GLIBCXX20_CONSTEXPR\n+#else\n+  template<typename _Ref1, typename _Ref2>\n+    struct _EqualToRefs\n+    {\n       bool\n-      operator()(_Iterator __it, _Value& __val) const\n-      { return *__it == __val; }\n-  };\n-\n-  _GLIBCXX20_CONSTEXPR\n-  inline _Iter_equal_to_val\n-  __iter_equal_to_val()\n-  { return _Iter_equal_to_val(); }\n-\n-  _GLIBCXX20_CONSTEXPR\n-  inline _Iter_equal_to_val\n-  __iter_comp_val(_Iter_equal_to_iter)\n-  { return _Iter_equal_to_val(); }\n+      operator()(_Ref1 __lhs, _Ref2 __rhs) const\n+      { return __lhs == __rhs; }\n \n-  template<typename _Compare>\n-    struct _Iter_comp_iter\n-    {\n-      _Compare _M_comp;\n+      bool\n+      operator()(_Ref2 __lhs, _Ref1 __rhs) const\n+      { return __lhs == __rhs; }\n \n-      explicit _GLIBCXX14_CONSTEXPR\n-      _Iter_comp_iter(_Compare __comp)\n-\t: _M_comp(_GLIBCXX_MOVE(__comp))\n-      { }\n+      bool\n+      operator()(_Ref1 __lhs, _Ref1 __rhs) const\n+      { return __lhs == __rhs; }\n \n-      template<typename _Iterator1, typename _Iterator2>\n-        _GLIBCXX14_CONSTEXPR\n-        bool\n-        operator()(_Iterator1 __it1, _Iterator2 __it2)\n-        { return bool(_M_comp(*__it1, *__it2)); }\n+      bool\n+      operator()(_Ref2 __lhs, _Ref2 __rhs) const\n+      { return __lhs == __rhs; }\n     };\n \n-  template<typename _Compare>\n-    _GLIBCXX14_CONSTEXPR\n-    inline _Iter_comp_iter<_Compare>\n-    __iter_comp_iter(_Compare __comp)\n-    { return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }\n-\n-  template<typename _Compare>\n-    struct _Iter_comp_val\n+  template<typename _Ref>\n+    struct _EqualToRefs<_Ref, _Ref>\n     {\n-      _Compare _M_comp;\n-\n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Iter_comp_val(_Compare __comp)\n-\t: _M_comp(_GLIBCXX_MOVE(__comp))\n-      { }\n+      bool\n+      operator()(_Ref __lhs, _Ref __rhs) const\n+      { return __lhs == __rhs; }\n+    };\n \n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)\n-\t: _M_comp(__comp._M_comp)\n-      { }\n+  template<typename _Ite1, typename _Ite2>\n+    struct _EqualTo\n+      : _EqualToRefs<typename std::iterator_traits<_Ite1>::reference,\n+\t\t     typename std::iterator_traits<_Ite2>::reference>\n+    { };\n+#endif\n \n #if __cplusplus >= 201103L\n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)\n-\t: _M_comp(std::move(__comp._M_comp))\n-      { }\n+  template<typename _Ite1, typename _Ite2>\n+    constexpr _EqualTo\n+    __equal_to(_Ite1, _Ite2) noexcept\n+    { return _EqualTo{}; }\n+\n+  constexpr _EqualTo\n+  __equal_to() noexcept\n+  { return _EqualTo{}; }\n+#else\n+  template<typename _Ite1, typename _Ite2>\n+    inline _EqualTo<_Ite1, _Ite2>\n+    __equal_to(_Ite1, _Ite2)\n+    { return _EqualTo<_Ite1, _Ite2>(); }\n #endif\n \n-      template<typename _Iterator, typename _Value>\n-\t_GLIBCXX20_CONSTEXPR\n-\tbool\n-\toperator()(_Iterator __it, _Value& __val)\n-\t{ return bool(_M_comp(*__it, __val)); }\n-    };\n-\n-  template<typename _Compare>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Iter_comp_val<_Compare>\n-    __iter_comp_val(_Compare __comp)\n-    { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }\n-\n-  template<typename _Compare>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Iter_comp_val<_Compare>\n-    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)\n-    { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }\n-\n-  template<typename _Compare>\n-    struct _Val_comp_iter\n-    {\n-      _Compare _M_comp;\n-\n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Val_comp_iter(_Compare __comp)\n-\t: _M_comp(_GLIBCXX_MOVE(__comp))\n-      { }\n-\n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)\n-\t: _M_comp(__comp._M_comp)\n-      { }\n-\n #if __cplusplus >= 201103L\n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)\n-\t: _M_comp(std::move(__comp._M_comp))\n-      { }\n+  template<typename _Ite>\n+    constexpr _EqualTo\n+    __equal_to(_Ite) noexcept\n+    { return _EqualTo{}; }\n+#else\n+  template<typename _Ite>\n+    inline _EqualTo<_Ite, _Ite>\n+    __equal_to(_Ite)\n+    { return _EqualTo<_Ite, _Ite>(); }\n #endif\n \n-      template<typename _Value, typename _Iterator>\n-\t_GLIBCXX20_CONSTEXPR\n-\tbool\n-\toperator()(_Value& __val, _Iterator __it)\n-\t{ return bool(_M_comp(__val, *__it)); }\n-    };\n-\n-  template<typename _Compare>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Val_comp_iter<_Compare>\n-    __val_comp_iter(_Compare __comp)\n-    { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }\n+#if __cplusplus < 201103L\n+  template<typename _Ite, typename _Val>\n+    struct _EqualToVal\n+      : _EqualToRefs<typename std::iterator_traits<_Ite>::reference, _Val&>\n+    { };\n+#endif\n \n-  template<typename _Compare>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Val_comp_iter<_Compare>\n-    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)\n-    { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }\n+#if __cplusplus >= 201103L\n+  template<typename _Comp, typename _Ite, typename _Val>\n+    constexpr auto\n+    __equal_to_val(_Comp&& __comp, _Ite, _Val&&) noexcept\n+    -> decltype(std::forward<_Comp>(__comp))\n+    { return std::forward<_Comp>(__comp); }\n+#else\n+  template<typename _Comp, typename _Ite, typename _Val>\n+    inline _Comp\n+    __equal_to_val(_Comp __comp, _Ite, _Val&)\n+    { return __comp; }\n+\n+  template<typename _Ref1, typename _Ref2, typename _Ite, typename _Val>\n+    inline _EqualToVal<_Ite, _Val>\n+    __equal_to_val(const _EqualToRefs<_Ref1, _Ref2>&, _Ite, _Val&)\n+    { return _EqualToVal<_Ite, _Val>(); }\n+#endif\n \n-  template<typename _Value>\n-    struct _Iter_equals_val\n+#if __cplusplus >= 201103L\n+  template<typename _Val>\n+    struct _EqualVal\n     {\n-      _Value& _M_value;\n+    private:\n+      _Val _M_val;\n \n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Iter_equals_val(_Value& __value)\n-\t: _M_value(__value)\n-      { }\n+    public:\n+      constexpr\n+      _EqualVal(_Val __val)\n+      : _M_val(__val) { }\n \n-      template<typename _Iterator>\n+      template<typename _Lhs>\n \t_GLIBCXX20_CONSTEXPR\n \tbool\n-\toperator()(_Iterator __it)\n-\t{ return *__it == _M_value; }\n+\toperator()(_Lhs&& __lhs) const\n+\tnoexcept( noexcept(__lhs == _M_val) )\n+\t{ return __lhs == _M_val; }\n     };\n-\n-  template<typename _Value>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Iter_equals_val<_Value>\n-    __iter_equals_val(_Value& __val)\n-    { return _Iter_equals_val<_Value>(__val); }\n-\n-  template<typename _Iterator1>\n-    struct _Iter_equals_iter\n+#else\n+  template<typename _Ref, typename _Val>\n+    struct _EqualValRef\n     {\n-      _Iterator1 _M_it1;\n+    private:\n+      _Val _M_val;\n \n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Iter_equals_iter(_Iterator1 __it1)\n-\t: _M_it1(__it1)\n+    public:\n+      _EqualValRef(_Val __val)\n+      : _M_val(__val)\n       { }\n \n-      template<typename _Iterator2>\n-\t_GLIBCXX20_CONSTEXPR\n-\tbool\n-\toperator()(_Iterator2 __it2)\n-\t{ return *__it2 == *_M_it1; }\n+      bool\n+      operator()(_Ref __lhs) const\n+      { return __lhs == _M_val; }\n     };\n \n-  template<typename _Iterator>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Iter_equals_iter<_Iterator>\n-    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)\n-    { return _Iter_equals_iter<_Iterator>(__it); }\n-\n-  template<typename _Predicate>\n-    struct _Iter_pred\n+  template<typename _Ite, typename _Val>\n+    struct _EqualVal\n+    : _EqualValRef<typename std::iterator_traits<_Ite>::reference, _Val>\n     {\n-      _Predicate _M_pred;\n+      typedef\n+      _EqualValRef<typename std::iterator_traits<_Ite>::reference, _Val> _Base;\n \n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Iter_pred(_Predicate __pred)\n-\t: _M_pred(_GLIBCXX_MOVE(__pred))\n+      _EqualVal(_Val __val)\n+      : _Base(__val)\n       { }\n-\n-      template<typename _Iterator>\n-\t_GLIBCXX20_CONSTEXPR\n-\tbool\n-\toperator()(_Iterator __it)\n-\t{ return bool(_M_pred(*__it)); }\n     };\n+#endif\n \n-  template<typename _Predicate>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Iter_pred<_Predicate>\n-    __pred_iter(_Predicate __pred)\n-    { return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)); }\n+#if __cplusplus >= 201103L\n+  template<typename _Ite, typename _Val>\n+    constexpr _EqualVal<const _Val&>\n+    __equal_val(_Ite, const _Val& __val) noexcept\n+    {return _EqualVal<const _Val&>(__val);}\n+\n+  template<typename _Val>\n+    constexpr _EqualVal<const _Val&>\n+    __equal_val(const _Val& __val) noexcept\n+    {return _EqualVal<const _Val&>(__val);}\n+#else\n+  template<typename _Ite, typename _Val>\n+    inline _EqualVal<_Ite, const _Val&>\n+    __equal_val(_Ite, const _Val& __val)\n+    { return _EqualVal<_Ite, const _Val&>(__val); }\n+#endif\n \n-  template<typename _Compare, typename _Value>\n-    struct _Iter_comp_to_val\n+#if __cplusplus >= 201103L\n+  template<typename _BinaryPred, typename _Val>\n+    struct _CompVal\n     {\n-      _Compare _M_comp;\n-      _Value& _M_value;\n-\n-      _GLIBCXX20_CONSTEXPR\n-      _Iter_comp_to_val(_Compare __comp, _Value& __value)\n-\t: _M_comp(_GLIBCXX_MOVE(__comp)), _M_value(__value)\n+      template<typename _BPred>\n+\tconstexpr\n+\t_CompVal(_BPred&& __pred, _Val __val)\n+\t: _M_binary_pred(std::forward<_BPred>(__pred))\n+\t, _M_val(__val)\n+\t{ }\n+\n+      _CompVal(const _CompVal&) = default;\n+      _CompVal(_CompVal&&) = default;\n+      ~_CompVal() = default;\n+\n+      // Macro to define operator() with given cv-qualifiers ref-qualifiers,\n+      // forwarding _M_binary_pred and the function arguments with the same\n+      // qualifiers, and deducing the return type and exception-specification.\n+# define _GLIBCXX_BINARY_PRED_CALL_OP( _QUALS )\t\t\t\t\\\n+      template<typename _Arg,\t\t\t\t\t\t\\\n+\t       typename = std::__enable_if_t<std::__is_invocable<\t\\\n+\t\t _BinaryPred _QUALS, _Arg, _Val>::value>> \t\\\n+\t_GLIBCXX20_CONSTEXPR\t\t\t\t\t\t\\\n+\tbool\t\t\t\t\t\t\t\t\\\n+\toperator()(_Arg&& __arg) _QUALS\t\t\t\t\t\\\n+\tnoexcept(std::__is_nothrow_invocable<\t\t\t\t\\\n+\t\t _BinaryPred _QUALS, _Arg, _Val>::value)\t\t\\\n+\t{\t\t\t\t\t\t\t\t\\\n+\t  return std::__invoke(\t\t\t\t\t\t\\\n+\t\t   std::forward< _BinaryPred _QUALS >(_M_binary_pred),\t\\\n+\t\t   std::forward<_Arg>(__arg), _M_val);\t\t\t\\\n+\t}\t\t\t\t\t\t\t\t\\\n+\t\t\t\t\t\t\t\t\t\\\n+      template<typename _Arg,\t\t\t\t\t\t\\\n+\t       typename = std::__enable_if_t<!std::__is_invocable<\t\\\n+\t\t _BinaryPred _QUALS, _Arg, _Val>::value>>\t\\\n+\tvoid operator()(_Arg&&) _QUALS = delete;\n+\n+      _GLIBCXX_BINARY_PRED_CALL_OP( & )\n+      _GLIBCXX_BINARY_PRED_CALL_OP( const & )\n+      _GLIBCXX_BINARY_PRED_CALL_OP( && )\n+      _GLIBCXX_BINARY_PRED_CALL_OP( const && )\n+# undef _GLIBCXX_BINARY_PRED_CALL_OP\n+#else\n+  template<typename _BinaryPred, typename _Ite, typename _Val>\n+    struct _CompVal\n+    {\n+      _CompVal(_BinaryPred __pred, _Val __val)\n+      : _M_binary_pred(__pred), _M_val(__val)\n       { }\n \n-      template<typename _Iterator>\n-\t_GLIBCXX20_CONSTEXPR\n-\tbool\n-\toperator()(_Iterator __it)\n-\t{ return bool(_M_comp(*__it, _M_value)); }\n+      bool\n+      operator()(typename std::iterator_traits<_Ite>::reference __lhs)\n+      { return bool(_M_binary_pred(__lhs, _M_val)); }\n+#endif\n+\n+    private:\n+      _BinaryPred _M_binary_pred;\n+      _Val\t  _M_val;\n     };\n \n-  template<typename _Compare, typename _Value>\n-    _Iter_comp_to_val<_Compare, _Value>\n-    _GLIBCXX20_CONSTEXPR\n-    __iter_comp_val(_Compare __comp, _Value &__val)\n+#if __cplusplus >= 201103L\n+  template<typename _BPred, typename _Ite, typename _Val>\n+    _GLIBCXX20_CONSTEXPR inline\n+    _CompVal<std::__decay_t<_BPred>, const _Val&>\n+    __comp_val(_BPred&& __pred, _Ite, const _Val& __val)\n+    noexcept(std::is_nothrow_constructible<std::__decay_t<_BPred>,\n+\t     _BPred&&>::value)\n     {\n-      return _Iter_comp_to_val<_Compare, _Value>(_GLIBCXX_MOVE(__comp), __val);\n+      return\n+\t_CompVal<std::__decay_t<_BPred>, const _Val&>\n+\t(std::forward<_BPred>(__pred), __val);\n     }\n+#else\n+  template<typename _BPred, typename _Ite, typename _Val>\n+    inline _CompVal<_BPred, _Ite, const _Val&>\n+    __comp_val(_BPred __pred, _Ite, const _Val& __val)\n+    { return _CompVal<_BPred, _Ite, const _Val&>(__pred, __val); }\n+#endif\n \n-  template<typename _Compare, typename _Iterator1>\n-    struct _Iter_comp_to_iter\n+#if __cplusplus >= 201103L\n+  template<typename _BPred, typename _InIte, typename _Ite>\n+    _GLIBCXX20_CONSTEXPR inline\n+    _CompVal<std::__decay_t<_BPred>,\n+\t     typename std::iterator_traits<_Ite>::reference>\n+    __equal_ite(_BPred&& __pred, _InIte, _Ite  __ite)\n+    noexcept(std::is_nothrow_constructible<std::__decay_t<_BPred>,\n+\t     _BPred&&>::value)\n     {\n-      _Compare _M_comp;\n-      _Iterator1 _M_it1;\n-\n-      _GLIBCXX20_CONSTEXPR\n-      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)\n-\t: _M_comp(_GLIBCXX_MOVE(__comp)), _M_it1(__it1)\n-      { }\n-\n-      template<typename _Iterator2>\n-\t_GLIBCXX20_CONSTEXPR\n-\tbool\n-\toperator()(_Iterator2 __it2)\n-\t{ return bool(_M_comp(*__it2, *_M_it1)); }\n-    };\n+      return\n+\t_CompVal<std::__decay_t<_BPred>,\n+\t\t typename std::iterator_traits<_Ite>::reference>\n+\t(std::forward<_BPred>(__pred), *__ite);\n+    }\n \n-  template<typename _Compare, typename _Iterator>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Iter_comp_to_iter<_Compare, _Iterator>\n-    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)\n+  template<typename _InIte, typename _Ite>\n+    _GLIBCXX20_CONSTEXPR inline\n+    _EqualVal<typename std::iterator_traits<_Ite>::reference>\n+    __equal_ite(_EqualTo, _InIte, _Ite __ite)\n     {\n-      return _Iter_comp_to_iter<_Compare, _Iterator>(\n-\t  _GLIBCXX_MOVE(__comp._M_comp), __it);\n+      return\n+\t_EqualVal<typename std::iterator_traits<_Ite>::reference>(*__ite);\n+    }\n+#else\n+  template<typename _BPred, typename _InIte, typename _Ite>\n+    inline\n+      _CompVal<_BPred, _InIte, typename std::iterator_traits<_Ite>::reference>\n+    __equal_ite(_BPred __pred, _InIte, _Ite __ite)\n+    {\n+      return\n+\t_CompVal<_BPred, _InIte, typename std::iterator_traits<_Ite>::reference>\n+\t(__pred, *__ite);\n     }\n \n-  template<typename _Predicate>\n-    struct _Iter_negate\n+  template<typename _Ref1, typename _Ref2, typename _InIte, typename _Ite>\n+    inline\n+      _EqualVal<_InIte, typename std::iterator_traits<_Ite>::reference>\n+    __equal_ite(const _EqualToRefs<_Ref1, _Ref2>&, _InIte, _Ite __ite)\n     {\n-      _Predicate _M_pred;\n+      return\n+\t_EqualVal<_InIte, typename std::iterator_traits<_Ite>::reference>\n+\t(*__ite);\n+    }\n+#endif\n+} // namespace __ops\n+} // namespace __gnu_cxx\n \n-      _GLIBCXX20_CONSTEXPR\n-      explicit\n-      _Iter_negate(_Predicate __pred)\n-\t: _M_pred(_GLIBCXX_MOVE(__pred))\n-      { }\n \n-      template<typename _Iterator>\n-\t_GLIBCXX20_CONSTEXPR\n-\tbool\n-\toperator()(_Iterator __it)\n-\t{ return !bool(_M_pred(*__it)); }\n+namespace std _GLIBCXX_VISIBILITY(default)\n+{\n+_GLIBCXX_BEGIN_NAMESPACE_VERSION\n+\n+#if __cplusplus >= 201103L\n+  /// Generalized negator.\n+  template<typename _Fn>\n+    class _Not_fn\n+    {\n+      template<typename _Fn2, typename... _Args>\n+\tusing __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type;\n+\n+      template<typename _Tp>\n+\tstatic decltype(!std::declval<_Tp>())\n+\t_S_not() noexcept(noexcept(!std::declval<_Tp>()));\n+\n+    public:\n+      template<typename _Fn2>\n+\tconstexpr\n+\t_Not_fn(_Fn2&& __fn, int)\n+\t: _M_fn(std::forward<_Fn2>(__fn)) { }\n+\n+      _Not_fn(const _Not_fn& __fn) = default;\n+      _Not_fn(_Not_fn&& __fn) = default;\n+      ~_Not_fn() = default;\n+\n+      // Macro to define operator() with given cv-qualifiers ref-qualifiers,\n+      // forwarding _M_fn and the function arguments with the same qualifiers,\n+      // and deducing the return type and exception-specification.\n+# define _GLIBCXX_NOT_FN_CALL_OP( _QUALS )\t\t\t\t\\\n+      template<typename... _Args,\t\t\t\t\t\\\n+\t       typename = __enable_if_t<__is_invocable<_Fn _QUALS, _Args...>::value>> \\\n+\t_GLIBCXX20_CONSTEXPR\t\t\t\t\t\t\\\n+\tdecltype(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>())\t\t\\\n+\toperator()(_Args&&... __args) _QUALS\t\t\t\t\\\n+\tnoexcept(__is_nothrow_invocable<_Fn _QUALS, _Args...>::value\t\\\n+\t    && noexcept(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>()))\t\\\n+\t{\t\t\t\t\t\t\t\t\\\n+\t  return !std::__invoke(std::forward< _Fn _QUALS >(_M_fn),\t\\\n+\t\t\t\tstd::forward<_Args>(__args)...);\t\\\n+\t}\t\t\t\t\t\t\t\t\\\n+\t\t\t\t\t\t\t\t\t\\\n+      template<typename... _Args,\t\t\t\t\t\\\n+\t       typename = __enable_if_t<!__is_invocable<_Fn _QUALS, _Args...>::value>> \\\n+\tvoid operator()(_Args&&... __args) _QUALS = delete;\n+\n+      _GLIBCXX_NOT_FN_CALL_OP( & )\n+      _GLIBCXX_NOT_FN_CALL_OP( const & )\n+      _GLIBCXX_NOT_FN_CALL_OP( && )\n+      _GLIBCXX_NOT_FN_CALL_OP( const && )\n+# undef _GLIBCXX_NOT_FN_CALL_OP\n+#else\n+  /// Generalized negator.\n+  template<typename _Fn, typename _Ite>\n+    class _Not_fn\n+    {\n+    public:\n+      _Not_fn(_Fn __fn)\n+      : _M_fn(__fn) { }\n+\n+      bool\n+      operator()(typename std::iterator_traits<_Ite>::reference __arg)\n+      { return !bool(_M_fn(__arg)); }\n+#endif\n+    private:\n+      _Fn _M_fn;\n     };\n \n-  template<typename _Predicate>\n-    _GLIBCXX20_CONSTEXPR\n-    inline _Iter_negate<_Predicate>\n-    __negate(_Iter_pred<_Predicate> __pred)\n-    { return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)); }\n+  template<typename _Fn, typename _Ite>\n+    inline _GLIBCXX20_CONSTEXPR\n+#if __cplusplus >= 201103L\n+    _Not_fn<std::__decay_t<_Fn>>\n+    __not_fn(_Fn&& __fn, _Ite)\n+    noexcept(std::is_nothrow_constructible<std::__decay_t<_Fn>, _Fn&&>::value)\n+    { return _Not_fn<std::__decay_t<_Fn>>{std::forward<_Fn>(__fn), 0}; }\n+#else\n+    _Not_fn<_Fn, _Ite>\n+    __not_fn(_Fn __fn, _Ite)\n+    { return _Not_fn<_Fn, _Ite>(__fn); }\n+#endif\n \n-} // namespace __ops\n-} // namespace __gnu_cxx\n+_GLIBCXX_END_NAMESPACE_VERSION\n+} // namespace std\n \n #endif\ndiff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h\nindex 81a2457ae6f2..bfb729ef5fd4 100644\n--- a/libstdc++-v3/include/bits/stl_algo.h\n+++ b/libstdc++-v3/include/bits/stl_algo.h\n@@ -85,21 +85,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n   template<typename _Iterator, typename _Compare>\n     _GLIBCXX20_CONSTEXPR\n     void\n-    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,\n-\t\t\t   _Iterator __c, _Compare __comp)\n+    __move_median_to_first(_Iterator __result, _Iterator __a, _Iterator __b,\n+\t\t\t   _Iterator __c, _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n-      if (__comp(__a, __b))\n+      if (__comp(*__a, *__b))\n \t{\n-\t  if (__comp(__b, __c))\n+\t  if (__comp(*__b, *__c))\n \t    std::iter_swap(__result, __b);\n-\t  else if (__comp(__a, __c))\n+\t  else if (__comp(*__a, *__c))\n \t    std::iter_swap(__result, __c);\n \t  else\n \t    std::iter_swap(__result, __a);\n \t}\n-      else if (__comp(__a, __c))\n+      else if (__comp(*__a, *__c))\n \tstd::iter_swap(__result, __a);\n-      else if (__comp(__b, __c))\n+      else if (__comp(*__b, *__c))\n \tstd::iter_swap(__result, __c);\n       else\n \tstd::iter_swap(__result, __b);\n@@ -110,10 +110,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     inline _InputIterator\n     __find_if_not(_InputIterator __first, _InputIterator __last,\n-\t\t  _Predicate __pred)\n+\t\t  _GLIBCXX_CP_FWDREF(_Predicate) __pred)\n     {\n       return std::__find_if(__first, __last,\n-\t\t\t    __gnu_cxx::__ops::__negate(__pred));\n+\tstd::__not_fn(_GLIBCXX_FORWARD(_Predicate, __pred), __first));\n     }\n \n   /// Like find_if_not(), but uses and updates a count of the\n@@ -122,10 +122,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n   template<typename _InputIterator, typename _Predicate, typename _Distance>\n     _GLIBCXX20_CONSTEXPR\n     _InputIterator\n-    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)\n+    __find_if_not_n(_InputIterator __first, _Distance& __len,\n+\t\t    _GLIBCXX_CP_FWDREF(_Predicate) __pred)\n     {\n       for (; __len; --__len,  (void) ++__first)\n-\tif (!__pred(__first))\n+\tif (!__pred(*__first))\n \t  break;\n       return __first;\n     }\n@@ -152,7 +153,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t   _Integer __count, _UnaryPredicate __unary_pred,\n+\t\t   _Integer __count,\n+\t\t   _GLIBCXX_CP_FWDREF(_UnaryPredicate) __unary_pred,\n \t\t   std::forward_iterator_tag)\n     {\n       __first = std::__find_if(__first, __last, __unary_pred);\n@@ -162,7 +164,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t    __n = __count;\n \t  _ForwardIterator __i = __first;\n \t  ++__i;\n-\t  while (__i != __last && __n != 1 && __unary_pred(__i))\n+\t  while (__i != __last && __n != 1 && __unary_pred(*__i))\n \t    {\n \t      ++__i;\n \t      --__n;\n@@ -185,7 +187,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     _RandomAccessIter\n     __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,\n-\t\t   _Integer __count, _UnaryPredicate __unary_pred,\n+\t\t   _Integer __count,\n+\t\t   _GLIBCXX_CP_FWDREF(_UnaryPredicate) __unary_pred,\n \t\t   std::random_access_iterator_tag)\n     {\n       typedef typename std::iterator_traits<_RandomAccessIter>::difference_type\n@@ -201,7 +204,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t  // __first here is always pointing to one past the last element of\n \t  // next possible match.\n \t  _RandomAccessIter __backTrack = __first;\n-\t  while (__unary_pred(--__backTrack))\n+\t  while (__unary_pred(*(--__backTrack)))\n \t    {\n \t      if (--__remainder == 0)\n \t\treturn (__first - __count); // Success\n@@ -217,15 +220,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _ForwardIterator\n     __search_n(_ForwardIterator __first, _ForwardIterator __last,\n \t       _Integer __count,\n-\t       _UnaryPredicate __unary_pred)\n+\t       _GLIBCXX_CP_FWDREF(_UnaryPredicate) __unary_pred)\n     {\n       if (__count <= 0)\n \treturn __first;\n \n       if (__count == 1)\n-\treturn std::__find_if(__first, __last, __unary_pred);\n+\treturn std::__find_if(__first, __last,\n+\t\t\t      _GLIBCXX_FORWARD(_UnaryPredicate, __unary_pred));\n \n-      return std::__search_n_aux(__first, __last, __count, __unary_pred,\n+      return std::__search_n_aux(__first, __last, __count,\n+\t\t\t\t_GLIBCXX_FORWARD(_UnaryPredicate, __unary_pred),\n \t\t\t\t std::__iterator_category(__first));\n     }\n \n@@ -237,7 +242,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,\n \t       _ForwardIterator2 __first2, _ForwardIterator2 __last2,\n \t       forward_iterator_tag, forward_iterator_tag,\n-\t       _BinaryPredicate __comp)\n+\t       _GLIBCXX_CP_FWDREF(_BinaryPredicate) __comp)\n     {\n       if (__first2 == __last2)\n \treturn __last1;\n@@ -268,7 +273,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t       _BidirectionalIterator2 __first2,\n \t       _BidirectionalIterator2 __last2,\n \t       bidirectional_iterator_tag, bidirectional_iterator_tag,\n-\t       _BinaryPredicate __comp)\n+\t       _GLIBCXX_CP_FWDREF(_BinaryPredicate) __comp)\n     {\n       // concept requirements\n       __glibcxx_function_requires(_BidirectionalIteratorConcept<\n@@ -283,7 +288,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       _RevIterator2 __rlast2(__first2);\n       _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,\n \t\t\t\t\t      _RevIterator2(__last2), __rlast2,\n-\t\t\t\t\t      __comp);\n+\t\t\t\t_GLIBCXX_FORWARD(_BinaryPredicate, __comp));\n \n       if (__rresult == __rlast1)\n \treturn __last1;\n@@ -339,7 +344,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       return std::__find_end(__first1, __last1, __first2, __last2,\n \t\t\t     std::__iterator_category(__first1),\n \t\t\t     std::__iterator_category(__first2),\n-\t\t\t     __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t\t\t     __gnu_cxx::__ops::__equal_to(__first1, __first2));\n     }\n \n   /**\n@@ -390,7 +395,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       return std::__find_end(__first1, __last1, __first2, __last2,\n \t\t\t     std::__iterator_category(__first1),\n \t\t\t     std::__iterator_category(__first2),\n-\t\t\t     __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t     _GLIBCXX_MOVE(__comp));\n     }\n \n #if __cplusplus >= 201103L\n@@ -410,7 +415,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR\n     inline bool\n     all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)\n-    { return __last == std::find_if_not(__first, __last, __pred); }\n+    { return __last == std::find_if_not(__first, __last, std::move(__pred)); }\n \n   /**\n    *  @brief  Checks that a predicate is false for all the elements\n@@ -428,7 +433,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR\n     inline bool\n     none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)\n-    { return __last == _GLIBCXX_STD_A::find_if(__first, __last, __pred); }\n+    {\n+      return\n+\t__last == _GLIBCXX_STD_A::find_if(__first, __last, std::move(__pred));\n+    }\n \n   /**\n    *  @brief  Checks that a predicate is true for at least one element\n@@ -447,7 +455,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR\n     inline bool\n     any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)\n-    { return !std::none_of(__first, __last, __pred); }\n+    { return !std::none_of(__first, __last, std::move(__pred)); }\n \n   /**\n    *  @brief  Find the first element in a sequence for which a\n@@ -470,8 +478,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,\n \t      typename iterator_traits<_InputIterator>::value_type>)\n       __glibcxx_requires_valid_range(__first, __last);\n-      return std::__find_if_not(__first, __last,\n-\t\t\t\t__gnu_cxx::__ops::__pred_iter(__pred));\n+      return std::__find_if_not(__first, __last, std::move(__pred));\n     }\n \n   /**\n@@ -494,7 +501,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       if (__first == __last)\n \treturn true;\n       ++__first;\n-      return std::none_of(__first, __last, __pred);\n+      return std::none_of(__first, __last, std::move(__pred));\n     }\n \n   /**\n@@ -541,17 +548,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t}\n       return __first;\n     }\n-#endif\n+#endif // C++11\n \n   template<typename _InputIterator, typename _OutputIterator,\n \t   typename _Predicate>\n     _GLIBCXX20_CONSTEXPR\n     _OutputIterator\n     __remove_copy_if(_InputIterator __first, _InputIterator __last,\n-\t\t     _OutputIterator __result, _Predicate __pred)\n+\t\t     _OutputIterator __result,\n+\t\t     _GLIBCXX_CP_FWDREF(_Predicate) __pred)\n     {\n       for (; __first != __last; ++__first)\n-\tif (!__pred(__first))\n+\tif (!__pred(*__first))\n \t  {\n \t    *__result = *__first;\n \t    ++__result;\n@@ -588,7 +596,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__remove_copy_if(__first, __last, __result,\n-\t__gnu_cxx::__ops::__iter_equals_val(__value));\n+\t__gnu_cxx::__ops::__equal_val(__first, __value));\n     }\n \n   /**\n@@ -622,7 +630,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__remove_copy_if(__first, __last, __result,\n-\t\t\t\t   __gnu_cxx::__ops::__pred_iter(__pred));\n+\t\t\t\t   _GLIBCXX_MOVE(__pred));\n     }\n \n #if __cplusplus >= 201103L\n@@ -780,7 +788,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__remove_if(__first, __last,\n-\t\t__gnu_cxx::__ops::__iter_equals_val(__value));\n+\t__gnu_cxx::__ops::__equal_val(__first, __value));\n     }\n \n   /**\n@@ -814,21 +822,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__remove_if(__first, __last,\n-\t\t\t      __gnu_cxx::__ops::__pred_iter(__pred));\n+\t\t\t      _GLIBCXX_MOVE(__pred));\n     }\n \n   template<typename _ForwardIterator, typename _BinaryPredicate>\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t    _BinaryPredicate __binary_pred)\n+\t\t    _GLIBCXX_CP_FWDREF(_BinaryPredicate) __binary_pred)\n     {\n       if (__first == __last)\n \treturn __last;\n       _ForwardIterator __next = __first;\n       while (++__next != __last)\n \t{\n-\t  if (__binary_pred(__first, __next))\n+\t  if (__binary_pred(*__first, *__next))\n \t    return __first;\n \t  __first = __next;\n \t}\n@@ -839,7 +847,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __unique(_ForwardIterator __first, _ForwardIterator __last,\n-\t     _BinaryPredicate __binary_pred)\n+\t     _GLIBCXX_CP_FWDREF(_BinaryPredicate) __binary_pred)\n     {\n       // Skip the beginning, if already unique.\n       __first = std::__adjacent_find(__first, __last, __binary_pred);\n@@ -850,7 +858,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       _ForwardIterator __dest = __first;\n       ++__first;\n       while (++__first != __last)\n-\tif (!__binary_pred(__dest, __first))\n+\tif (!__binary_pred(*__dest, *__first))\n \t  *++__dest = _GLIBCXX_MOVE(*__first);\n       return ++__dest;\n     }\n@@ -882,7 +890,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__unique(__first, __last,\n-\t\t\t   __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t__gnu_cxx::__ops::__equal_to(__first));\n     }\n \n   /**\n@@ -915,7 +923,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__unique(__first, __last,\n-\t\t\t   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));\n+\t\t\t   _GLIBCXX_MOVE(__binary_pred));\n     }\n \n   // _GLIBCXX_RESOLVE_LIB_DEFECTS\n@@ -928,13 +936,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     _OutputIterator\n     __unique_copy(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t  _OutputIterator __result, _BinaryPredicate __binary_pred,\n+\t\t  _OutputIterator __result,\n+\t\t  _GLIBCXX_CP_FWDREF(_BinaryPredicate) __binary_pred,\n \t\t  forward_iterator_tag)\n     {\n       _ForwardIterator __prev = __first;\n       *__result = *__first;\n       while (++__first != __last)\n-\tif (!__binary_pred(__prev, __first))\n+\tif (!__binary_pred(*__prev, *__first))\n \t  {\n \t    *++__result = *__first;\n \t    __prev = __first;\n@@ -949,14 +958,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     _OutputIterator\n     __unique_copy_1(_InputIterator __first, _InputIterator __last,\n-\t\t    _OutputIterator __result, _BinaryPredicate __binary_pred,\n+\t\t    _OutputIterator __result,\n+\t\t    _GLIBCXX_CP_FWDREF(_BinaryPredicate) __binary_pred,\n \t\t    __false_type)\n     {\n       typedef typename iterator_traits<_InputIterator>::value_type _Val;\n       _Val __value = *__first;\n+      __decltype(__gnu_cxx::__ops::__equal_to_val\n+\t\t (_GLIBCXX_FORWARD(_BinaryPredicate, __binary_pred),\n+\t\t  __first, __value)) __bnry_pred =\n+\t__gnu_cxx::__ops::__equal_to_val\n+\t(_GLIBCXX_FORWARD(_BinaryPredicate, __binary_pred), __first, __value);\n       *__result = __value;\n       while (++__first != __last)\n-\tif (!__binary_pred(std::__addressof(__value), __first))\n+\tif (!__bnry_pred(__value, *__first))\n \t  {\n \t    __value = *__first;\n \t    *++__result = __value;\n@@ -970,12 +985,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t   typename _BinaryPredicate>\n     _ForwardIterator\n     __unique_copy_1(_InputIterator __first, _InputIterator __last,\n-\t\t    _ForwardIterator __result, _BinaryPredicate __binary_pred,\n+\t\t    _ForwardIterator __result,\n+\t\t    _GLIBCXX_CP_FWDREF(_BinaryPredicate) __binary_pred,\n \t\t    __true_type)\n     {\n       *__result = *__first;\n       while (++__first != __last)\n-\tif (!__binary_pred(__result, __first))\n+\tif (!__binary_pred(*__result, *__first))\n \t  *++__result = *__first;\n       return ++__result;\n     }\n@@ -1385,7 +1401,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __partition(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t_Predicate __pred, forward_iterator_tag)\n+\t\t_GLIBCXX_CP_FWDREF(_Predicate) __pred, forward_iterator_tag)\n     {\n       if (__first == __last)\n \treturn __first;\n@@ -1411,7 +1427,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     _BidirectionalIterator\n     __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,\n-\t\t_Predicate __pred, bidirectional_iterator_tag)\n+\t\t_GLIBCXX_CP_FWDREF(_Predicate) __pred, bidirectional_iterator_tag)\n     {\n       while (true)\n \t{\n@@ -1450,7 +1466,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _ForwardIterator\n     __stable_partition_adaptive(_ForwardIterator __first,\n \t\t\t\t_ForwardIterator __last,\n-\t\t\t\t_Predicate __pred, _Distance __len,\n+\t\t\t\t_GLIBCXX_CP_FWDREF(_Predicate) __pred,\n+\t\t\t\t_Distance __len,\n \t\t\t\t_Pointer __buffer,\n \t\t\t\t_Distance __buffer_size)\n     {\n@@ -1469,7 +1486,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  ++__result2;\n \t  ++__first;\n \t  for (; __first != __last; ++__first)\n-\t    if (__pred(__first))\n+\t    if (__pred(*__first))\n \t      {\n \t\t*__result1 = _GLIBCXX_MOVE(*__first);\n \t\t++__result1;\n@@ -1499,7 +1516,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \n       if (__right_len)\n \t__right_split =\n-\t  std::__stable_partition_adaptive(__right_split, __last, __pred,\n+\t  std::__stable_partition_adaptive(__right_split, __last,\n+\t\t\t\t\t   _GLIBCXX_FORWARD(_Predicate, __pred),\n \t\t\t\t\t   __right_len,\n \t\t\t\t\t   __buffer, __buffer_size);\n \n@@ -1510,7 +1528,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX26_CONSTEXPR\n     _ForwardIterator\n     __stable_partition(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t       _Predicate __pred)\n+\t\t       _GLIBCXX_CP_FWDREF(_Predicate) __pred)\n     {\n       __first = std::__find_if_not(__first, __last, __pred);\n \n@@ -1539,7 +1557,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       _Temporary_buffer<_ForwardIterator, _ValueType>\n \t__buf(__first, __len);\n       return\n-\tstd::__stable_partition_adaptive(__first, __last, __pred,\n+\tstd::__stable_partition_adaptive(__first, __last,\n+\t\t\t\t\t _GLIBCXX_FORWARD(_Predicate, __pred),\n \t\t\t\t\t __len,\n \t\t\t\t\t __buf.begin(),\n \t\t\t\t\t _DistanceType(__buf.size()));\n@@ -1576,7 +1595,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__stable_partition(__first, __last,\n-\t\t\t\t     __gnu_cxx::__ops::__pred_iter(__pred));\n+\t\t\t\t     _GLIBCXX_MOVE(__pred));\n     }\n #endif // HOSTED\n \n@@ -1588,11 +1607,12 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     void\n     __heap_select(_RandomAccessIterator __first,\n \t\t  _RandomAccessIterator __middle,\n-\t\t  _RandomAccessIterator __last, _Compare __comp)\n+\t\t  _RandomAccessIterator __last,\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       std::__make_heap(__first, __middle, __comp);\n       for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)\n-\tif (__comp(__i, __first))\n+\tif (__comp(*__i, *__first))\n \t  std::__pop_heap(__first, __middle, __i, __comp);\n     }\n \n@@ -1605,7 +1625,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     __partial_sort_copy(_InputIterator __first, _InputIterator __last,\n \t\t\t_RandomAccessIterator __result_first,\n \t\t\t_RandomAccessIterator __result_last,\n-\t\t\t_Compare __comp)\n+\t\t\t_GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_InputIterator>::value_type\n \t_InputValueType;\n@@ -1625,14 +1645,15 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       std::__make_heap(__result_first, __result_real_last, __comp);\n       while (__first != __last)\n \t{\n-\t  if (__comp(__first, __result_first))\n+\t  if (__comp(*__first, *__result_first))\n \t    std::__adjust_heap(__result_first, _DistanceType(0),\n \t\t\t       _DistanceType(__result_real_last\n \t\t\t\t\t     - __result_first),\n \t\t\t       _InputValueType(*__first), __comp);\n \t  ++__first;\n \t}\n-      std::__sort_heap(__result_first, __result_real_last, __comp);\n+      std::__sort_heap(__result_first, __result_real_last,\n+\t\t       _GLIBCXX_FORWARD(_Compare, __comp));\n       return __result_real_last;\n     }\n \n@@ -1683,7 +1704,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \n       return std::__partial_sort_copy(__first, __last,\n \t\t\t\t      __result_first, __result_last,\n-\t\t\t\t      __gnu_cxx::__ops::__iter_less_iter());\n+\t__gnu_cxx::__ops::__less(__first, __result_first));\n     }\n \n   /**\n@@ -1738,7 +1759,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \n       return std::__partial_sort_copy(__first, __last,\n \t\t\t\t      __result_first, __result_last,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t      _GLIBCXX_MOVE(__comp));\n     }\n \n   /// @cond undocumented\n@@ -1748,13 +1769,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     void\n     __unguarded_linear_insert(_RandomAccessIterator __last,\n-\t\t\t      _Compare __comp)\n+\t\t\t      _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typename iterator_traits<_RandomAccessIterator>::value_type\n \t__val = _GLIBCXX_MOVE(*__last);\n       _RandomAccessIterator __next = __last;\n       --__next;\n-      while (__comp(__val, __next))\n+      while (__comp(__val, *__next))\n \t{\n \t  *__last = _GLIBCXX_MOVE(*__next);\n \t  __last = __next;\n@@ -1768,13 +1789,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     void\n     __insertion_sort(_RandomAccessIterator __first,\n-\t\t     _RandomAccessIterator __last, _Compare __comp)\n+\t\t     _RandomAccessIterator __last,\n+\t\t     _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__first == __last) return;\n \n       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)\n \t{\n-\t  if (__comp(__i, __first))\n+\t  if (__comp(*__i, *__first))\n \t    {\n \t      typename iterator_traits<_RandomAccessIterator>::value_type\n \t\t__val = _GLIBCXX_MOVE(*__i);\n@@ -1782,8 +1804,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t      *__first = _GLIBCXX_MOVE(__val);\n \t    }\n \t  else\n-\t    std::__unguarded_linear_insert(__i,\n-\t\t\t\t__gnu_cxx::__ops::__val_comp_iter(__comp));\n+\t    std::__unguarded_linear_insert(__i, __comp);\n \t}\n     }\n \n@@ -1792,11 +1813,11 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     inline void\n     __unguarded_insertion_sort(_RandomAccessIterator __first,\n-\t\t\t       _RandomAccessIterator __last, _Compare __comp)\n+\t\t\t       _RandomAccessIterator __last,\n+\t\t\t       _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       for (_RandomAccessIterator __i = __first; __i != __last; ++__i)\n-\tstd::__unguarded_linear_insert(__i,\n-\t\t\t\t__gnu_cxx::__ops::__val_comp_iter(__comp));\n+\tstd::__unguarded_linear_insert(__i, __comp);\n     }\n \n   /**\n@@ -1810,16 +1831,18 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     void\n     __final_insertion_sort(_RandomAccessIterator __first,\n-\t\t\t   _RandomAccessIterator __last, _Compare __comp)\n+\t\t\t   _RandomAccessIterator __last,\n+\t\t\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__last - __first > int(_S_threshold))\n \t{\n \t  std::__insertion_sort(__first, __first + int(_S_threshold), __comp);\n \t  std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,\n-\t\t\t\t\t  __comp);\n+\t\t\t\t\t  _GLIBCXX_FORWARD(_Compare, __comp));\n \t}\n       else\n-\tstd::__insertion_sort(__first, __last, __comp);\n+\tstd::__insertion_sort(__first, __last,\n+\t\t\t      _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   /// This is a helper function...\n@@ -1828,14 +1851,15 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _RandomAccessIterator\n     __unguarded_partition(_RandomAccessIterator __first,\n \t\t\t  _RandomAccessIterator __last,\n-\t\t\t  _RandomAccessIterator __pivot, _Compare __comp)\n+\t\t\t  _RandomAccessIterator __pivot,\n+\t\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (true)\n \t{\n-\t  while (__comp(__first, __pivot))\n+\t  while (__comp(*__first, *__pivot))\n \t    ++__first;\n \t  --__last;\n-\t  while (__comp(__pivot, __last))\n+\t  while (__comp(*__pivot, *__last))\n \t    --__last;\n \t  if (!(__first < __last))\n \t    return __first;\n@@ -1849,12 +1873,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     inline _RandomAccessIterator\n     __unguarded_partition_pivot(_RandomAccessIterator __first,\n-\t\t\t\t_RandomAccessIterator __last, _Compare __comp)\n+\t\t\t\t_RandomAccessIterator __last,\n+\t\t\t\t_GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       _RandomAccessIterator __mid = __first + (__last - __first) / 2;\n       std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,\n \t\t\t\t  __comp);\n-      return std::__unguarded_partition(__first + 1, __last, __first, __comp);\n+      return std::__unguarded_partition(__first + 1, __last, __first,\n+\t\t\t\t\t_GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   template<typename _RandomAccessIterator, typename _Compare>\n@@ -1863,10 +1889,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     __partial_sort(_RandomAccessIterator __first,\n \t\t   _RandomAccessIterator __middle,\n \t\t   _RandomAccessIterator __last,\n-\t\t   _Compare __comp)\n+\t\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       std::__heap_select(__first, __middle, __last, __comp);\n-      std::__sort_heap(__first, __middle, __comp);\n+      std::__sort_heap(__first, __middle, _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   /// This is a helper function for the sort routine.\n@@ -1875,13 +1901,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     void\n     __introsort_loop(_RandomAccessIterator __first,\n \t\t     _RandomAccessIterator __last,\n-\t\t     _Size __depth_limit, _Compare __comp)\n+\t\t     _Size __depth_limit, _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__last - __first > int(_S_threshold))\n \t{\n \t  if (__depth_limit == 0)\n \t    {\n-\t      std::__partial_sort(__first, __last, __last, __comp);\n+\t      std::__partial_sort(__first, __last, __last,\n+\t\t\t\t  _GLIBCXX_FORWARD(_Compare, __comp));\n \t      return;\n \t    }\n \t  --__depth_limit;\n@@ -1898,14 +1925,15 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     inline void\n     __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,\n-\t   _Compare __comp)\n+\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__first != __last)\n \t{\n \t  std::__introsort_loop(__first, __last,\n \t\t\t\tstd::__lg(__last - __first) * 2,\n \t\t\t\t__comp);\n-\t  std::__final_insertion_sort(__first, __last, __comp);\n+\t  std::__final_insertion_sort(__first, __last,\n+\t\t\t\t      _GLIBCXX_FORWARD(_Compare, __comp));\n \t}\n     }\n \n@@ -1914,13 +1942,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     void\n     __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,\n \t\t  _RandomAccessIterator __last, _Size __depth_limit,\n-\t\t  _Compare __comp)\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__last - __first > 3)\n \t{\n \t  if (__depth_limit == 0)\n \t    {\n-\t      std::__heap_select(__first, __nth + 1, __last, __comp);\n+\t      std::__heap_select(__first, __nth + 1, __last,\n+\t\t\t\t _GLIBCXX_FORWARD(_Compare, __comp));\n \t      // Place the nth largest element in its final position.\n \t      std::iter_swap(__first, __nth);\n \t      return;\n@@ -1933,7 +1962,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  else\n \t    __last = __cut;\n \t}\n-      std::__insertion_sort(__first, __last, __comp);\n+      std::__insertion_sort(__first, __last,\n+\t\t\t    _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   /// @endcond\n@@ -1971,14 +2001,15 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t\t\t\t\t__val, __comp);\n \n       return std::__lower_bound(__first, __last, __val,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_val(__comp));\n+\t\t\t\t_GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _ForwardIterator, typename _Tp, typename _Compare>\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __upper_bound(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t  const _Tp& __val, _Compare __comp)\n+\t\t  _GLIBCXX_FWDREF(_Tp) __val,\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_ForwardIterator>::difference_type\n \t_DistanceType;\n@@ -1990,7 +2021,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  _DistanceType __half = __len >> 1;\n \t  _ForwardIterator __middle = __first;\n \t  std::advance(__middle, __half);\n-\t  if (__comp(__val, __middle))\n+\t  if (__comp(__val, *__middle))\n \t    __len = __half;\n \t  else\n \t    {\n@@ -2026,7 +2057,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_partitioned_upper(__first, __last, __val);\n \n       return std::__upper_bound(__first, __last, __val,\n-\t\t\t\t__gnu_cxx::__ops::__val_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less_val(__first, __val));\n     }\n \n   /**\n@@ -2058,16 +2089,16 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t\t\t\t\t__val, __comp);\n \n       return std::__upper_bound(__first, __last, __val,\n-\t\t\t\t__gnu_cxx::__ops::__val_comp_iter(__comp));\n+\t\t\t\t_GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _ForwardIterator, typename _Tp,\n-\t   typename _CompareItTp, typename _CompareTpIt>\n+\t   typename _Comp>\n     _GLIBCXX20_CONSTEXPR\n     pair<_ForwardIterator, _ForwardIterator>\n     __equal_range(_ForwardIterator __first, _ForwardIterator __last,\n \t\t  const _Tp& __val,\n-\t\t  _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)\n+\t\t  _GLIBCXX_CP_FWDREF(_Comp) __comp)\n     {\n       typedef typename iterator_traits<_ForwardIterator>::difference_type\n \t_DistanceType;\n@@ -2079,21 +2110,22 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  _DistanceType __half = __len >> 1;\n \t  _ForwardIterator __middle = __first;\n \t  std::advance(__middle, __half);\n-\t  if (__comp_it_val(__middle, __val))\n+\t  if (__comp(*__middle, __val))\n \t    {\n \t      __first = __middle;\n \t      ++__first;\n \t      __len = __len - __half - 1;\n \t    }\n-\t  else if (__comp_val_it(__val, __middle))\n+\t  else if (__comp(__val, *__middle))\n \t    __len = __half;\n \t  else\n \t    {\n \t      _ForwardIterator __left\n-\t\t= std::__lower_bound(__first, __middle, __val, __comp_it_val);\n+\t\t= std::__lower_bound(__first, __middle, __val, __comp);\n \t      std::advance(__first, __len);\n \t      _ForwardIterator __right\n-\t\t= std::__upper_bound(++__middle, __first, __val, __comp_val_it);\n+\t\t= std::__upper_bound(++__middle, __first, __val,\n+\t\t\t\t     _GLIBCXX_FORWARD(_Comp, __comp));\n \t      return pair<_ForwardIterator, _ForwardIterator>(__left, __right);\n \t    }\n \t}\n@@ -2133,8 +2165,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_partitioned_upper(__first, __last, __val);\n \n       return std::__equal_range(__first, __last, __val,\n-\t\t\t\t__gnu_cxx::__ops::__iter_less_val(),\n-\t\t\t\t__gnu_cxx::__ops::__val_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less_val(__first, __val));\n     }\n \n   /**\n@@ -2172,8 +2203,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t\t\t\t\t__val, __comp);\n \n       return std::__equal_range(__first, __last, __val,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_val(__comp),\n-\t\t\t\t__gnu_cxx::__ops::__val_comp_iter(__comp));\n+\t\t\t\t_GLIBCXX_MOVE(__comp));\n     }\n \n   /**\n@@ -2203,7 +2233,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \n       _ForwardIterator __i\n \t= std::__lower_bound(__first, __last, __val,\n-\t\t\t     __gnu_cxx::__ops::__iter_less_val());\n+\t\t\t     __gnu_cxx::__ops::__less_val(__first, __val));\n       return __i != __last && !(__val < *__i);\n     }\n \n@@ -2239,7 +2269,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \n       _ForwardIterator __i\n \t= std::__lower_bound(__first, __last, __val,\n-\t\t\t     __gnu_cxx::__ops::__iter_comp_val(__comp));\n+\t\t\t     __comp);\n       return __i != __last && !bool(__comp(__val, *__i));\n     }\n \n@@ -2251,11 +2281,12 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     void\n     __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,\n \t\t\t  _InputIterator2 __first2, _InputIterator2 __last2,\n-\t\t\t  _OutputIterator __result, _Compare __comp)\n+\t\t\t  _OutputIterator __result,\n+\t\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n \t{\n-\t  if (__comp(__first2, __first1))\n+\t  if (__comp(*__first2, *__first1))\n \t    {\n \t      *__result = _GLIBCXX_MOVE(*__first2);\n \t      ++__first2;\n@@ -2280,7 +2311,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t\t\t   _BidirectionalIterator2 __first2,\n \t\t\t\t   _BidirectionalIterator2 __last2,\n \t\t\t\t   _BidirectionalIterator3 __result,\n-\t\t\t\t   _Compare __comp)\n+\t\t\t\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__first1 == __last1)\n \t{\n@@ -2294,7 +2325,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       --__last2;\n       while (true)\n \t{\n-\t  if (__comp(__last2, __last1))\n+\t  if (__comp(*__last2, *__last1))\n \t    {\n \t      *--__result = _GLIBCXX_MOVE(*__last1);\n \t      if (__first1 == __last1)\n@@ -2360,19 +2391,25 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t     _BidirectionalIterator __middle,\n \t\t     _BidirectionalIterator __last,\n \t\t     _Distance __len1, _Distance __len2,\n-\t\t     _Pointer __buffer, _Compare __comp)\n+\t\t     _Pointer __buffer, _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n+      __decltype(__gnu_cxx::__ops::__less(_GLIBCXX_FORWARD(_Compare, __comp),\n+\t\t\t\t\t  __first, __buffer)) __cmp\n+\t= __gnu_cxx::__ops::__less(_GLIBCXX_FORWARD(_Compare, __comp),\n+\t\t\t\t   __first, __buffer);\n       if (__len1 <= __len2)\n \t{\n \t  _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);\n \t  std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,\n-\t\t\t\t     __first, __comp);\n+\t\t\t\t     __first,\n+\t\t\t\t     _GLIBCXX_FORWARD(_Compare, __cmp));\n \t}\n       else\n \t{\n \t  _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);\n \t  std::__move_merge_adaptive_backward(__first, __middle, __buffer,\n-\t\t\t\t\t      __buffer_end, __last, __comp);\n+\t\t\t\t\t      __buffer_end, __last,\n+\t\t\t\t\t     _GLIBCXX_FORWARD(_Compare, __cmp));\n \t}\n     }\n \n@@ -2384,11 +2421,12 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t\t    _BidirectionalIterator __last,\n \t\t\t    _Distance __len1, _Distance __len2,\n \t\t\t    _Pointer __buffer, _Distance __buffer_size,\n-\t\t\t    _Compare __comp)\n+\t\t\t    _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__len1 <= __buffer_size || __len2 <= __buffer_size)\n \tstd::__merge_adaptive(__first, __middle, __last,\n-\t\t\t      __len1, __len2, __buffer, __comp);\n+\t\t\t      __len1, __len2, __buffer,\n+\t\t\t      _GLIBCXX_FORWARD(_Compare, __comp));\n       else\n \t{\n \t  _BidirectionalIterator __first_cut = __first;\n@@ -2400,8 +2438,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t      __len11 = __len1 / 2;\n \t      std::advance(__first_cut, __len11);\n \t      __second_cut\n-\t\t= std::__lower_bound(__middle, __last, *__first_cut,\n-\t\t\t\t     __gnu_cxx::__ops::__iter_comp_val(__comp));\n+\t\t= std::__lower_bound(__middle, __last, *__first_cut, __comp);\n \t      __len22 = std::distance(__middle, __second_cut);\n \t    }\n \t  else\n@@ -2409,8 +2446,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t      __len22 = __len2 / 2;\n \t      std::advance(__second_cut, __len22);\n \t      __first_cut\n-\t\t= std::__upper_bound(__first, __middle, *__second_cut,\n-\t\t\t\t     __gnu_cxx::__ops::__val_comp_iter(__comp));\n+\t\t= std::__upper_bound(__first, __middle, *__second_cut, __comp);\n \t      __len11 = std::distance(__first, __first_cut);\n \t    }\n \n@@ -2424,7 +2460,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  std::__merge_adaptive_resize(__new_middle, __second_cut, __last,\n \t\t\t\t       _Distance(__len1 - __len11),\n \t\t\t\t       _Distance(__len2 - __len22),\n-\t\t\t\t       __buffer, __buffer_size, __comp);\n+\t\t\t\t       __buffer, __buffer_size,\n+\t\t\t\t       _GLIBCXX_FORWARD(_Compare, __comp));\n \t}\n     }\n \n@@ -2437,14 +2474,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t\t   _BidirectionalIterator __middle,\n \t\t\t   _BidirectionalIterator __last,\n \t\t\t   _Distance __len1, _Distance __len2,\n-\t\t\t   _Compare __comp)\n+\t\t\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__len1 == 0 || __len2 == 0)\n \treturn;\n \n       if (__len1 + __len2 == 2)\n \t{\n-\t  if (__comp(__middle, __first))\n+\t  if (__comp(*__middle, *__first))\n \t    std::iter_swap(__first, __middle);\n \t  return;\n \t}\n@@ -2458,8 +2495,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  __len11 = __len1 / 2;\n \t  std::advance(__first_cut, __len11);\n \t  __second_cut\n-\t    = std::__lower_bound(__middle, __last, *__first_cut,\n-\t\t\t\t __gnu_cxx::__ops::__iter_comp_val(__comp));\n+\t    = std::__lower_bound(__middle, __last, *__first_cut, __comp);\n \t  __len22 = std::distance(__middle, __second_cut);\n \t}\n       else\n@@ -2467,8 +2503,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  __len22 = __len2 / 2;\n \t  std::advance(__second_cut, __len22);\n \t  __first_cut\n-\t    = std::__upper_bound(__first, __middle, *__second_cut,\n-\t\t\t\t __gnu_cxx::__ops::__val_comp_iter(__comp));\n+\t    = std::__upper_bound(__first, __middle, *__second_cut, __comp);\n \t  __len11 = std::distance(__first, __first_cut);\n \t}\n \n@@ -2477,7 +2512,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       std::__merge_without_buffer(__first, __first_cut, __new_middle,\n \t\t\t\t  __len11, __len22, __comp);\n       std::__merge_without_buffer(__new_middle, __second_cut, __last,\n-\t\t\t\t  __len1 - __len11, __len2 - __len22, __comp);\n+\t\t\t\t  __len1 - __len11, __len2 - __len22,\n+\t\t\t\t  _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   template<typename _BidirectionalIterator, typename _Compare>\n@@ -2486,7 +2522,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     __inplace_merge(_BidirectionalIterator __first,\n \t\t    _BidirectionalIterator __middle,\n \t\t    _BidirectionalIterator __last,\n-\t\t    _Compare __comp)\n+\t\t    _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_BidirectionalIterator>::value_type\n \t  _ValueType;\n@@ -2513,17 +2549,20 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \n       if (__builtin_expect(__buf.size() == __buf._M_requested_size(), true))\n \tstd::__merge_adaptive\n-\t  (__first, __middle, __last, __len1, __len2, __buf.begin(), __comp);\n+\t  (__first, __middle, __last, __len1, __len2, __buf.begin(),\n+\t   _GLIBCXX_FORWARD(_Compare, __comp));\n       else if (__builtin_expect(__buf.begin() == 0, false))\n \tstd::__merge_without_buffer\n-\t  (__first, __middle, __last, __len1, __len2, __comp);\n+\t  (__first, __middle, __last, __len1, __len2,\n+\t   _GLIBCXX_FORWARD(_Compare, __comp));\n       else\n \tstd::__merge_adaptive_resize\n \t  (__first, __middle, __last, __len1, __len2, __buf.begin(),\n-\t   _DistanceType(__buf.size()), __comp);\n+\t   _DistanceType(__buf.size()), _GLIBCXX_FORWARD(_Compare, __comp));\n #else\n       std::__merge_without_buffer\n-\t(__first, __middle, __last, __len1, __len2, __comp);\n+\t(__first, __middle, __last, __len1, __len2,\n+\t _GLIBCXX_FORWARD(_Compare, __comp));\n #endif\n     }\n \n@@ -2562,7 +2601,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       std::__inplace_merge(__first, __middle, __last,\n-\t\t\t   __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t   __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -2606,7 +2645,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       std::__inplace_merge(__first, __middle, __last,\n-\t\t\t   __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t   _GLIBCXX_MOVE(__comp));\n     }\n \n \n@@ -2616,11 +2655,11 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _OutputIterator\n     __move_merge(_InputIterator __first1, _InputIterator __last1,\n \t\t _InputIterator __first2, _InputIterator __last2,\n-\t\t _OutputIterator __result, _Compare __comp)\n+\t\t _OutputIterator __result, _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n \t{\n-\t  if (__comp(__first2, __first1))\n+\t  if (__comp(*__first2, *__first1))\n \t    {\n \t      *__result = _GLIBCXX_MOVE(*__first2);\n \t      ++__first2;\n@@ -2643,7 +2682,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     __merge_sort_loop(_RandomAccessIterator1 __first,\n \t\t      _RandomAccessIterator1 __last,\n \t\t      _RandomAccessIterator2 __result, _Distance __step_size,\n-\t\t      _Compare __comp)\n+\t\t      _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       const _Distance __two_step = 2 * __step_size;\n \n@@ -2658,7 +2697,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __step_size = std::min(_Distance(__last - __first), __step_size);\n \n       std::__move_merge(__first, __first + __step_size,\n-\t\t\t__first + __step_size, __last, __result, __comp);\n+\t\t\t__first + __step_size, __last, __result,\n+\t\t\t_GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   template<typename _RandomAccessIterator, typename _Distance,\n@@ -2667,14 +2707,16 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     void\n     __chunk_insertion_sort(_RandomAccessIterator __first,\n \t\t\t   _RandomAccessIterator __last,\n-\t\t\t   _Distance __chunk_size, _Compare __comp)\n+\t\t\t   _Distance __chunk_size,\n+\t\t\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__last - __first >= __chunk_size)\n \t{\n \t  std::__insertion_sort(__first, __first + __chunk_size, __comp);\n \t  __first += __chunk_size;\n \t}\n-      std::__insertion_sort(__first, __last, __comp);\n+      std::__insertion_sort(__first, __last,\n+\t\t\t    _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   enum { _S_chunk_size = 7 };\n@@ -2683,7 +2725,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     void\n     __merge_sort_with_buffer(_RandomAccessIterator __first,\n \t\t\t     _RandomAccessIterator __last,\n-\t\t\t     _Pointer __buffer, _Compare __comp)\n+\t\t\t     _Pointer __buffer,\n+\t\t\t     _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_RandomAccessIterator>::difference_type\n \t_Distance;\n@@ -2710,14 +2753,17 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     __stable_sort_adaptive(_RandomAccessIterator __first,\n \t\t\t   _RandomAccessIterator __middle,\n \t\t\t   _RandomAccessIterator __last,\n-\t\t\t   _Pointer __buffer, _Compare __comp)\n+\t\t\t   _Pointer __buffer,\n+\t\t\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n-      std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);\n-      std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);\n+      __decltype(__gnu_cxx::__ops::__less(__comp, __first, __buffer)) __cmp\n+\t= __gnu_cxx::__ops::__less(__comp, __first, __buffer);\n+      std::__merge_sort_with_buffer(__first, __middle, __buffer, __cmp);\n+      std::__merge_sort_with_buffer(__middle, __last, __buffer, __cmp);\n \n       std::__merge_adaptive(__first, __middle, __last,\n \t\t\t    __middle - __first, __last - __middle,\n-\t\t\t    __buffer, __comp);\n+\t\t\t    __buffer, _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   template<typename _RandomAccessIterator, typename _Pointer,\n@@ -2726,7 +2772,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     __stable_sort_adaptive_resize(_RandomAccessIterator __first,\n \t\t\t\t  _RandomAccessIterator __last,\n \t\t\t\t  _Pointer __buffer, _Distance __buffer_size,\n-\t\t\t\t  _Compare __comp)\n+\t\t\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       const _Distance __len = (__last - __first + 1) / 2;\n       const _RandomAccessIterator __middle = __first + __len;\n@@ -2740,11 +2786,11 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t\t\t\t       _Distance(__middle - __first),\n \t\t\t\t       _Distance(__last - __middle),\n \t\t\t\t       __buffer, __buffer_size,\n-\t\t\t\t       __comp);\n+\t\t\t\t       _GLIBCXX_FORWARD(_Compare, __comp));\n \t}\n       else\n \tstd::__stable_sort_adaptive(__first, __middle, __last,\n-\t\t\t\t    __buffer, __comp);\n+\t\t\t\t__buffer, _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   /// This is a helper function for the stable sorting routines.\n@@ -2752,11 +2798,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX26_CONSTEXPR\n     void\n     __inplace_stable_sort(_RandomAccessIterator __first,\n-\t\t\t  _RandomAccessIterator __last, _Compare __comp)\n+\t\t\t  _RandomAccessIterator __last,\n+\t\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__last - __first < 15)\n \t{\n-\t  std::__insertion_sort(__first, __last, __comp);\n+\t  std::__insertion_sort(__first, __last,\n+\t\t\t\t_GLIBCXX_FORWARD(_Compare, __comp));\n \t  return;\n \t}\n       _RandomAccessIterator __middle = __first + (__last - __first) / 2;\n@@ -2765,7 +2813,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       std::__merge_without_buffer(__first, __middle, __last,\n \t\t\t\t  __middle - __first,\n \t\t\t\t  __last - __middle,\n-\t\t\t\t  __comp);\n+\t\t\t\t  _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   // stable_sort\n@@ -2781,13 +2829,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     bool\n     __includes(_InputIterator1 __first1, _InputIterator1 __last1,\n \t       _InputIterator2 __first2, _InputIterator2 __last2,\n-\t       _Compare __comp)\n+\t       _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n \t{\n-\t  if (__comp(__first2, __first1))\n+\t  if (__comp(*__first2, *__first1))\n \t    return false;\n-\t  if (!__comp(__first1, __first2))\n+\t  if (!__comp(*__first1, *__first2))\n \t    ++__first2;\n \t  ++__first1;\n \t}\n@@ -2834,7 +2882,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive2(__first2, __last2);\n \n       return std::__includes(__first1, __last1, __first2, __last2,\n-\t\t\t     __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t     __gnu_cxx::__ops::__less(__first1, __first2));\n     }\n \n   /**\n@@ -2881,7 +2929,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);\n \n       return std::__includes(__first1, __last1, __first2, __last2,\n-\t\t\t     __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t     _GLIBCXX_MOVE(__comp));\n     }\n \n   // nth_element\n@@ -2898,7 +2946,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX20_CONSTEXPR\n     bool\n     __next_permutation(_BidirectionalIterator __first,\n-\t\t       _BidirectionalIterator __last, _Compare __comp)\n+\t\t       _BidirectionalIterator __last,\n+\t\t       _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__first == __last)\n \treturn false;\n@@ -2913,10 +2962,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t{\n \t  _BidirectionalIterator __ii = __i;\n \t  --__i;\n-\t  if (__comp(__i, __ii))\n+\t  if (__comp(*__i, *__ii))\n \t    {\n \t      _BidirectionalIterator __j = __last;\n-\t      while (!__comp(__i, --__j))\n+\t      while (!__comp(*__i, *(--__j)))\n \t\t{}\n \t      std::iter_swap(__i, __j);\n \t      std::__reverse(__ii, __last,\n@@ -2959,7 +3008,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       return std::__next_permutation\n-\t(__first, __last, __gnu_cxx::__ops::__iter_less_iter());\n+\t(__first, __last, __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -2993,14 +3042,15 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       return std::__next_permutation\n-\t(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t(__first, __last, _GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _BidirectionalIterator, typename _Compare>\n     _GLIBCXX20_CONSTEXPR\n     bool\n     __prev_permutation(_BidirectionalIterator __first,\n-\t\t       _BidirectionalIterator __last, _Compare __comp)\n+\t\t       _BidirectionalIterator __last,\n+\t\t       _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__first == __last)\n \treturn false;\n@@ -3015,10 +3065,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t{\n \t  _BidirectionalIterator __ii = __i;\n \t  --__i;\n-\t  if (__comp(__ii, __i))\n+\t  if (__comp(*__ii, *__i))\n \t    {\n \t      _BidirectionalIterator __j = __last;\n-\t      while (!__comp(--__j, __i))\n+\t      while (!__comp(*(--__j), *__i))\n \t\t{}\n \t      std::iter_swap(__i, __j);\n \t      std::__reverse(__ii, __last,\n@@ -3062,7 +3112,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       return std::__prev_permutation(__first, __last,\n-\t\t\t\t     __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t     __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -3096,7 +3146,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       return std::__prev_permutation(__first, __last,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t     _GLIBCXX_MOVE(__comp));\n     }\n \n   // replace\n@@ -3108,10 +3158,11 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _OutputIterator\n     __replace_copy_if(_InputIterator __first, _InputIterator __last,\n \t\t      _OutputIterator __result,\n-\t\t      _Predicate __pred, const _Tp& __new_value)\n+\t\t      _GLIBCXX_CP_FWDREF(_Predicate) __pred,\n+\t\t      const _Tp& __new_value)\n     {\n       for (; __first != __last; ++__first, (void)++__result)\n-\tif (__pred(__first))\n+\tif (__pred(*__first))\n \t  *__result = __new_value;\n \telse\n \t  *__result = *__first;\n@@ -3148,8 +3199,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__replace_copy_if(__first, __last, __result,\n-\t\t\t__gnu_cxx::__ops::__iter_equals_val(__old_value),\n-\t\t\t\t\t      __new_value);\n+\t\t\t__gnu_cxx::__ops::__equal_val(__first, __old_value),\n+\t\t\t\t    __new_value);\n     }\n \n   /**\n@@ -3184,8 +3235,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__replace_copy_if(__first, __last, __result,\n-\t\t\t\t__gnu_cxx::__ops::__pred_iter(__pred),\n-\t\t\t\t\t      __new_value);\n+\t\t\t\t    _GLIBCXX_MOVE(__pred), __new_value);\n     }\n \n #if __cplusplus >= 201103L\n@@ -3216,20 +3266,22 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     inline bool\n     is_sorted(_ForwardIterator __first, _ForwardIterator __last,\n \t      _Compare __comp)\n-    { return std::is_sorted_until(__first, __last, __comp) == __last; }\n+    {\n+      return std::is_sorted_until(__first, __last, std::move(__comp)) == __last;\n+    }\n \n   template<typename _ForwardIterator, typename _Compare>\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t      _Compare __comp)\n+\t\t      _Compare&& __comp)\n     {\n       if (__first == __last)\n \treturn __last;\n \n       _ForwardIterator __next = __first;\n       for (++__next; __next != __last; __first = __next, (void)++__next)\n-\tif (__comp(__next, __first))\n+\tif (__comp(*__next, *__first))\n \t  return __next;\n       return __next;\n     }\n@@ -3255,7 +3307,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       return std::__is_sorted_until(__first, __last,\n-\t\t\t\t    __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t    __gnu_cxx::__ops::__less());\n     }\n \n   /**\n@@ -3282,7 +3334,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       return std::__is_sorted_until(__first, __last,\n-\t\t\t\t    __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t    std::move(__comp));\n     }\n \n   /**\n@@ -3327,7 +3379,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     _GLIBCXX14_CONSTEXPR\n     pair<_ForwardIterator, _ForwardIterator>\n     __minmax_element(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t     _Compare __comp)\n+\t\t     _Compare&& __comp)\n     {\n       _ForwardIterator __next = __first;\n       if (__first == __last\n@@ -3335,7 +3387,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \treturn std::make_pair(__first, __first);\n \n       _ForwardIterator __min{}, __max{};\n-      if (__comp(__next, __first))\n+      if (__comp(*__next, *__first))\n \t{\n \t  __min = __next;\n \t  __max = __first;\n@@ -3354,25 +3406,25 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \t  __next = __first;\n \t  if (++__next == __last)\n \t    {\n-\t      if (__comp(__first, __min))\n+\t      if (__comp(*__first, *__min))\n \t\t__min = __first;\n-\t      else if (!__comp(__first, __max))\n+\t      else if (!__comp(*__first, *__max))\n \t\t__max = __first;\n \t      break;\n \t    }\n \n-\t  if (__comp(__next, __first))\n+\t  if (__comp(*__next, *__first))\n \t    {\n-\t      if (__comp(__next, __min))\n+\t      if (__comp(*__next, *__min))\n \t\t__min = __next;\n-\t      if (!__comp(__first, __max))\n+\t      if (!__comp(*__first, *__max))\n \t\t__max = __first;\n \t    }\n \t  else\n \t    {\n-\t      if (__comp(__first, __min))\n+\t      if (__comp(*__first, *__min))\n \t\t__min = __first;\n-\t      if (!__comp(__next, __max))\n+\t      if (!__comp(*__next, *__max))\n \t\t__max = __next;\n \t    }\n \n@@ -3407,7 +3459,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       return std::__minmax_element(__first, __last,\n-\t\t\t\t   __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t   __gnu_cxx::__ops::__less());\n     }\n \n   /**\n@@ -3437,7 +3489,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       return std::__minmax_element(__first, __last,\n-\t\t\t\t   __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t   std::move(__comp));\n     }\n \n   template<typename _Tp>\n@@ -3448,7 +3500,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive(__l.begin(), __l.end());\n       pair<const _Tp*, const _Tp*> __p =\n \tstd::__minmax_element(__l.begin(), __l.end(),\n-\t\t\t      __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t      __gnu_cxx::__ops::__less());\n       return std::make_pair(*__p.first, *__p.second);\n     }\n \n@@ -3460,7 +3512,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp);\n       pair<const _Tp*, const _Tp*> __p =\n \tstd::__minmax_element(__l.begin(), __l.end(),\n-\t\t\t      __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t      std::move(__comp));\n       return std::make_pair(*__p.first, *__p.second);\n     }\n \n@@ -3494,7 +3546,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_valid_range(__first1, __last1);\n \n       return std::__is_permutation(__first1, __last1, __first2,\n-\t\t\t\t   __gnu_cxx::__ops::__iter_comp_iter(__pred));\n+\t\t\t\t   std::move(__pred));\n     }\n \n #if __cplusplus > 201103L\n@@ -3506,7 +3558,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n     bool\n     __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,\n \t\t     _ForwardIterator2 __first2, _ForwardIterator2 __last2,\n-\t\t     _BinaryPredicate __pred)\n+\t\t     _BinaryPredicate&& __pred)\n     {\n       using _Cat1\n \t= typename iterator_traits<_ForwardIterator1>::iterator_category;\n@@ -3525,7 +3577,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       // have the same elements in the same order.\n       for (; __first1 != __last1 && __first2 != __last2;\n \t  ++__first1, (void)++__first2)\n-\tif (!__pred(__first1, __first2))\n+\tif (!__pred(*__first1, *__first2))\n \t  break;\n \n       if constexpr (__ra_iters)\n@@ -3546,14 +3598,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)\n \t{\n \t  if (__scan != std::__find_if(__first1, __scan,\n-\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))\n+\t\t__gnu_cxx::__ops::__equal_ite(__pred, __first1, __scan)))\n \t    continue; // We've seen this one before.\n \n \t  auto __matches = std::__count_if(__first2, __last2,\n-\t\t__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));\n+\t    __gnu_cxx::__ops::__equal_ite(__pred, __first2, __scan));\n \t  if (0 == __matches\n \t      || std::__count_if(__scan, __last1,\n-\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))\n+\t\t   __gnu_cxx::__ops::__equal_ite(__pred, __first1, __scan))\n \t      != __matches)\n \t    return false;\n \t}\n@@ -3585,7 +3637,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n \n       return\n \tstd::__is_permutation(__first1, __last1, __first2, __last2,\n-\t\t\t      __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t\t\t      __gnu_cxx::__ops::__equal_to());\n     }\n \n   /**\n@@ -3614,7 +3666,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)\n       __glibcxx_requires_valid_range(__first2, __last2);\n \n       return std::__is_permutation(__first1, __last1, __first2, __last2,\n-\t\t\t\t   __gnu_cxx::__ops::__iter_comp_iter(__pred));\n+\t\t\t\t   std::move(__pred));\n     }\n #endif // C++14\n \n@@ -3892,7 +3944,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n #endif\n \n       return std::__find_if(__first, __last,\n-\t\t\t    __gnu_cxx::__ops::__iter_equals_val(__val));\n+\t\t\t    __gnu_cxx::__ops::__equal_val(__first, __val));\n     }\n \n   /**\n@@ -3918,7 +3970,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__find_if(__first, __last,\n-\t\t\t    __gnu_cxx::__ops::__pred_iter(__pred));\n+\t\t\t    _GLIBCXX_MOVE(__pred));\n     }\n \n   /**\n@@ -4023,7 +4075,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__adjacent_find(__first, __last,\n-\t\t\t\t  __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t\t\t\t  __gnu_cxx::__ops::__equal_to(__first));\n     }\n \n   /**\n@@ -4051,7 +4103,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__adjacent_find(__first, __last,\n-\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));\n+\t\t\t\t  _GLIBCXX_MOVE(__binary_pred));\n     }\n \n   /**\n@@ -4075,7 +4127,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__count_if(__first, __last,\n-\t\t\t     __gnu_cxx::__ops::__iter_equals_val(__value));\n+\t\t\t     __gnu_cxx::__ops::__equal_val(__first, __value));\n     }\n \n   /**\n@@ -4099,7 +4151,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__count_if(__first, __last,\n-\t\t\t     __gnu_cxx::__ops::__pred_iter(__pred));\n+\t\t\t     _GLIBCXX_MOVE(__pred));\n     }\n \n   /**\n@@ -4144,7 +4196,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first2, __last2);\n \n       return std::__search(__first1, __last1, __first2, __last2,\n-\t\t\t   __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t__gnu_cxx::__ops::__equal_to(__first1, __first2));\n     }\n \n   /**\n@@ -4175,7 +4227,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__search_n(__first, __last, __count,\n-\t\t\t     __gnu_cxx::__ops::__iter_equals_val(__val));\n+\t\t\t     __gnu_cxx::__ops::__equal_val(__first, __val));\n     }\n \n \n@@ -4211,7 +4263,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n \n       return std::__search_n(__first, __last, __count,\n-\t\t__gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));\n+\t\t\t     __gnu_cxx::__ops::__comp_val\n+\t\t\t     (_GLIBCXX_MOVE(__binary_pred), __first, __val));\n     }\n \n #if __cplusplus >= 201703L\n@@ -4468,7 +4521,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       if (__first == __last)\n \treturn __result;\n       return std::__unique_copy(__first, __last, __result,\n-\t\t\t\t__gnu_cxx::__ops::__iter_equal_to_iter(),\n+\t\t\t\t__gnu_cxx::__ops::__equal_to(__first),\n \t\t\t\tstd::__iterator_category(__first));\n     }\n \n@@ -4510,7 +4563,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       if (__first == __last)\n \treturn __result;\n       return std::__unique_copy(__first, __last, __result,\n-\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__binary_pred),\n+\t\t\t\t_GLIBCXX_MOVE(__binary_pred),\n \t\t\t\tstd::__iterator_category(__first));\n     }\n \n@@ -4649,7 +4702,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \t    typename iterator_traits<_ForwardIterator>::value_type>)\n       __glibcxx_requires_valid_range(__first, __last);\n \n-      return std::__partition(__first, __last, __pred,\n+      return std::__partition(__first, __last, _GLIBCXX_MOVE(__pred),\n \t\t\t      std::__iterator_category(__first));\n     }\n \n@@ -4688,7 +4741,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       std::__partial_sort(__first, __middle, __last,\n-\t\t\t  __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t  __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -4729,7 +4782,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       std::__partial_sort(__first, __middle, __last,\n-\t\t\t  __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t  _GLIBCXX_MOVE(__comp));\n     }\n \n   /**\n@@ -4767,7 +4820,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       std::__introselect(__first, __nth, __last,\n \t\t\t std::__lg(__last - __first) * 2,\n-\t\t\t __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -4808,7 +4861,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       std::__introselect(__first, __nth, __last,\n \t\t\t std::__lg(__last - __first) * 2,\n-\t\t\t __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t _GLIBCXX_MOVE(__comp));\n     }\n \n   /**\n@@ -4838,7 +4891,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n       __glibcxx_requires_irreflexive(__first, __last);\n \n-      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());\n+      std::__sort(__first, __last, __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -4871,7 +4924,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first, __last);\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n-      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+      std::__sort(__first, __last, _GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _InputIterator1, typename _InputIterator2,\n@@ -4880,11 +4933,11 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     _OutputIterator\n     __merge(_InputIterator1 __first1, _InputIterator1 __last1,\n \t    _InputIterator2 __first2, _InputIterator2 __last2,\n-\t    _OutputIterator __result, _Compare __comp)\n+\t    _OutputIterator __result, _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n \t{\n-\t  if (__comp(__first2, __first1))\n+\t  if (__comp(*__first2, *__first1))\n \t    {\n \t      *__result = *__first2;\n \t      ++__first2;\n@@ -4944,7 +4997,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__merge(__first1, __last1,\n \t\t\t\t     __first2, __last2, __result,\n-\t\t\t\t     __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less(__first1, __first2));\n     }\n \n   /**\n@@ -4995,14 +5048,14 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__merge(__first1, __last1,\n \t\t\t\t__first2, __last2, __result,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t_GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _RandomAccessIterator, typename _Compare>\n     _GLIBCXX26_CONSTEXPR\n     inline void\n     __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,\n-\t\t  _Compare __comp)\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_RandomAccessIterator>::value_type\n \t_ValueType;\n@@ -5015,7 +5068,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n #if _GLIBCXX_HOSTED\n # if __glibcxx_constexpr_algorithms >= 202306L // >= C++26\n       if consteval {\n-\treturn std::__inplace_stable_sort(__first, __last, __comp);\n+\treturn std::__inplace_stable_sort(__first, __last,\n+\t\t\t\t\t  std::forward<_Compare>(__comp));\n       }\n # endif\n \n@@ -5027,14 +5081,18 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       if (__builtin_expect(__buf._M_requested_size() == __buf.size(), true))\n \tstd::__stable_sort_adaptive(__first,\n \t\t\t\t    __first + _DistanceType(__buf.size()),\n-\t\t\t\t    __last, __buf.begin(), __comp);\n+\t\t\t\t    __last, __buf.begin(),\n+\t\t\t\t    _GLIBCXX_FORWARD(_Compare, __comp));\n       else if (__builtin_expect(__buf.begin() == 0, false))\n-\tstd::__inplace_stable_sort(__first, __last, __comp);\n+\tstd::__inplace_stable_sort(__first, __last,\n+\t\t\t\t   _GLIBCXX_FORWARD(_Compare, __comp));\n       else\n \tstd::__stable_sort_adaptive_resize(__first, __last, __buf.begin(),\n-\t\t\t\t\t   _DistanceType(__buf.size()), __comp);\n+\t\t\t\t\t   _DistanceType(__buf.size()),\n+\t\t\t\t\t   _GLIBCXX_FORWARD(_Compare, __comp));\n #else\n-      std::__inplace_stable_sort(__first, __last, __comp);\n+      std::__inplace_stable_sort\n+\t(__first, __last, _GLIBCXX_FORWARD(_Compare, __comp));\n #endif\n     }\n \n@@ -5069,7 +5127,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       _GLIBCXX_STD_A::__stable_sort(__first, __last,\n-\t\t\t\t    __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t    __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -5106,7 +5164,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       _GLIBCXX_STD_A::__stable_sort(__first, __last,\n-\t\t\t\t    __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t    _GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _InputIterator1, typename _InputIterator2,\n@@ -5116,16 +5174,16 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     _OutputIterator\n     __set_union(_InputIterator1 __first1, _InputIterator1 __last1,\n \t\t_InputIterator2 __first2, _InputIterator2 __last2,\n-\t\t_OutputIterator __result, _Compare __comp)\n+\t\t_OutputIterator __result, _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n \t{\n-\t  if (__comp(__first1, __first2))\n+\t  if (__comp(*__first1, *__first2))\n \t    {\n \t      *__result = *__first1;\n \t      ++__first1;\n \t    }\n-\t  else if (__comp(__first2, __first1))\n+\t  else if (__comp(*__first2, *__first1))\n \t    {\n \t      *__result = *__first2;\n \t      ++__first2;\n@@ -5189,7 +5247,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_union(__first1, __last1,\n \t\t\t\t__first2, __last2, __result,\n-\t\t\t\t__gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less(__first1, __first2));\n     }\n \n   /**\n@@ -5240,7 +5298,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_union(__first1, __last1,\n \t\t\t\t__first2, __last2, __result,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t_GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _InputIterator1, typename _InputIterator2,\n@@ -5250,12 +5308,13 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     _OutputIterator\n     __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,\n \t\t       _InputIterator2 __first2, _InputIterator2 __last2,\n-\t\t       _OutputIterator __result, _Compare __comp)\n+\t\t       _OutputIterator __result,\n+\t\t       _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n-\tif (__comp(__first1, __first2))\n+\tif (__comp(*__first1, *__first2))\n \t  ++__first1;\n-\telse if (__comp(__first2, __first1))\n+\telse if (__comp(*__first2, *__first1))\n \t  ++__first2;\n \telse\n \t  {\n@@ -5311,7 +5370,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,\n \t\t\t\t     __first2, __last2, __result,\n-\t\t\t\t     __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less(__first1, __first2));\n     }\n \n   /**\n@@ -5361,7 +5420,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,\n \t\t\t\t__first2, __last2, __result,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t_GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _InputIterator1, typename _InputIterator2,\n@@ -5371,16 +5430,16 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     _OutputIterator\n     __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,\n \t\t     _InputIterator2 __first2, _InputIterator2 __last2,\n-\t\t     _OutputIterator __result, _Compare __comp)\n+\t\t     _OutputIterator __result, _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n-\tif (__comp(__first1, __first2))\n+\tif (__comp(*__first1, *__first2))\n \t  {\n \t    *__result = *__first1;\n \t    ++__first1;\n \t    ++__result;\n \t  }\n-\telse if (__comp(__first2, __first1))\n+\telse if (__comp(*__first2, *__first1))\n \t  ++__first2;\n \telse\n \t  {\n@@ -5436,7 +5495,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_difference(__first1, __last1,\n \t\t\t\t   __first2, __last2, __result,\n-\t\t\t\t   __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less(__first1, __first2));\n     }\n \n   /**\n@@ -5488,7 +5547,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_difference(__first1, __last1,\n \t\t\t\t   __first2, __last2, __result,\n-\t\t\t\t   __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t\t      _GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _InputIterator1, typename _InputIterator2,\n@@ -5501,16 +5560,16 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \t\t\t       _InputIterator2 __first2,\n \t\t\t       _InputIterator2 __last2,\n \t\t\t       _OutputIterator __result,\n-\t\t\t       _Compare __comp)\n+\t\t\t       _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__first1 != __last1 && __first2 != __last2)\n-\tif (__comp(__first1, __first2))\n+\tif (__comp(*__first1, *__first2))\n \t  {\n \t    *__result = *__first1;\n \t    ++__first1;\n \t    ++__result;\n \t  }\n-\telse if (__comp(__first2, __first1))\n+\telse if (__comp(*__first2, *__first1))\n \t  {\n \t    *__result = *__first2;\n \t    ++__first2;\n@@ -5571,7 +5630,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,\n \t\t\t\t\t__first2, __last2, __result,\n-\t\t\t\t\t__gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less(__first1, __first2));\n     }\n \n   /**\n@@ -5624,20 +5683,20 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \n       return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,\n \t\t\t\t__first2, __last2, __result,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t_GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _ForwardIterator, typename _Compare>\n     _GLIBCXX14_CONSTEXPR\n     _ForwardIterator\n     __min_element(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t  _Compare __comp)\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__first == __last)\n \treturn __first;\n       _ForwardIterator __result = __first;\n       while (++__first != __last)\n-\tif (__comp(__first, __result))\n+\tif (__comp(*__first, *__result))\n \t  __result = __first;\n       return __result;\n     }\n@@ -5662,7 +5721,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       return _GLIBCXX_STD_A::__min_element(__first, __last,\n-\t\t\t\t__gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t\t   __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -5689,19 +5748,19 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       return _GLIBCXX_STD_A::__min_element(__first, __last,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t\t   _GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _ForwardIterator, typename _Compare>\n     _GLIBCXX14_CONSTEXPR\n     _ForwardIterator\n     __max_element(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t  _Compare __comp)\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       if (__first == __last) return __first;\n       _ForwardIterator __result = __first;\n       while (++__first != __last)\n-\tif (__comp(__result, __first))\n+\tif (__comp(*__result, *__first))\n \t  __result = __first;\n       return __result;\n     }\n@@ -5726,7 +5785,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive(__first, __last);\n \n       return _GLIBCXX_STD_A::__max_element(__first, __last,\n-\t\t\t\t__gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t\t   __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -5753,7 +5812,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       return _GLIBCXX_STD_A::__max_element(__first, __last,\n-\t\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t\t   _GLIBCXX_MOVE(__comp));\n     }\n \n #if __cplusplus >= 201103L\n@@ -5765,7 +5824,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     {\n       __glibcxx_requires_irreflexive(__l.begin(), __l.end());\n       return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(),\n-\t  __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t\t    __gnu_cxx::__ops::__less());\n     }\n \n   template<typename _Tp, typename _Compare>\n@@ -5775,7 +5834,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     {\n       __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp);\n       return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(),\n-\t  __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t\t    std::move(__comp));\n     }\n \n   template<typename _Tp>\n@@ -5785,7 +5844,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     {\n       __glibcxx_requires_irreflexive(__l.begin(), __l.end());\n       return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(),\n-\t  __gnu_cxx::__ops::__iter_less_iter());\n+\t\t\t\t\t    __gnu_cxx::__ops::__less());\n     }\n \n   template<typename _Tp, typename _Compare>\n@@ -5795,7 +5854,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     {\n       __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp);\n       return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(),\n-\t  __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t\t\t\t\t    std::move(__comp));\n     }\n #endif // C++11\n \ndiff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h\nindex b104ec2536a0..a54293e0abca 100644\n--- a/libstdc++-v3/include/bits/stl_algobase.h\n+++ b/libstdc++-v3/include/bits/stl_algobase.h\n@@ -1328,7 +1328,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER\n     bool\n     __lexicographical_compare_impl(_II1 __first1, _II1 __last1,\n \t\t\t\t   _II2 __first2, _II2 __last2,\n-\t\t\t\t   _Compare __comp)\n+\t\t\t\t   _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_II1>::iterator_category _Category1;\n       typedef typename iterator_traits<_II2>::iterator_category _Category2;\n@@ -1338,9 +1338,9 @@ _GLIBCXX_END_NAMESPACE_CONTAINER\n       for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);\n \t   ++__first1, (void)++__first2)\n \t{\n-\t  if (__comp(__first1, __first2))\n+\t  if (__comp(*__first1, *__first2))\n \t    return true;\n-\t  if (__comp(__first2, __first1))\n+\t  if (__comp(*__first2, *__first1))\n \t    return false;\n \t}\n       return __first1 == __last1 && __first2 != __last2;\n@@ -1354,10 +1354,9 @@ _GLIBCXX_END_NAMESPACE_CONTAINER\n \tstatic bool\n \t__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)\n \t{\n-\t  using __gnu_cxx::__ops::__iter_less_iter;\n \t  return std::__lexicographical_compare_impl(__first1, __last1,\n \t\t\t\t\t\t     __first2, __last2,\n-\t\t\t\t\t\t     __iter_less_iter());\n+\t\t\t\t__gnu_cxx::__ops::__less(__first1, __first2));\n \t}\n \n       template<typename _II1, typename _II2>\n@@ -1501,7 +1500,8 @@ _GLIBCXX_END_NAMESPACE_CONTAINER\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __lower_bound(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t  const _Tp& __val, _Compare __comp)\n+\t\t  _GLIBCXX_FWDREF(_Tp) __val,\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_ForwardIterator>::difference_type\n \t_DistanceType;\n@@ -1513,7 +1513,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER\n \t  _DistanceType __half = __len >> 1;\n \t  _ForwardIterator __middle = __first;\n \t  std::advance(__middle, __half);\n-\t  if (__comp(__middle, __val))\n+\t  if (__comp(*__middle, __val))\n \t    {\n \t      __first = __middle;\n \t      ++__first;\n@@ -1549,7 +1549,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER\n       __glibcxx_requires_partitioned_lower(__first, __last, __val);\n \n       return std::__lower_bound(__first, __last, __val,\n-\t\t\t\t__gnu_cxx::__ops::__iter_less_val());\n+\t\t\t\t__gnu_cxx::__ops::__less_val(__first, __val));\n     }\n \n   /// This is a helper function for the sort routines and for random.tcc.\n@@ -1671,7 +1671,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     _GLIBCXX20_CONSTEXPR\n     inline bool\n     __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,\n-\t     _BinaryPredicate __binary_pred)\n+\t     _BinaryPredicate&& __binary_pred)\n     {\n       using _RATag = random_access_iterator_tag;\n       using _Cat1 = typename iterator_traits<_II1>::iterator_category;\n@@ -1682,7 +1682,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n \t  if ((__last1 - __first1) != (__last2 - __first2))\n \t    return false;\n \t  return _GLIBCXX_STD_A::equal(__first1, __last1, __first2,\n-\t\t\t\t       __binary_pred);\n+\t     std::forward<_BinaryPredicate>(__binary_pred));\n \t}\n       else\n \t{\n@@ -1756,7 +1756,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first2, __last2);\n \n       return _GLIBCXX_STD_A::__equal4(__first1, __last1, __first2, __last2,\n-\t\t\t\t      __binary_pred);\n+\t\t\t\t      std::move(__binary_pred));\n     }\n #endif // __glibcxx_robust_nonmodifying_seq_ops\n \n@@ -1823,8 +1823,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first2, __last2);\n \n       return std::__lexicographical_compare_impl\n-\t(__first1, __last1, __first2, __last2,\n-\t __gnu_cxx::__ops::__iter_comp_iter(__comp));\n+\t(__first1, __last1, __first2, __last2, _GLIBCXX_MOVE(__comp));\n     }\n \n #if __cpp_lib_three_way_comparison\n@@ -1930,9 +1929,10 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     _GLIBCXX20_CONSTEXPR\n     pair<_InputIterator1, _InputIterator2>\n     __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\n-\t       _InputIterator2 __first2, _BinaryPredicate __binary_pred)\n+\t       _InputIterator2 __first2,\n+\t       _GLIBCXX_CP_FWDREF(_BinaryPredicate) __binary_pred)\n     {\n-      while (__first1 != __last1 && __binary_pred(__first1, __first2))\n+      while (__first1 != __last1 && __binary_pred(*__first1, *__first2))\n \t{\n \t  ++__first1;\n \t  ++__first2;\n@@ -1968,7 +1968,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first1, __last1);\n \n       return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,\n-\t\t\t     __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t\t\t__gnu_cxx::__ops::__equal_to(__first1, __first2));\n     }\n \n   /**\n@@ -2000,7 +2000,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first1, __last1);\n \n       return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,\n-\t__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));\n+\t\t\t\t\t_GLIBCXX_MOVE(__binary_pred));\n     }\n \n #if __glibcxx_robust_nonmodifying_seq_ops // C++ >= 14\n@@ -2010,10 +2010,10 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n     pair<_InputIterator1, _InputIterator2>\n     __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\n \t       _InputIterator2 __first2, _InputIterator2 __last2,\n-\t       _BinaryPredicate __binary_pred)\n+\t       _BinaryPredicate&& __binary_pred)\n     {\n       while (__first1 != __last1 && __first2 != __last2\n-\t     && __binary_pred(__first1, __first2))\n+\t     && __binary_pred(*__first1, *__first2))\n \t{\n \t  ++__first1;\n \t  ++__first2;\n@@ -2051,7 +2051,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first2, __last2);\n \n       return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,\n-\t\t\t     __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t\t\t__gnu_cxx::__ops::__equal_to(__first1, __first2));\n     }\n \n   /**\n@@ -2086,7 +2086,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first2, __last2);\n \n       return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,\n-\t\t\t     __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));\n+\t\t\t\t\t_GLIBCXX_MOVE(__binary_pred));\n     }\n #endif\n \n@@ -2096,10 +2096,11 @@ _GLIBCXX_END_NAMESPACE_ALGO\n   template<typename _Iterator, typename _Predicate>\n     _GLIBCXX20_CONSTEXPR\n     inline _Iterator\n-    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)\n+    __find_if(_Iterator __first, _Iterator __last,\n+\t      _GLIBCXX_CP_FWDREF(_Predicate) __pred)\n     {\n #pragma GCC unroll 4\n-      while (__first != __last && !__pred(__first))\n+      while (__first != __last && !__pred(*__first))\n \t++__first;\n       return __first;\n     }\n@@ -2107,11 +2108,12 @@ _GLIBCXX_END_NAMESPACE_ALGO\n   template<typename _InputIterator, typename _Predicate>\n     _GLIBCXX20_CONSTEXPR\n     typename iterator_traits<_InputIterator>::difference_type\n-    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)\n+    __count_if(_InputIterator __first, _InputIterator __last,\n+\t       _GLIBCXX_CP_FWDREF(_Predicate) __pred)\n     {\n       typename iterator_traits<_InputIterator>::difference_type __n = 0;\n       for (; __first != __last; ++__first)\n-\tif (__pred(__first))\n+\tif (__pred(*__first))\n \t  ++__n;\n       return __n;\n     }\n@@ -2120,7 +2122,7 @@ _GLIBCXX_END_NAMESPACE_ALGO\n     _GLIBCXX20_CONSTEXPR\n     _ForwardIterator\n     __remove_if(_ForwardIterator __first, _ForwardIterator __last,\n-\t\t_Predicate __pred)\n+\t\t_GLIBCXX_CP_FWDREF(_Predicate) __pred)\n     {\n       __first = std::__find_if(__first, __last, __pred);\n       if (__first == __last)\n@@ -2128,7 +2130,7 @@ _GLIBCXX_END_NAMESPACE_ALGO\n       _ForwardIterator __result = __first;\n       ++__first;\n       for (; __first != __last; ++__first)\n-\tif (!__pred(__first))\n+\tif (!__pred(*__first))\n \t  {\n \t    *__result = _GLIBCXX_MOVE(*__first);\n \t    ++__result;\n@@ -2142,7 +2144,7 @@ _GLIBCXX_END_NAMESPACE_ALGO\n     _ForwardIterator1\n     __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,\n \t     _ForwardIterator2 __first2, _ForwardIterator2 __last2,\n-\t     _BinaryPredicate  __predicate)\n+\t     _GLIBCXX_CP_FWDREF(_BinaryPredicate)  __predicate)\n     {\n       // Test for empty ranges\n       if (__first1 == __last1 || __first2 == __last2)\n@@ -2151,18 +2153,22 @@ _GLIBCXX_END_NAMESPACE_ALGO\n       // Test for a pattern of length 1.\n       _ForwardIterator2 __p1(__first2);\n       if (++__p1 == __last2)\n-\treturn std::__find_if(__first1, __last1,\n-\t\t__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));\n+\t{\n+\t  return std::__find_if(__first1, __last1,\n+\t     __gnu_cxx::__ops::__equal_ite(_GLIBCXX_FORWARD(_BinaryPredicate,\n+\t\t\t\t\t\t\t    __predicate),\n+\t\t\t\t\t   __first1, __first2));\n+\t}\n \n       // General case.\n       _ForwardIterator1 __current = __first1;\n \n+      __decltype(__gnu_cxx::__ops::__equal_ite(__predicate, __first1, __first2))\n+\t__unry_pred = __gnu_cxx::__ops::__equal_ite(__predicate,\n+\t\t\t\t\t\t    __first1, __first2);\n       for (;;)\n \t{\n-\t  __first1 =\n-\t    std::__find_if(__first1, __last1,\n-\t\t__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));\n-\n+\t  __first1 = std::__find_if(__first1, __last1, __unry_pred);\n \t  if (__first1 == __last1)\n \t    return __last1;\n \n@@ -2171,7 +2177,7 @@ _GLIBCXX_END_NAMESPACE_ALGO\n \t  if (++__current == __last1)\n \t    return __last1;\n \n-\t  while (__predicate(__current, __p))\n+\t  while (__predicate(*__current, *__p))\n \t    {\n \t      if (++__p == __last2)\n \t\treturn __first1;\n@@ -2194,7 +2200,7 @@ _GLIBCXX_END_NAMESPACE_ALGO\n       // Efficiently compare identical prefixes:  O(N) if sequences\n       // have the same elements in the same order.\n       for (; __first1 != __last1; ++__first1, (void)++__first2)\n-\tif (!__pred(__first1, __first2))\n+\tif (!__pred(*__first1, *__first2))\n \t  break;\n \n       if (__first1 == __last1)\n@@ -2207,15 +2213,15 @@ _GLIBCXX_END_NAMESPACE_ALGO\n       for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)\n \t{\n \t  if (__scan != std::__find_if(__first1, __scan,\n-\t\t\t  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))\n+\t\t__gnu_cxx::__ops::__equal_ite(__pred, __first1, __scan)))\n \t    continue; // We've seen this one before.\n \n \t  auto __matches\n \t    = std::__count_if(__first2, __last2,\n-\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));\n+\t\t__gnu_cxx::__ops::__equal_ite(__pred, __first2, __scan));\n \t  if (0 == __matches ||\n \t      std::__count_if(__scan, __last1,\n-\t\t\t__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))\n+\t\t__gnu_cxx::__ops::__equal_ite(__pred, __first1, __scan))\n \t      != __matches)\n \t    return false;\n \t}\n@@ -2249,7 +2255,7 @@ _GLIBCXX_END_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first1, __last1);\n \n       return std::__is_permutation(__first1, __last1, __first2,\n-\t\t\t\t   __gnu_cxx::__ops::__iter_equal_to_iter());\n+\t\t\t\t   __gnu_cxx::__ops::__equal_to());\n     }\n #endif // C++11\n \n@@ -2294,7 +2300,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO\n       __glibcxx_requires_valid_range(__first2, __last2);\n \n       return std::__search(__first1, __last1, __first2, __last2,\n-\t\t\t   __gnu_cxx::__ops::__iter_comp_iter(__predicate));\n+\t\t\t   _GLIBCXX_MOVE(__predicate));\n     }\n \n _GLIBCXX_END_NAMESPACE_ALGO\ndiff --git a/libstdc++-v3/include/bits/stl_heap.h b/libstdc++-v3/include/bits/stl_heap.h\nindex 028ac83eeb70..18326c7115b5 100644\n--- a/libstdc++-v3/include/bits/stl_heap.h\n+++ b/libstdc++-v3/include/bits/stl_heap.h\n@@ -74,12 +74,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     _Distance\n     __is_heap_until(_RandomAccessIterator __first, _Distance __n,\n-\t\t    _Compare& __comp)\n+\t\t    _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       _Distance __parent = 0;\n       for (_Distance __child = 1; __child < __n; ++__child)\n \t{\n-\t  if (__comp(__first + __parent, __first + __child))\n+\t  if (__comp(__first[__parent], __first[__child]))\n \t    return __child;\n \t  if ((__child & 1) == 0)\n \t    ++__parent;\n@@ -94,19 +94,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     inline bool\n     __is_heap(_RandomAccessIterator __first, _Distance __n)\n     {\n-      __gnu_cxx::__ops::_Iter_less_iter __comp;\n-      return std::__is_heap_until(__first, __n, __comp) == __n;\n+      return std::__is_heap_until\n+\t(__first, __n, __gnu_cxx::__ops::__less(__first)) == __n;\n     }\n \n   template<typename _RandomAccessIterator, typename _Compare,\n \t   typename _Distance>\n     _GLIBCXX20_CONSTEXPR\n     inline bool\n-    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)\n+    __is_heap(_RandomAccessIterator __first,\n+\t      _GLIBCXX_CP_FWDREF(_Compare) __comp,\n+\t      _Distance __n)\n     {\n-      typedef __decltype(__comp) _Cmp;\n-      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));\n-      return std::__is_heap_until(__first, __n, __cmp) == __n;\n+      return std::__is_heap_until\n+\t(__first, __n, _GLIBCXX_FORWARD(_Compare, __comp)) == __n;\n     }\n \n   template<typename _RandomAccessIterator>\n@@ -119,9 +120,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     inline bool\n     __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,\n-\t      _Compare __comp)\n+\t      _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n-      return std::__is_heap(__first, _GLIBCXX_MOVE(__comp),\n+      return std::__is_heap(__first, _GLIBCXX_FORWARD(_Compare, __comp),\n \t\t\t    std::distance(__first, __last));\n     }\n \n@@ -133,17 +134,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     void\n     __push_heap(_RandomAccessIterator __first,\n-\t\t_Distance __holeIndex, _Distance __topIndex, _Tp __value,\n-\t\t_Compare& __comp)\n+\t\t_Distance __holeIndex, _Distance __topIndex,\n+\t\t_GLIBCXX_CP_FWDREF(_Tp) __value,\n+\t\t_GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       _Distance __parent = (__holeIndex - 1) / 2;\n-      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))\n+      while (__holeIndex > __topIndex && __comp(__first[__parent], __value))\n \t{\n \t  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));\n \t  __holeIndex = __parent;\n \t  __parent = (__holeIndex - 1) / 2;\n \t}\n-      *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);\n+      *(__first + __holeIndex) = _GLIBCXX_FORWARD(_Tp, __value);\n     }\n \n   /**\n@@ -174,8 +176,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_irreflexive(__first, __last);\n       __glibcxx_requires_heap(__first, __last - 1);\n \n-      __gnu_cxx::__ops::_Iter_less_val __comp;\n       _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));\n+      __decltype(__gnu_cxx::__ops::__less_val(__first, __value)) __comp =\n+\t__gnu_cxx::__ops::__less_val(__first, __value);\n       std::__push_heap(__first, _DistanceType((__last - __first) - 1),\n \t\t       _DistanceType(0), _GLIBCXX_MOVE(__value), __comp);\n     }\n@@ -210,11 +213,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n       __glibcxx_requires_heap_pred(__first, __last - 1, __comp);\n \n-      __decltype(__gnu_cxx::__ops::__iter_comp_val(_GLIBCXX_MOVE(__comp)))\n-\t__cmp(_GLIBCXX_MOVE(__comp));\n       _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));\n       std::__push_heap(__first, _DistanceType((__last - __first) - 1),\n-\t\t       _DistanceType(0), _GLIBCXX_MOVE(__value), __cmp);\n+\t\t       _DistanceType(0), _GLIBCXX_MOVE(__value),\n+\t\t       _GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _RandomAccessIterator, typename _Distance,\n@@ -222,15 +224,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     void\n     __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,\n-\t\t  _Distance __len, _Tp __value, _Compare __comp)\n+\t\t  _Distance __len,\n+\t\t  _GLIBCXX_CP_FWDREF(_Tp) __value,\n+\t\t  _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       const _Distance __topIndex = __holeIndex;\n       _Distance __secondChild = __holeIndex;\n       while (__secondChild < (__len - 1) / 2)\n \t{\n \t  __secondChild = 2 * (__secondChild + 1);\n-\t  if (__comp(__first + __secondChild,\n-\t\t     __first + (__secondChild - 1)))\n+\t  if (__comp(__first[__secondChild],\n+\t\t     __first[__secondChild - 1]))\n \t    __secondChild--;\n \t  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));\n \t  __holeIndex = __secondChild;\n@@ -242,17 +246,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t\t\t\t\t\t     + (__secondChild - 1)));\n \t  __holeIndex = __secondChild - 1;\n \t}\n-      __decltype(__gnu_cxx::__ops::__iter_comp_val(_GLIBCXX_MOVE(__comp)))\n-\t__cmp(_GLIBCXX_MOVE(__comp));\n+\n+      __decltype(__gnu_cxx::__ops::__less_val\n+\t\t (_GLIBCXX_FORWARD(_Compare, __comp), __first, __value)) __cmp\n+\t= __gnu_cxx::__ops::__less_val\n+\t(_GLIBCXX_FORWARD(_Compare, __comp), __first, __value);\n       std::__push_heap(__first, __holeIndex, __topIndex,\n-\t\t       _GLIBCXX_MOVE(__value), __cmp);\n+\t\t       _GLIBCXX_FORWARD(_Tp, __value),\n+\t\t       _GLIBCXX_MOVE(__cmp));\n     }\n \n   template<typename _RandomAccessIterator, typename _Compare>\n     _GLIBCXX20_CONSTEXPR\n     inline void\n     __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,\n-\t       _RandomAccessIterator __result, _Compare& __comp)\n+\t       _RandomAccessIterator __result,\n+\t       _GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_RandomAccessIterator>::value_type\n \t_ValueType;\n@@ -263,7 +272,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       *__result = _GLIBCXX_MOVE(*__first);\n       std::__adjust_heap(__first, _DistanceType(0),\n \t\t\t _DistanceType(__last - __first),\n-\t\t\t _GLIBCXX_MOVE(__value), __comp);\n+\t\t_GLIBCXX_MOVE(__value), _GLIBCXX_FORWARD(_Compare, __comp));\n     }\n \n   /**\n@@ -295,8 +304,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       if (__last - __first > 1)\n \t{\n \t  --__last;\n-\t  __gnu_cxx::__ops::_Iter_less_iter __comp;\n-\t  std::__pop_heap(__first, __last, __last, __comp);\n+\t  std::__pop_heap(__first, __last, __last,\n+\t\t\t  __gnu_cxx::__ops::__less(__first));\n \t}\n     }\n \n@@ -327,10 +336,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \n       if (__last - __first > 1)\n \t{\n-\t  typedef __decltype(__comp) _Cmp;\n-\t  __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));\n \t  --__last;\n-\t  std::__pop_heap(__first, __last, __last, __cmp);\n+\t  std::__pop_heap(__first, __last, __last, _GLIBCXX_MOVE(__comp));\n \t}\n     }\n \n@@ -338,7 +345,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     _GLIBCXX20_CONSTEXPR\n     void\n     __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,\n-\t\t_Compare& __comp)\n+\t\t_GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       typedef typename iterator_traits<_RandomAccessIterator>::value_type\n \t  _ValueType;\n@@ -382,8 +389,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n       __glibcxx_requires_irreflexive(__first, __last);\n \n-      __gnu_cxx::__ops::_Iter_less_iter __comp;\n-      std::__make_heap(__first, __last, __comp);\n+      std::__make_heap(__first, __last, __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -408,16 +414,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n-      typedef __decltype(__comp) _Cmp;\n-      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));\n-      std::__make_heap(__first, __last, __cmp);\n+      std::__make_heap(__first, __last, _GLIBCXX_MOVE(__comp));\n     }\n \n   template<typename _RandomAccessIterator, typename _Compare>\n     _GLIBCXX20_CONSTEXPR\n     void\n     __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,\n-\t\t_Compare& __comp)\n+\t\t_GLIBCXX_CP_FWDREF(_Compare) __comp)\n     {\n       while (__last - __first > 1)\n \t{\n@@ -448,8 +452,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_irreflexive(__first, __last);\n       __glibcxx_requires_heap(__first, __last);\n \n-      __gnu_cxx::__ops::_Iter_less_iter __comp;\n-      std::__sort_heap(__first, __last, __comp);\n+      std::__sort_heap(__first, __last, __gnu_cxx::__ops::__less(__first));\n     }\n \n   /**\n@@ -475,9 +478,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n       __glibcxx_requires_heap_pred(__first, __last, __comp);\n \n-      typedef __decltype(__comp) _Cmp;\n-      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));\n-      std::__sort_heap(__first, __last, __cmp);\n+      std::__sort_heap(__first, __last, _GLIBCXX_MOVE(__comp));\n     }\n \n #if __cplusplus >= 201103L\n@@ -504,9 +505,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n       __glibcxx_requires_irreflexive(__first, __last);\n \n-      __gnu_cxx::__ops::_Iter_less_iter __comp;\n       return __first +\n-\tstd::__is_heap_until(__first, std::distance(__first, __last), __comp);\n+\tstd::__is_heap_until(__first, std::distance(__first, __last),\n+\t\t\t     __gnu_cxx::__ops::__less());\n     }\n \n   /**\n@@ -532,10 +533,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_valid_range(__first, __last);\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n-      typedef __decltype(__comp) _Cmp;\n-      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));\n       return __first\n-\t+ std::__is_heap_until(__first, std::distance(__first, __last), __cmp);\n+\t+ std::__is_heap_until(__first, std::distance(__first, __last),\n+\t\t\t       std::move(__comp));\n     }\n \n   /**\n@@ -572,11 +572,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       __glibcxx_requires_irreflexive_pred(__first, __last, __comp);\n \n       const auto __dist = std::distance(__first, __last);\n-      typedef __decltype(__comp) _Cmp;\n-      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));\n-      return std::__is_heap_until(__first, __dist, __cmp) == __dist;\n+      return std::__is_heap_until(__first, __dist,\n+\t\t\t\t  std::move(__comp)) == __dist;\n     }\n-#endif\n+#endif // C++11\n \n _GLIBCXX_END_NAMESPACE_VERSION\n } // namespace\ndiff --git a/libstdc++-v3/include/std/deque b/libstdc++-v3/include/std/deque\nindex 2badab80a6dc..6b977998b20a 100644\n--- a/libstdc++-v3/include/std/deque\n+++ b/libstdc++-v3/include/std/deque\n@@ -66,7 +66,7 @@\n #include <bits/stl_construct.h>\n #include <bits/stl_uninitialized.h>\n #include <bits/stl_deque.h>\n-#include <bits/refwrap.h>\n+#include <bits/move.h>\n #include <bits/range_access.h>\n #include <bits/deque.tcc>\n \n@@ -104,12 +104,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     inline typename deque<_Tp, _Alloc>::size_type\n     erase_if(deque<_Tp, _Alloc>& __cont, _Predicate __pred)\n     {\n-      using namespace __gnu_cxx;\n       _GLIBCXX_STD_C::deque<_Tp, _Alloc>& __ucont = __cont;\n       const auto __osz = __cont.size();\n       const auto __end = __ucont.end();\n       auto __removed = std::__remove_if(__ucont.begin(), __end,\n-\t\t\t\t\t__ops::__pred_iter(std::ref(__pred)));\n+\t\t\t\t\tstd::move(__pred));\n       if (__removed != __end)\n \t{\n \t  __cont.erase(__niter_wrap(__cont.begin(), __removed),\n@@ -130,7 +129,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       const auto __osz = __cont.size();\n       const auto __end = __ucont.end();\n       auto __removed = std::__remove_if(__ucont.begin(), __end,\n-\t\t\t\t\t__ops::__iter_equals_val(__value));\n+\t\t\t\t\t__ops::__equal_val(__value));\n       if (__removed != __end)\n \t{\n \t  __cont.erase(__niter_wrap(__cont.begin(), __removed),\ndiff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional\nindex 5b329daf184e..db86f1131c4d 100644\n--- a/libstdc++-v3/include/std/functional\n+++ b/libstdc++-v3/include/std/functional\n@@ -75,6 +75,9 @@\n #if _GLIBCXX_HOSTED\n # include <bits/std_function.h>\t// std::function\n #endif\n+#if __cplusplus >= 201402L\n+# include <bits/predefined_ops.h> // std::_Not_fn\n+#endif\n #if __cplusplus >= 201703L\n # if _GLIBCXX_HOSTED\n #  include <unordered_map>\n@@ -965,57 +968,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n #endif // __cpp_lib_bind_back\n \n #if __cplusplus >= 201402L\n-  /// Generalized negator.\n-  template<typename _Fn>\n-    class _Not_fn\n-    {\n-      template<typename _Fn2, typename... _Args>\n-\tusing __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type;\n-\n-      template<typename _Tp>\n-\tstatic decltype(!std::declval<_Tp>())\n-\t_S_not() noexcept(noexcept(!std::declval<_Tp>()));\n-\n-    public:\n-      template<typename _Fn2>\n-\tconstexpr\n-\t_Not_fn(_Fn2&& __fn, int)\n-\t: _M_fn(std::forward<_Fn2>(__fn)) { }\n-\n-      _Not_fn(const _Not_fn& __fn) = default;\n-      _Not_fn(_Not_fn&& __fn) = default;\n-      ~_Not_fn() = default;\n-\n-      // Macro to define operator() with given cv-qualifiers ref-qualifiers,\n-      // forwarding _M_fn and the function arguments with the same qualifiers,\n-      // and deducing the return type and exception-specification.\n-#define _GLIBCXX_NOT_FN_CALL_OP( _QUALS )\t\t\t\t\\\n-      template<typename... _Args,\t\t\t\t\t\\\n-\t       typename = enable_if_t<__is_invocable<_Fn _QUALS, _Args...>::value>> \\\n-\t_GLIBCXX20_CONSTEXPR\t\t\t\t\t\t\\\n-\tdecltype(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>())\t\t\\\n-\toperator()(_Args&&... __args) _QUALS\t\t\t\t\\\n-\tnoexcept(__is_nothrow_invocable<_Fn _QUALS, _Args...>::value\t\\\n-\t    && noexcept(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>()))\t\\\n-\t{\t\t\t\t\t\t\t\t\\\n-\t  return !std::__invoke(std::forward< _Fn _QUALS >(_M_fn),\t\\\n-\t\t\t\tstd::forward<_Args>(__args)...);\t\\\n-\t}\t\t\t\t\t\t\t\t\\\n-\t\t\t\t\t\t\t\t\t\\\n-      template<typename... _Args,\t\t\t\t\t\\\n-\t       typename = enable_if_t<!__is_invocable<_Fn _QUALS, _Args...>::value>> \\\n-\tvoid operator()(_Args&&... __args) _QUALS = delete;\n-\n-      _GLIBCXX_NOT_FN_CALL_OP( & )\n-      _GLIBCXX_NOT_FN_CALL_OP( const & )\n-      _GLIBCXX_NOT_FN_CALL_OP( && )\n-      _GLIBCXX_NOT_FN_CALL_OP( const && )\n-#undef _GLIBCXX_NOT_FN_CALL_OP\n-\n-    private:\n-      _Fn _M_fn;\n-    };\n-\n   template<typename _Tp, typename _Pred>\n     struct __is_byte_like : false_type { };\n \ndiff --git a/libstdc++-v3/include/std/inplace_vector b/libstdc++-v3/include/std/inplace_vector\nindex b5a81bed3c98..f3aea9119430 100644\n--- a/libstdc++-v3/include/std/inplace_vector\n+++ b/libstdc++-v3/include/std/inplace_vector\n@@ -42,7 +42,6 @@\n #include <bits/ranges_base.h> // borrowed_iterator_t, __detail::__container_compatible_range\n #include <bits/ranges_util.h> // subrange\n #include <bits/ranges_uninitialized.h>\n-#include <bits/refwrap.h>\n #include <bits/stl_construct.h>\n #include <bits/stl_uninitialized.h>\n #include <bits/stl_algo.h> // rotate\n@@ -1339,11 +1338,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     constexpr size_t\n     erase_if(inplace_vector<_Tp, _Nm>& __cont, _Predicate __pred)\n     {\n-      using namespace __gnu_cxx;\n       const auto __osz = __cont.size();\n       const auto __end = __cont.end();\n       auto __removed = std::__remove_if(__cont.begin(), __end,\n-\t\t\t\t\t__ops::__pred_iter(std::ref(__pred)));\n+\t\t\t\t\tstd::move(__pred));\n       if (__removed != __end)\n \t{\n \t  __cont.erase(__niter_wrap(__cont.begin(), __removed),\n@@ -1362,7 +1360,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       const auto __osz = __cont.size();\n       const auto __end = __cont.end();\n       auto __removed = std::__remove_if(__cont.begin(), __end,\n-\t\t\t\t\t__ops::__iter_equals_val(__value));\n+\t\t\t\t\t__ops::__equal_val(__value));\n       if (__removed != __end)\n \t{\n \t  __cont.erase(__niter_wrap(__cont.begin(), __removed),\ndiff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string\nindex 71864715ff75..e6e0f284e077 100644\n--- a/libstdc++-v3/include/std/string\n+++ b/libstdc++-v3/include/std/string\n@@ -51,7 +51,7 @@\n #include <bits/stl_function.h> // For less\n #include <ext/numeric_traits.h>\n #include <bits/stl_algobase.h>\n-#include <bits/refwrap.h>\n+#include <bits/move.h>\n #include <bits/range_access.h>\n #include <bits/basic_string.h>\n #include <bits/basic_string.tcc>\n@@ -100,11 +100,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     inline typename basic_string<_CharT, _Traits, _Alloc>::size_type\n     erase_if(basic_string<_CharT, _Traits, _Alloc>& __cont, _Predicate __pred)\n     {\n-      using namespace __gnu_cxx;\n       const auto __osz = __cont.size();\n       const auto __end = __cont.end();\n       auto __removed = std::__remove_if(__cont.begin(), __end,\n-\t\t\t\t\t__ops::__pred_iter(std::ref(__pred)));\n+\t\t\t\t\tstd::move(__pred));\n       __cont.erase(__removed, __end);\n       return __osz - __cont.size();\n     }\n@@ -119,7 +118,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       const auto __osz = __cont.size();\n       const auto __end = __cont.end();\n       auto __removed = std::__remove_if(__cont.begin(), __end,\n-\t\t\t\t\t__ops::__iter_equals_val(__value));\n+\t\t\t\t\t__ops::__equal_val(__value));\n       __cont.erase(__removed, __end);\n       return __osz - __cont.size();\n     }\ndiff --git a/libstdc++-v3/include/std/vector b/libstdc++-v3/include/std/vector\nindex a98ffb179ec0..73f27cd2bd4c 100644\n--- a/libstdc++-v3/include/std/vector\n+++ b/libstdc++-v3/include/std/vector\n@@ -67,7 +67,7 @@\n #include <bits/stl_uninitialized.h>\n #include <bits/stl_vector.h>\n #include <bits/stl_bvector.h>\n-#include <bits/refwrap.h>\n+#include <bits/move.h>\n #include <bits/range_access.h>\n \n #ifndef _GLIBCXX_EXPORT_TEMPLATE\n@@ -117,12 +117,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n     inline typename vector<_Tp, _Alloc>::size_type\n     erase_if(vector<_Tp, _Alloc>& __cont, _Predicate __pred)\n     {\n-      using namespace __gnu_cxx;\n       _GLIBCXX_STD_C::vector<_Tp, _Alloc>& __ucont = __cont;\n       const auto __osz = __cont.size();\n       const auto __end = __ucont.end();\n       auto __removed = std::__remove_if(__ucont.begin(), __end,\n-\t\t\t\t\t__ops::__pred_iter(std::ref(__pred)));\n+\t\t\t\t\tstd::move(__pred));\n       if (__removed != __end)\n \t{\n \t  __cont.erase(__niter_wrap(__cont.begin(), __removed),\n@@ -144,7 +143,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n       const auto __osz = __cont.size();\n       const auto __end = __ucont.end();\n       auto __removed = std::__remove_if(__ucont.begin(), __end,\n-\t\t\t\t\t__ops::__iter_equals_val(__value));\n+\t\t\t\t\t__ops::__equal_val(__value));\n       if (__removed != __end)\n \t{\n \t  __cont.erase(__niter_wrap(__cont.begin(), __removed),\ndiff --git a/libstdc++-v3/src/c++17/memory_resource.cc b/libstdc++-v3/src/c++17/memory_resource.cc\nindex c61569f249ad..d4398b52a700 100644\n--- a/libstdc++-v3/src/c++17/memory_resource.cc\n+++ b/libstdc++-v3/src/c++17/memory_resource.cc\n@@ -26,6 +26,7 @@\n #include <algorithm>\t\t\t// lower_bound, rotate\n #include <atomic>\n #include <bit>\t\t\t\t// has_single_bit, bit_ceil, bit_width\n+#include <functional>\t\t\t// less_equal\n #include <new>\n #include <bits/move.h>\t\t\t// std::__exchange\n #if ATOMIC_POINTER_LOCK_FREE != 2\ndiff --git a/libstdc++-v3/testsuite/25_algorithms/inplace_merge/1.cc b/libstdc++-v3/testsuite/25_algorithms/inplace_merge/1.cc\nindex 84f4e337f8b1..a4bcef166c84 100644\n--- a/libstdc++-v3/testsuite/25_algorithms/inplace_merge/1.cc\n+++ b/libstdc++-v3/testsuite/25_algorithms/inplace_merge/1.cc\n@@ -21,6 +21,7 @@\n // { dg-require-effective-target hosted }\n \n #include <algorithm>\n+#include <vector>\n #include <testsuite_hooks.h>\n #include <testsuite_iterators.h>\n #include <testsuite_new_operators.h>\n@@ -119,6 +120,17 @@ test4()\n     }\n }\n \n+bool bs[] = { false, false, true, false, true, true };\n+std::vector<bool> v(6);\n+\n+void\n+test5()\n+{\n+  v.assign(bs, bs + 6);\n+  inplace_merge(v.begin(), v.begin() + 3, v.end());\n+  VERIFY( !v[0] && !v[1] && !v[2] && v[3] && v[4] && v[5] );\n+}\n+\n int \n main()\n {\n@@ -129,14 +141,17 @@ main()\n   __gnu_test::set_new_limit(sizeof(S) * 4);\n   test3();\n   test4();\n+  test5();\n \n   __gnu_test::set_new_limit(sizeof(S));\n   test3();\n   test4();\n+  test5();\n \n   __gnu_test::set_new_limit(0);\n   test3();\n   test4();\n+  test5();\n \n   return 0;\n }\ndiff --git a/libstdc++-v3/testsuite/25_algorithms/stable_sort/1.cc b/libstdc++-v3/testsuite/25_algorithms/stable_sort/1.cc\nindex 73d8dffbdf9b..8fb8aca4af32 100644\n--- a/libstdc++-v3/testsuite/25_algorithms/stable_sort/1.cc\n+++ b/libstdc++-v3/testsuite/25_algorithms/stable_sort/1.cc\n@@ -84,6 +84,26 @@ test3()\n     VERIFY(array[i].j == i % 2);\n }\n \n+struct NotConstLess\n+{\n+  bool\n+  operator()(S& s1, S& s2)\n+  { return s1.i < s2.i; }\n+};\n+\n+void\n+test4()\n+{\n+#if __cplusplus >= 201103L\n+  NotConstLess less;\n+  S array[] = { -1, -2, 1, 2, -3 ,-5 ,3 , -4, 5, 4 };\n+  test_container<S, random_access_iterator_wrapper> con(array,array + 10);\n+  stable_sort(con.begin(), con.end(), less);\n+  for(int i = 0; i < 10; ++i)\n+    VERIFY(array[i].j == i % 2);\n+#endif\n+}\n+\n int \n main()\n {\n@@ -91,13 +111,17 @@ main()\n   test2();\n \n   test3();\n+  test4();\n \n   __gnu_test::set_new_limit(sizeof(S) * 5);\n   test3();\n+  test4();\n \n   __gnu_test::set_new_limit(sizeof(S));\n   test3();\n+  test4();\n \n   __gnu_test::set_new_limit(0);\n   test3();\n+  test4();\n }\n",
    "prefixes": [
        "v1",
        "1/1"
    ]
}