27.8 Sorting and related operations [alg.sorting] C++N4910:2022 (662) p1223.cpp

# はじめに(Introduction)
N4910  Working Draft, Standard for Programming Language C++
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf

n4910は、ISO/IEC JTC1 SC22 WG21の作業原案(Working Draft)です。
公式のISO/IEC 14882原本ではありません。
ISO/IEC JTC1 SC22 WG21では、可能な限り作業文書を公開し、幅広い意見を求めています。
一連の記事はコード断片をコンパイルできる形にする方法を検討してコンパイル、リンク、実行して、規格案の原文と処理系(g++, Clang++)との違いを確認し、技術内容を検討し、ISO/IEC JTC1 SC22 WG21にフィードバックするために用います。
また、CERT C++, MISRA C++等のコーディング標準のコード断片をコンパイルする際の参考にさせていただこうと考えています。CERT C++, MISRA C++が標準化の動きとの時間的なずれがあれば確認できれば幸いです。また、boostライブラリとの関連、Linux OS, TOPPERSカーネル、g++(GCC), clang++(LLVM）との関係も調査中です。
何か、抜け漏れ、耳より情報がありましたらおしらせくださると幸いです。

 <この項は書きかけです。順次追記します。>

## 背景(back ground)
C/C++でコンパイルエラーが出ると、途方にくれることがしばしばあります。
何回かに１回は、該当するエラーが検索できます。
ただ、条件が違っていて、そこでの修正方法では目的を達成しないこともしばしばです。いろいろな条件のコンパイルエラーとその対応方法について、広く記録することによって、いつか同じエラーに遭遇した時にやくに立つことを目指しています。

この半年の間で、三度、自分のネットでの記録に助けられたことがあります。
また過去に解決できなかった記録を１０種類以上、最近になって解決できたことがあります。それは、主に次の３つの情報に基づいています。

https://stackoverflow.com

http://ja.cppreference.com/

cpprefjp - C++日本語リファレンス

https://cpprefjp.github.io/

コンパイラの実装状況

https://cpprefjp.github.io/implementation-status.html

また
https://researchmap.jp/joub9b3my-1797580/#_1797580
に記載したサイトのお世話になっています。

## 作業方針(sequence)
Clang++では-std=c++03, C++2bの2種類
g++では-std=c++03, c++2bの２種類
でコンパイルし、

１）コンパイルエラーを収集する。
２）コンパイルエラーをなくす方法を検討する。
コンパイルエラーになる例を示すだけが目的のコードは、コンパイルエラーをなくすのではなく、コンパイルエラーの種類を収集するだけにする。
文法を示すのが目的のコード場合に、コンパイルエラーをなくすのに手間がかかる場合は、順次作業します。
３）リンクエラーをなくす方法を検討する。
文法を示すのが目的のコード場合に、リンクエラーをなくすのに手間がかかる場合は、順次作業します。
４）意味のある出力を作る。
コンパイル、リンクが通っても、意味のある出力を示そうとすると、コンパイル・リンクエラーが出て収拾できそうにない場合がある。順次作業します。

１）だけのものから４）まで進んだものと色々ある状態です。一歩でも前に進むご助言をお待ちしています。「検討事項」の欄に現状を記録するようにしています。

### C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list  

https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

### C++N4741, 2018 Standard Working Draft on ISO/IEC 14882 sample code compile list
https://qiita.com/kaizen_nagoya/items/3294c014044550896010

### C++N4606, 2016符号断片編纂一覧(example code compile list)
C++N4606, 2016 Working Draft 2016, ISO/IEC 14882, C++ standard(1) Example code compile list
https://qiita.com/kaizen_nagoya/items/df5d62c35bd6ed1c3d43/

### C++N3242, 2011 sample code compile list on clang++ and g++
https://qiita.com/kaizen_nagoya/items/685b5c1a2c17c1bf1318

## 編纂器(Compiler)
### clang++ --version
> Debian clang version 14.0.5-++20220610033153+c12386ae247c-1~exp1~20220610153237.151
Target: x86_64-pc-linux-gnu, Thread model: posix, InstalledDir: /usr/bin

### g++- --version
> g++ (GCC) 12.1.0  Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

#  27.8 Sorting and related operations [alg.sorting] C++N4910:2022 (662) p1223.cpp

## 算譜(source code)

```c++:p1223.cpp
// C++N4910 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf
const char * n4910 = "27.8 Sorting and related operations [alg.sorting] C++N4910:2022 (662) p1223.cpp";
// Debian clang version 14.0.5-++20220610033153+c12386ae247c-
// g++ (GCC) 12.1.0 Copyright (C) 2022 Free Software Foundation, Inc.
// Edited by Dr. OGAWA Kiyoshi. Compile procedure and results record.
// C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list
// https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

#include "N4910.h"

using namespace std;

#define R int
// 27.8.1 General [alg.sorting.general]
//  The operations in 27.8 defined directly in namespace std have two versions: one that takes a function object of type Compare and one that uses an operator<.
//  Compare is a function object type (22.10) that meets the requirements for a template parameter named BinaryPredicate (27.2). The return value of the function call operation applied to an object of type Compare, when contextually converted to bool (7.3), yields true if the first argument of the call is less than the second, and false otherwise. Compare comp is used throughout for algorithms assuming an ordering relation.
//   For all algorithms that take Compare, there is a version that uses operator< instead. That is, comp(*i, *j) != false defaults to *i < *j != false. For algorithms other than those described in 27.8.4, comp shall induce a strict weak ordering on the values.
//  The term strict refers to the requirement of an irreflexive relation (!comp(x, x) for all x), and the term weak to requirements that are not as strong as those for a total ordering, but stronger than those for a partial ordering. If we define equiv(a, b) as !comp(a, b) && !comp(b, a), then the requirements are that comp and equiv both be transitive relations:
// — equiv(a, b) && equiv(b, c) implies equiv(a, c) [Note 1: Under these conditions, it can be shown that
//— comp(a, b) && comp(b, c) implies comp(a, c)
// — equiv is an equivalence relation,
// — comp induces a well-defined relation on the equivalence classes determined by equiv, and — the induced relation is a strict total ordering.
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: For the overloads in namespace std, RandomAccessIterator meets the Cpp17Value- Swappable requirements (16.4.4.3) and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Effects: Sorts the elements in the range [first, last) with respect to comp and proj. Returns: last for the overloads in namespace ranges.
Complexity: Let N be last - first. O(N log N) comparisons and projections.
//  A sequence is sorted with respect to a comp and proj for a comparator and projection comp and proj if for every iterator i pointing to the sequence and every non-negative integer n such that i + n is a valid iterator pointing to an element of the sequence,
     bool(invoke(comp, invoke(proj, *(i + n)), invoke(proj, *i)))
is false.
//  A sequence [start, finish) is partitioned with respect to an expression f(e) if there exists an integer n such
thatforall0 <= i < (finish - start),f(*(start + i))istrueifandonlyifi < n.
//  In the descriptions of the functions that deal with ordering relationships we frequently use a notion of equivalence to describe concepts such as stability. The equivalence to which we refer is not necessarily an operator==, but an equivalence relation induced by the strict weak ordering. That is, two elements a and b are considered equivalent if and only if !(a < b) && !(b < a).
// 27.8.2.1 sort
template<class RandomAccessIterator>
constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator>
void sort(ExecutionPolicy&& exec,
          RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void sort(RandomAccessIterator first, RandomAccessIterator last,
                    Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void sort(ExecutionPolicy&& exec,
          RandomAccessIterator first, RandomAccessIterator last,
          Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
[alg.sort] [sort]
requires sortable<iterator_t<R>, Comp, Proj>
constexpr borrowed_iterator_t<R>
ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
// 27.8.2.2 stable_sort [stable.sort]
template<class RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator>
void stable_sort(ExecutionPolicy&& exec,
                 RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                 Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void stable_sort(ExecutionPolicy&& exec,
                 RandomAccessIterator first, RandomAccessIterator last,
                 Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
borrowed_iterator_t<R>
ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: For the overloads in namespace std, RandomAccessIterator meets the Cpp17Value- Swappable requirements (16.4.4.3) and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Effects: Sorts the elements in the range [first, last) with respect to comp and proj.
// Returns: last for the overloads in namespace ranges.
// Complexity: Let N be last - first. If enough extra memory is available, N log(N) comparisons. Otherwise, at most N log2(N) comparisons. In either case, twice as many projections as the number of comparisons.
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: [first, middle) and [middle, last) are valid ranges. For the overloads in namespace std, RandomAccessIterator meets the Cpp17ValueSwappable requirements (16.4.4.3) and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Remarks: Stable (16.4.6.8).
// 7.8.2.3 partial_sort [partial.sort]
template<class RandomAccessIterator>
constexpr void partial_sort(RandomAccessIterator first,
                            RandomAccessIterator middle,
                            RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator>
void partial_sort(ExecutionPolicy&& exec,
                  RandomAccessIterator first,
                  RandomAccessIterator middle,
                  RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void partial_sort(RandomAccessIterator first,
                            RandomAccessIterator middle,
                            RandomAccessIterator last,
                            Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void partial_sort(ExecutionPolicy&& exec,
                  RandomAccessIterator first,
                  RandomAccessIterator middle,
                  RandomAccessIterator last,
                  Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
// Effects: Places the first middle - first elements from the range [first, last) as sorted with respect to comp and proj into the range [first, middle). The rest of the elements in the range [middle, last) are placed in an unspecified order.
// Returns: last for the overload in namespace ranges.
// Complexity: Approximately (last - first) * log(middle - first) comparisons, and twice as many projections.
class Proj1 = identity, class Proj2 = identity>
                                              requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
                                              sortable<iterator_t<R2>, Comp, Proj2> &&
                                              indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
                                              projected<iterator_t<R2>, Proj2>>
                                              constexpr ranges::partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
                                              ranges::partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
Proj1 proj1 = {}, Proj2 proj2 = {});
// Let N be min(last - first, result_last - result_first). Let comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names.
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
constexpr borrowed_iterator_t<R>
ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
// Effects: Equivalent to:
return ranges::partial_sort(ranges::begin(r), middle, ranges::end(r), comp, proj);
// 27.8.2.4 partial_sort_copy [partial.sort.copy]
template<class InputIterator, class RandomAccessIterator>
constexpr RandomAccessIterator
partial_sort_copy(InputIterator first, InputIterator last,
                  RandomAccessIterator result_first,
                  RandomAccessIterator result_last);
template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator>
RandomAccessIterator
partial_sort_copy(ExecutionPolicy&& exec,
                  ForwardIterator first, ForwardIterator last,
                  RandomAccessIterator result_first,
                  RandomAccessIterator result_last);
template<class InputIterator, class RandomAccessIterator,
         class Compare>
constexpr RandomAccessIterator
partial_sort_copy(InputIterator first, InputIterator last,
                  RandomAccessIterator result_first,
                  RandomAccessIterator result_last,
                  Compare comp);
template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator,
         class Compare>
RandomAccessIterator
partial_sort_copy(ExecutionPolicy&& exec,
                  ForwardIterator first, ForwardIterator last,
                  RandomAccessIterator result_first,
                  RandomAccessIterator result_last,
                  Compare comp);
template<input_iterator I1, sentinel_for<I1> S1, random_access_iterator I2, sentinel_for<I2> S2,
         class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
        constexpr ranges::partial_sort_copy_result<I1, I2>
        ranges::partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
                                  Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, random_access_range R2, class Comp = ranges::less,
// Mandates: For the overloads in namespace std, the expression *first is writable (25.3.1) to result_- first.
// Preconditions: For the overloads in namespace std, RandomAccessIterator meets the Cpp17Value- Swappable requirements (16.4.4.3), the type of *result_first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// For iterators a1 and b1 in [first, last), and iterators x2 and y2 in [result_first, result_last), after evaluating the assignment *y2 = *b1, let E be the value of
         bool(invoke(comp, invoke(proj1, *a1), invoke(proj2, *y2))).
// Then, after evaluating the assignment *x2 = *a1, E is equal to bool(invoke(comp, invoke(proj2, *x2), invoke(proj2, *y2))).
// [Note 1: Writing a value from the input range into the output range does not affect how it is ordered by comp and proj1 or proj2. —end note]
// Effects: Places the first N elements as sorted with respect to comp and proj2 into the range [result_- first,result_first + N).
// Returns:
// — result_first + N for the overloads in namespace std.
// — {last, result_first + N} for the overloads in namespace ranges.
// Complexity: Approximately (last - first) * log N comparisons, and twice as many projections.
// 27.8.2.5 is_sorted template<class ForwardIterator>
         [is.sorted]
         constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);
Effects:
Equivalent to:
return is_sorted_until(first, last) == last;
template<class ExecutionPolicy, class ForwardIterator>
bool is_sorted(ExecutionPolicy&& exec,
               ForwardIterator first, ForwardIterator last);
// Effects: Equivalent to:
return is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last) == last;
template<class ForwardIterator, class Compare>
constexpr bool is_sorted(ForwardIterator first, ForwardIterator last,
                         Compare comp);
// Effects: Equivalent to: return is_sorted_until(first, last, comp) == last;
template<class ExecutionPolicy, class ForwardIterator, class Compare>
bool is_sorted(ExecutionPolicy&& exec,
               ForwardIterator first, ForwardIterator last,
               Compare comp);
// Effects: Equivalent to:
return is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last;
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
template<forward_range R, class Proj = identity,
         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
// Effects: Equivalent to: return ranges::is_sorted_until(first, last, comp, proj) == last;
template<class ForwardIterator>
constexpr ForwardIterator
is_sorted_until(ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator
is_sorted_until(ExecutionPolicy&& exec,
                ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
constexpr ForwardIterator
is_sorted_until(ForwardIterator first, ForwardIterator last,
                Compare comp);
template<class ExecutionPolicy, class ForwardIterator, class Compare>
ForwardIterator
is_sorted_until(ExecutionPolicy&& exec,
                ForwardIterator first, ForwardIterator last,
                Compare comp);
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
template<forward_range R, class Proj = identity,
         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
constexpr borrowed_iterator_t<R>
ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names. Returns: The last iterator i in [first, last] for which the range [first, i) is sorted with respect to comp and proj. Complexity: Linear.
requires sortable<I, Comp, Proj>
constexpr I
ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: [first,nth) and [nth,last) are valid ranges. For the overloads in namespace std, RandomAccessIterator meets the Cpp17ValueSwappable requirements (16.4.4.3), and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) require-
ments.
// Effects: After nth_element the element in the position pointed to by nth is the element that would be in that position if the whole range were sorted with respect to comp and proj, unless nth == last. Also for every iterator i in the range [first, nth) and every iterator j in the range [nth, last) it holds that: bool(invoke(comp, invoke(proj, *j), invoke(proj, *i))) is false.
// 27.8.3 Nth element [alg.nth.element]
template<class RandomAccessIterator>
constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                           RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator>
void nth_element(ExecutionPolicy&& exec,
                 RandomAccessIterator first, RandomAccessIterator nth,
                 RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                           RandomAccessIterator last,  Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void nth_element(ExecutionPolicy&& exec,
                 RandomAccessIterator first, RandomAccessIterator nth,
                 RandomAccessIterator last, Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
// Returns: last for the overload in namespace ranges.
ranges::less>
constexpr borrowed_iterator_t<R>
ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for overloads with no parameters by those names. Preconditions: The elements e of [first, last) are partitioned with respect to the expression
bool(invoke(comp, invoke(proj, e), value)).
// Returns: The furthermost iterator i in the range [first,last] such that for every iterator j in the range [first, i), bool(invoke(comp, invoke(proj, *j), value)) is true. // Complexity: At most log2(last - first) + O(1) comparisons and projections.
// Complexity: For the overloads with no ExecutionPolicy, linear on average. For the overloads with an ExecutionPolicy, O(N) applications of the predicate, and O(N logN) swaps, where N = last - first.
//  All of the algorithms in 27.8.4 are versions of binary search and assume that the sequence being searched is partitioned with respect to an expression formed by binding the search key to an argument of the comparison function. They work on non-random access iterators minimizing the number of comparisons, which will be logarithmic for all types of iterators. They are especially appropriate for random access iterators, because these algorithms do a logarithmic number of steps through the data structure. For non-random access iterators they execute a linear number of steps.
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
constexpr borrowed_iterator_t<R>
ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
// Effects: Equivalent to:
return ranges::nth_element(ranges::begin(r), nth, ranges::end(r), comp, proj);
// 27.8.4 Binary search [alg.binary.search]
// 27.8.4.1 General [alg.binary.search.general]
// 27.8.4.2 lower_bound [lower.bound]
template<class ForwardIterator, class T>
constexpr ForwardIterator
lower_bound(ForwardIterator first, ForwardIterator last,
            const T& value);
template<class ForwardIterator, class T, class Compare>
constexpr ForwardIterator
lower_bound(ForwardIterator first, ForwardIterator last,
            const T& value, Compare comp);
template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
constexpr I ranges::lower_bound(I first, S last, const T& value, Comp comp = {},
                                Proj proj = {});
template<forward_range R, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
// 27.8.4.3 upper_bound [upper.bound]
         template<class ForwardIterator, class T>
         constexpr ForwardIterator
         upper_bound(ForwardIterator first, ForwardIterator last,
                     const T& value);
template<class ForwardIterator, class T, class Compare>
constexpr ForwardIterator
upper_bound(ForwardIterator first, ForwardIterator last,
            const T& value, Compare comp);
ranges::less>
constexpr borrowed_subrange_t<R>
ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for overloads with no parameters by those names.
// Preconditions: The elements e of [first,last) are partitioned with respect to the expressions bool(invoke(comp, invoke(proj, e), value)) and !bool(invoke(comp, value, invoke(proj, e))). Also, for all elements e of [first, last), bool(comp(e, value)) implies !bool(comp(value, e)) for the overloads in namespace std.
// Returns: — For the overloads in namespace std:
{   lower_bound(first, last, value, comp),
    upper_bound(first, last, value, comp)
}
// — For the overloads in namespace ranges: {ranges::lower_bound(first, last, value, comp, proj),
ranges::upper_bound(first, last, value, comp, proj)
}
// Complexity: At most 2 ∗ log2(last - first) + O(1) comparisons and projections.
template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
template<forward_range R, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
         ranges::less>
constexpr borrowed_iterator_t<R>
ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for overloads with no parameters by those names. Preconditions: The elements e of [first, last) are partitioned with respect to the expression
!bool(invoke(comp, value, invoke(proj, e))).
// Returns: The furthermost iterator i in the range [first,last] such that for every iterator j in the range [first, i), !bool(invoke(comp, value, invoke(proj, *j))) is true. Complexity: At most log2(last - first) + O(1) comparisons and projections.
// 27.8.4.4 equal_range [equal.range]
template<class ForwardIterator, class T>
constexpr pair<ForwardIterator, ForwardIterator>
equal_range(ForwardIterator first,
            ForwardIterator last, const T& value);
template<class ForwardIterator, class T, class Compare>
constexpr pair<ForwardIterator, ForwardIterator>
equal_range(ForwardIterator first,
            ForwardIterator last, const T& value,
            Compare comp);
template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
constexpr subrange<I>
ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
template<forward_range R, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
// 27.8.4.5 binary_search [binary.search]
         template<class ForwardIterator, class T>
         constexpr bool
         binary_search(ForwardIterator first, ForwardIterator last,
                       const T& value);
template<class ForwardIterator, class T, class Compare>
constexpr bool
binary_search(ForwardIterator first, ForwardIterator last,
              const T& value, Compare comp);
template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
constexpr bool ranges::binary_search(I first, S last, const T& value, Comp comp = {},
                                     Proj proj = {});
template<forward_range R, class T, class Proj = identity,
         indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
         ranges::less>
constexpr bool ranges::binary_search(R&& r, const T& value, Comp comp = {},
                                     Proj proj = {});
// Let comp be less{} and proj be identity{} for overloads with no parameters by those names.
// Preconditions: The elements e of [first,last) are partitioned with respect to the expressions bool(invoke(comp, invoke(proj, e), value)) and !bool(invoke(comp, value, invoke(proj, e))). Also, for all elements e of [first, last), bool(comp(e, value)) implies !bool(comp(value, e)) for the overloads in namespace std.
// Returns: true if and only if for some iterator i in the range [first,last), !bool(invoke(comp, invoke(proj, *i), value)) && !bool(invoke(comp, value, invoke(proj, *i))) is true.
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
        constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {});
// Let proj be identity{} for the overloads with no parameter named proj.
// Returns: true if and only if the elements e of [first,last) are partitioned with respect to the expression bool(invoke(pred, invoke(proj, e))).
// Complexity: Linear. At most last - first applications of pred and proj.
// Complexity: At most log2(last - first) + O(1) comparisons and projections.
// 27.8.5 Partitions [alg.partitions]
template<class InputIterator, class Predicate>
constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate>
bool is_partitioned(ExecutionPolicy&& exec,
                    ForwardIterator first, ForwardIterator last, Predicate pred);
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});
template<input_range R, class Proj = identity,
         template<class ForwardIterator, class Predicate>
         constexpr ForwardIterator
         partition(ForwardIterator first, ForwardIterator last, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate>
ForwardIterator
partition(ExecutionPolicy&& exec,
          ForwardIterator first, ForwardIterator last, Predicate pred);
template<permutable I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr subrange<I>
ranges::partition(I first, S last, Pred pred, Proj proj = {});
template<forward_range R, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
requires permutable<iterator_t<R>>
constexpr borrowed_subrange_t<R>
ranges::partition(R&& r, Pred pred, Proj proj = {});
// Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
// Preconditions: For the overloads in namespace std, ForwardIterator meets the Cpp17ValueSwappable requirements (16.4.4.3).
// Effects: Places all the elements e in [first,last) that satisfy E(e) before all the elements that do not. Returns: Let i be an iterator such that E(*j) is true for every iterator j in [first,i) and false for every iterator j in [i, last).
// Returns: — i for the overloads in namespace std.
// — {i, last} for the overloads in namespace ranges.
// Complexity: Let N = last - first:
// — For the overload with no ExecutionPolicy, exactly N applications of the predicate and projection. At most N/2 swaps if the type of first meets the Cpp17BidirectionalIterator requirements for the overloads in namespace std or models bidirectional_iterator for the overloads in namespace ranges, and at most N swaps otherwise.
// — For the overload with an ExecutionPolicy, O(N logN) swaps and O(N) applications of the predicate.
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
        requires permutable<iterator_t<R>>
        borrowed_subrange_t<R> ranges::stable_partition(R&& r, Pred pred, Proj proj = {});
Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
// Preconditions: For the overloads in namespace std, BidirectionalIterator meets the Cpp17Value- Swappable requirements (16.4.4.3) and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Effects: Places all the elements e in [first,last) that satisfy E(e) before all the elements that do not. The relative order of the elements in both groups is preserved.
// Returns: Let i be an iterator such that for every iterator j in [first,i), E(*j) is true, and for every iterator j in the range [i,last), E(*j) is false. Returns:
// — i for the overloads in namespace std.
// — {i, last} for the overloads in namespace ranges. Complexity: Let N = last - first:
// — For the overloads with no ExecutionPolicy, at most N log N swaps, but only O (N ) swaps if there is enough extra memory. Exactly N applications of the predicate and projection.
// — For the overload with an ExecutionPolicy, O(N logN) swaps and O(N) applications of the predicate.
    template<class BidirectionalIterator, class Predicate>
    BidirectionalIterator
    stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred);
template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
BidirectionalIterator
stable_partition(ExecutionPolicy&& exec,
                 BidirectionalIterator first, BidirectionalIterator last, Predicate pred);
template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
requires permutable<I>
subrange<I> ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
template<bidirectional_range R, class Proj = identity,
         template<class InputIterator, class OutputIterator1, class OutputIterator2, class Predicate>
         constexpr pair<OutputIterator1, OutputIterator2>
         partition_copy(InputIterator first, InputIterator last,
                        OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
         class ForwardIterator2, class Predicate>
pair<ForwardIterator1, ForwardIterator2>
partition_copy(ExecutionPolicy&& exec,
               ForwardIterator first, ForwardIterator last,
               ForwardIterator1 out_true, ForwardIterator2 out_false, Predicate pred);
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O1, weakly_incrementable O2,
         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
constexpr ranges::partition_copy_result<I, O1, O2>
ranges::partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
                       Proj proj = {});
template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
         class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
requires indirectly_copyable<iterator_t<R>, O1> &&
indirectly_copyable<iterator_t<R>, O2>
constexpr ranges::partition_copy_result<borrowed_iterator_t<R>, O1, O2>
ranges::partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
// Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
// Mandates: For the overloads in namespace std, the expression *first is writable (25.3.1) to out_true and out_false.
// Preconditions: The input range and output ranges do not overlap.
// [Note 1: For the overload with an ExecutionPolicy, there might be a performance cost if first’s value type does not meet the Cpp17CopyConstructible requirements.
// Effects: For each iterator i in [first, last), copies *i to the output range beginning with out_true if E(*i) is true, or to the output range beginning with out_false otherwise.
// Returns: Let o1 be the end of the output range beginning at out_true, and o2 the end of the output range beginning at out_false. Returns
// — {o1, o2} for the overloads in namespace std.
// — {last, o1, o2} for the overloads in namespace ranges.
// Complexity: Exactly last - first applications of pred and proj.
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
        constexpr borrowed_iterator_t<R>
        ranges::partition_point(R&& r, Pred pred, Proj proj = {});
// Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
// Preconditions: The elements e of [first,last) are partitioned with respect to E(e).
// Returns: An iterator mid such that E(*i) is true for all iterators i in [first,mid), and false for all iterators i in [mid, last).
// Complexity: O(log(last - first)) applications of pred and proj.
template<class ForwardIterator, class Predicate>
constexpr ForwardIterator
partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr I ranges::partition_point(I first, S last, Pred pred, Proj proj = {});
template<forward_range R, class Proj = identity,
// 27.8.6 Merge [alg.merge]
         template<class InputIterator1, class InputIterator2,
                  class OutputIterator>
         constexpr OutputIterator
         merge(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, InputIterator2 last2,
               OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator>
ForwardIterator
merge(ExecutionPolicy&& exec,
      ForwardIterator1 first1, ForwardIterator1 last1,
      ForwardIterator2 first2, ForwardIterator2 last2,
      ForwardIterator result);
template<class InputIterator1, class InputIterator2,
         class OutputIterator, class Compare>
constexpr OutputIterator
merge(InputIterator1 first1, InputIterator1 last1,
      InputIterator2 first2, InputIterator2 last2,
      OutputIterator result, Compare comp);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator, class Compare>
ForwardIterator
merge(ExecutionPolicy&& exec,
      ForwardIterator1 first1, ForwardIterator1 last1,
      ForwardIterator2 first2, ForwardIterator2 last2,
      ForwardIterator result, Compare comp);
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
         class Proj2 = identity>
requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
constexpr ranges::merge_result<I1, I2, O>
ranges::merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
         class Proj1 = identity, class Proj2 = identity>
requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
constexpr ranges::merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
ranges::merge(R1&& r1, R2&& r2, O result,
              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
// Let N be (last1 - first1) + (last2 - first2). Let comp be less{}, proj1 be identity{}, and proj2 be identity{}, for the overloads with no parameters by those names.
// Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively. The resulting range does not overlap with either of the original ranges.
// Effects: Copies all the elements of the two ranges [first1, last1) and [first2, last2) into the range [result,result_last), where result_last is result + N. If an element a precedes b in an input range, a is copied into the output range before b. If e1 is an element of [first1,last1) and e2 of [first2,last2), e2 is copied into the output range before e1 if and only if bool(invoke(comp, invoke(proj2, e2), invoke(proj1, e1))) is true.
// Returns: — result_last for the overloads in namespace std.
// — {last1, last2, result_last} for the overloads in namespace ranges.
// Complexity :— For the overloads with no ExecutionPolicy, at most N // − 1 comparisons and applications of each projection.
// — For the overloads with an ExecutionPolicy, O(N) comparisons.
// Remarks: Stable (16.4.6.8).
template<class BidirectionalIterator>
void inplace_merge(BidirectionalIterator first,
                   BidirectionalIterator middle,
                   BidirectionalIterator last);
template<class ExecutionPolicy, class BidirectionalIterator>
void inplace_merge(ExecutionPolicy&& exec,
                   BidirectionalIterator first,
                   BidirectionalIterator middle,
                   BidirectionalIterator last);
template<class BidirectionalIterator, class Compare>
void inplace_merge(BidirectionalIterator first,
                   BidirectionalIterator middle,
                   BidirectionalIterator last, Compare comp);
template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
void inplace_merge(ExecutionPolicy&& exec,
                   BidirectionalIterator first,
                   BidirectionalIterator middle,
                   BidirectionalIterator last, Compare comp);
template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: [first,middle) and [middle,last) are valid ranges sorted with respect to comp and proj. For the overloads in namespace std, BidirectionalIterator meets the Cpp17ValueSwappable requirements (16.4.4.3) and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Effects: Merges two sorted consecutive ranges [first, middle) and [middle, last), putting the result of the merge into the range [first, last). The resulting range is sorted with respect to comp and proj. Returns: last for the overload in namespace ranges.
// Complexity: Let N = last - first:
// — For the overloads with no ExecutionPolicy, and if enough additional memory is available, exactly N − 1 comparisons.
// — Otherwise, O(N logN) comparisons.
// In either case, twice as many projections as comparisons. Remarks: Stable (16.4.6.8).
// Subclause 27.8.7 defines all the basic set operations on sorted structures. They also work with multisets (24.4.7) containing multiple copies of equivalent elements. The semantics of the set operations are generalized to multisets in a standard way by defining set_union to contain the maximum number of occurrences of every element, set_intersection to contain the minimum, and so on.
// 27.8.7.2 includes [includes]
template<class InputIterator1, class InputIterator2>
constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
                        template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
                        requires sortable<iterator_t<R>, Comp, Proj>
                        borrowed_iterator_t<R>
                        ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
// Effects: Equivalent to:
                        return ranges::inplace_merge(ranges::begin(r), middle, ranges::end(r), comp, proj);
// 27.8.7 Set operations on sorted structures [alg.set.operations]
// 27.8.7.1 General [alg.set.operations.general]
                        InputIterator2 first2, InputIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
bool includes(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
template<class InputIterator1, class InputIterator2, class Compare>
constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        Compare comp);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Compare>
bool includes(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              Compare comp);
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         class Proj1 = identity, class Proj2 = identity,
         indirect_strict_weak_order<projected<I1, Proj1>,
                                    projected<I2, Proj2>> Comp = ranges::less>
constexpr bool ranges::includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, class Proj1 = identity,
         class Proj2 = identity,
         indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                    projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
// Let comp be less{}, proj1 be identity{}, and proj2 be identity{}, for the overloads with no parameters by those names.
// Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively.
// Returns: true if and only if [first2, last2) is a subsequence of [first1, last1).
// [Note 1: A sequence S is a subsequence of another sequence T if S can be obtained from T by removing some, all, or none of T’s elements and keeping the remaining elements in the same order.
// Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applica-tions of each projection.
// 27.8.7.3 set_union [set.union]
template<class InputIterator1, class InputIterator2, class OutputIterator>
constexpr OutputIterator
set_union(InputIterator1 first1, InputIterator1 last1,
          InputIterator2 first2, InputIterator2 last2,
          OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator>
ForwardIterator
set_union(ExecutionPolicy&& exec,
          ForwardIterator1 first1, ForwardIterator1 last1,
          ForwardIterator2 first2, ForwardIterator2 last2,
          ForwardIterator result);
template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
constexpr OutputIterator
set_union(InputIterator1 first1, InputIterator1 last1,
          InputIterator2 first2, InputIterator2 last2,
          OutputIterator result, Compare comp);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator, class Compare>
ForwardIterator
set_union(ExecutionPolicy&& exec,
          ForwardIterator1 first1, ForwardIterator1 last1,
          ForwardIterator2 first2, ForwardIterator2 last2,
          ForwardIterator result, Compare comp);
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         weakly_incrementable O, class Comp = ranges::less,
         class Proj1 = identity, class Proj2 = identity>
requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
constexpr ranges::set_union_result<I1, I2, O>
ranges::set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, weakly_incrementable O,
         class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
constexpr ranges::set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
ranges::set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
// Let comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names.
// Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively. The resulting range does not overlap with either of the original ranges.
// Effects: Constructs a sorted union of the elements from the two ranges; that is, the set of elements that are present in one or both of the ranges.
// Returns: Let result_last be the end of the constructed range. Returns
// — result_last for the overloads in namespace std.
// — {last1, last2, result_last} for the overloads in namespace ranges.
// Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applica- tions of each projection.
// Remarks: Stable (16.4.6.8). If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, then all m elements from the first range are copied to the output range, in order, and then the final max(n − m, 0) elements from the second range are copied to the output range, in order.
// 27.8.7.4 set_intersection [set.intersection]
template<class InputIterator1, class InputIterator2,
         class OutputIterator>
constexpr OutputIterator
set_intersection(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, InputIterator2 last2,
                 OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator>
ForwardIterator
set_intersection(ExecutionPolicy&& exec,
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 ForwardIterator result);
template<class InputIterator1, class InputIterator2,
         class OutputIterator, class Compare>
constexpr OutputIterator
set_intersection(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, InputIterator2 last2,
                 OutputIterator result, Compare comp);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator, class Compare>
ForwardIterator
set_intersection(ExecutionPolicy&& exec,
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
                 constexpr ranges::set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
                 ranges::set_intersection(R1&& r1, R2&& r2, O result,
                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
// Let comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names.
// Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively. The resulting range does not overlap with either of the original ranges.
// Effects: Constructs a sorted intersection of the elements from the two ranges; that is, the set of elements that are present in both of the ranges.
// Returns: Let result_last be the end of the constructed range. Returns
// — result_last for the overloads in namespace std.
// — {last1, last2, result_last} for the overloads in namespace ranges.
// Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applica- tions of each projection.
// Remarks: Stable (16.4.6.8). If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, the first min(m, n) elements are copied from the first range to the output range, in order.
                 ForwardIterator result, Compare comp);
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         weakly_incrementable O, class Comp = ranges::less,
         class Proj1 = identity, class Proj2 = identity>
requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
constexpr ranges::set_intersection_result<I1, I2, O>
ranges::set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, weakly_incrementable O,
         class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
// 27.8.7.5 set_difference [set.difference]
template<class InputIterator1, class InputIterator2,
         class OutputIterator>
constexpr OutputIterator
set_difference(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, InputIterator2 last2,
               OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator>
ForwardIterator
set_difference(ExecutionPolicy&& exec,
               ForwardIterator1 first1, ForwardIterator1 last1,
               ForwardIterator2 first2, ForwardIterator2 last2,
               ForwardIterator result);
template<class InputIterator1, class InputIterator2,
         class OutputIterator, class Compare>
constexpr OutputIterator
set_difference(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, InputIterator2 last2,
               OutputIterator result, Compare comp);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator, class Compare>
ForwardIterator
set_difference(ExecutionPolicy&& exec,
               ForwardIterator1 first1, ForwardIterator1 last1,
               ForwardIterator2 first2, ForwardIterator2 last2,
               ForwardIterator result, Compare comp);
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         weakly_incrementable O, class Comp = ranges::less,
         class Proj1 = identity, class Proj2 = identity>
requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
constexpr ranges::set_difference_result<I1, O>
ranges::set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, weakly_incrementable O,
         class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
constexpr ranges::set_difference_result<borrowed_iterator_t<R1>, O>
ranges::set_difference(R1&& r1, R2&& r2, O result,
                       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
// Let comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names.
// Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively. The resulting range does not overlap with either of the original ranges.
// Effects: Copies the elements of the range [first1, last1) which are not present in the range [first2, last2) to the range beginning at result. The elements in the constructed range are sorted.
// Returns: Let result_last be the end of the constructed range. Returns // — result_last for the overloads in namespace std.
// — {last1, result_last} for the overloads in namespace ranges.
// Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applica- tions of each projection.
// Remarks: If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, the last max(m − n, 0) elements from [first1, last1) is copied to the output range, in order.
// 27.8.7.6 set_symmetric_difference [set.symmetric.difference]
template<class InputIterator1, class InputIterator2,
         class OutputIterator>
constexpr OutputIterator
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator>
ForwardIterator
set_symmetric_difference(ExecutionPolicy&& exec,
                         ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2, ForwardIterator2 last2,
                         ForwardIterator result);
template<class InputIterator1, class InputIterator2,
         class OutputIterator, class Compare>
constexpr OutputIterator
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator result, Compare comp);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator, class Compare>
ForwardIterator
set_symmetric_difference(ExecutionPolicy&& exec,
                         ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2, ForwardIterator2 last2,
                         ForwardIterator result, Compare comp);
// — With N = b - a, for all i, 0 < i < N, bool(invoke(comp, invoke(proj, a[􏰅i−1􏰆]), invoke( proj, a[i]))) is false.
// — *a may be removed by pop_heap, or a new element added by push_heap, in O(logN) time.
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         weakly_incrementable O, class Comp = ranges::less,
         class Proj1 = identity, class Proj2 = identity>
requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
constexpr ranges::set_symmetric_difference_result<I1, I2, O>
ranges::set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                                 Comp comp = {}, Proj1 proj1 = {},
                                 Proj2 proj2 = {});
template<input_range R1, input_range R2, weakly_incrementable O,
         class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
constexpr ranges::set_symmetric_difference_result<borrowed_iterator_t<R1>,
        borrowed_iterator_t<R2>, O>
ranges::set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});
// Let comp be less{}, and proj1 and proj2 be identity{} for the overloads with no parameters by those names.
// Preconditions: The ranges [first1, last1) and [first2, last2) are sorted with respect to comp and proj1 or proj2, respectively. The resulting range does not overlap with either of the original ranges.
// Effects: Copies the elements of the range [first1, last1) that are not present in the range [first2, last2), and the elements of the range [first2, last2) that are not present in the range [first1, last1) to the range beginning at result. The elements in the constructed range are sorted.
// Returns: Let result_last be the end of the constructed range. Returns
// — result_last for the overloads in namespace std.
// — {last1, last2, result_last} for the overloads in namespace ranges.
// Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applica- tions of each projection.
// Remarks: Stable (16.4.6.8). If [first1, last1) contains m elements that are equivalent to each other and [first2, last2) contains n elements that are equivalent to them, then |m − n| of those elements shall be copied to the output range: the last m − n of these elements from [first1, last1) if m > n, and the last n − m of these elements from [first2, last2) if m < n. In either case, the elements are copied in order.
//  A random access range [a, b) is a heap with respect to comp and proj for a comparator and projection comp and proj if its elements are organized such that:
// 27.8.8 Heap operations [alg.heap.operations]
// 27.8.8.1 General [alg.heap.operations.general]
// These properties make heaps useful as priority queues.
//  make_heap converts a range into a heap and sort_heap turns a heap into a sorted sequence.
// 27.8.8.2 push_heap [push.heap]
template<class RandomAccessIterator>
constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
constexpr borrowed_iterator_t<R>
ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: The range [first, last - 1) is a valid heap with respect to comp and proj. For the overloads in namespace std, the type of *first meets the Cpp17MoveConstructible requirements
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: The range [first,last) is a valid non-empty heap with respect to comp and proj. For the overloads in namespace std, RandomAccessIterator meets the Cpp17ValueSwappable re- quirements (16.4.4.3) and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Effects: Swaps the value in the location first with the value in the location last - 1 and makes
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// (Table 30) and the Cpp17MoveAssignable requirements (Table 32).
// Effects: Places the value in the location last - 1 into the resulting heap [first, last). Returns: last for the overloads in namespace ranges.
// Complexity: At most log(last - first) comparisons and twice as many projections.
// 27.8.8.3 pop_heap [pop.heap]
template<class RandomAccessIterator>
constexpr void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                        Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
constexpr borrowed_iterator_t<R>
ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
// [first, last - 1) into a heap with respect to comp and proj.
// Returns: last for the overloads in namespace ranges.
// Complexity: At most 2log(last - first) comparisons and twice as many projections.
// 27.8.8.4 make_heap [make.heap]
template<class RandomAccessIterator>
constexpr void make_heap(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void make_heap(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
constexpr borrowed_iterator_t<R>
ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
// Preconditions: For the overloads in namespace std, the type of *first meets the Cpp17Move- Constructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Effects: Constructs a heap with respect to comp and proj out of the range [first, last). Returns: last for the overloads in namespace ranges.
// Complexity: At most 3(last - first) comparisons and twice as many projections.
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
// Preconditions: The range [first, last) is a valid heap with respect to comp and proj. For the overloads in namespace std, RandomAccessIterator meets the Cpp17ValueSwappable requirements (16.4.4.3) and the type of *first meets the Cpp17MoveConstructible (Table 30) and Cpp17MoveAssignable (Table 32) requirements.
// Effects: Sorts elements in the heap [first, last) with respect to comp and proj.
// Returns: last for the overloads in namespace ranges.
// Complexity: At most 2N log N comparisons, where N = last - first, and twice as many projections.
// 27.8.8.5 sort_heap [sort.heap]
template<class RandomAccessIterator>
constexpr void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
constexpr borrowed_iterator_t<R>
ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
// 27.8.8.6 is_heap [is.heap]
template<class RandomAccessIterator>
constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
// Effects: Equivalent to: return is_heap_until(first, last) == last;
template<class ExecutionPolicy, class RandomAccessIterator>
bool is_heap(ExecutionPolicy&& exec,
             RandomAccessIterator first, RandomAccessIterator last);
// Effects: Equivalent to:
return is_heap_until(std::forward<ExecutionPolicy>(exec), first, last) == last;
template<class RandomAccessIterator, class Compare>
constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
// Effects: Equivalent to: return is_heap_until(first, last, comp) == last;
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
bool is_heap(ExecutionPolicy&& exec, RandomAccessIterator first, RandomAccessIterator last, Compare comp);
// Effects: Equivalent to:
return is_heap_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last;
template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr bool ranges::is_heap(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Proj = identity,
         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
// Effects: Equivalent to: return ranges::is_heap_until(first, last, comp, proj) == last;
indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
        constexpr borrowed_iterator_t<R>
        ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names. Returns: The last iterator i in [first, last] for which the range [first, i) is a heap with respect to
constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
// Preconditions: For the first form, T meets the Cpp17LessThanComparable requirements (Table 28).
// Returns: The smaller value. Returns the first argument when the arguments are equivalent.
// Complexity: Exactly one comparison and two applications of the projection, if any.
// Remarks: An invocation may explicitly specify an argument for the template parameter T of the overloads in namespace std.
template<class RandomAccessIterator>
constexpr RandomAccessIterator
is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator>
RandomAccessIterator
is_heap_until(ExecutionPolicy&& exec,
              RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr RandomAccessIterator
is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
              Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
RandomAccessIterator
is_heap_until(ExecutionPolicy&& exec,
              RandomAccessIterator first, RandomAccessIterator last,
              Compare comp);
template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
template<random_access_range R, class Proj = identity,
// comp and proj. Complexity: Linear.
// 27.8.9 Minimum and maximum [alg.min.max]
         template<class T>
         constexpr const T& min(const T& a, const T& b);
template<class T, class Compare>
constexpr const T& min(const T& a, const T& b, Compare comp);
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
template<class T>
constexpr T min(initializer_list<T> r);
template<class T, class Compare>
constexpr T min(initializer_list<T> r, Compare comp);
template<copyable T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr T ranges::min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
constexpr range_value_t<R>
ranges::min(R&& r, Comp comp = {}, Proj proj = {});
// Preconditions: ranges::distance(r) > 0. For the overloads in namespace std, T meets the Cpp17- CopyConstructible requirements. For the first form, T meets the Cpp17LessThanComparable requirements (Table 28).
// Returns: The smallest value in the input range. Returns a copy of the leftmost element when several elements are equivalent to the smallest.
// Complexity: Exactly ranges::distance(r) - 1 comparisons and twice as many applications of the projection, if any.
// Remarks: An invocation may explicitly specify an argument for the template parameter T of the overloads in namespace std.
indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
        requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
        constexpr range_value_t<R>
        ranges::max(R&& r, Comp comp = {}, Proj proj = {});
// Preconditions: ranges::distance(r) > 0. For the overloads in namespace std, T meets the Cpp17- CopyConstructible requirements. For the first form, T meets the Cpp17LessThanComparable requirements (Table 28).
// Returns: The largest value in the input range. Returns a copy of the leftmost element when several elements are equivalent to the largest.
// Complexity: Exactly ranges::distance(r) - 1 comparisons and twice as many applications of the projection, if any.
// Remarks: An invocation may explicitly specify an argument for the template parameter T of the overloads in namespace std.
template<class T>
constexpr const T& max(const T& a, const T& b);
template<class T, class Compare>
constexpr const T& max(const T& a, const T& b, Compare comp);
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr const T& ranges::max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
// Preconditions: For the first form, T meets the Cpp17LessThanComparable requirements (Table 28).
// Returns: The larger value. Returns the first argument when the arguments are equivalent.
// Complexity: Exactly one comparison and two applications of the projection, if any.
// Remarks: An invocation may explicitly specify an argument for the template parameter T of the overloads in namespace std.
template<class T>
constexpr T max(initializer_list<T> r);
template<class T, class Compare>
constexpr T max(initializer_list<T> r, Compare comp);
template<copyable T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr T ranges::max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
template<input_range R, class Proj = identity,
         template<class T>
         constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
template<class T, class Compare>
constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr ranges::minmax_result<const T&>
ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
// Preconditions: For the first form, T meets the Cpp17LessThanComparable requirements (Table 28).
// Returns: {b, a} if b is smaller than a, and {a, b} otherwise.
// Complexity: Exactly one comparison and two applications of the projection, if any.
// Remarks: An invocation may explicitly specify an argument for the template parameter T of the overloads in namespace std.
requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
constexpr ranges::minmax_result<range_value_t<R>>
        ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
// Preconditions: ranges::distance(r) > 0. For the overloads in namespace std, T meets the Cpp17- CopyConstructible requirements. For the first form, type T meets the Cpp17LessThanComparable requirements (Table 28).
// Returns: Let X be the return type. Returns X{x, y}, where x is a copy of the leftmost element with the smallest value and y a copy of the rightmost element with the largest value in the input range. Complexity: At most (3/2)ranges::distance(r) applications of the corresponding predicate and twice as many applications of the projection, if any.
// Remarks: An invocation may explicitly specify an argument for the template parameter T of the
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names.
template<class T>
constexpr pair<T, T> minmax(initializer_list<T> t);
template<class T, class Compare>
constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
template<copyable T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr ranges::minmax_result<T>
ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// overloads in namespace std.
template<class ForwardIterator>
constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator min_element(ExecutionPolicy&& exec,
                            ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                      Compare comp);
template<class ExecutionPolicy, class ForwardIterator, class Compare>
ForwardIterator min_element(ExecutionPolicy&& exec,
                            ForwardIterator first, ForwardIterator last, Compare comp);
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
template<forward_range R, class Proj = identity,
         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
constexpr borrowed_iterator_t<R>
ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
// Returns: The first iterator i in the range [first,last) such that for every iterator j in the range [first, last),
bool(invoke(comp, invoke(proj, *j), invoke(proj, *i)))
// is false. Returns last if first == last.
// Complexity: Exactly max(last - first - 1,0) comparisons and twice as many projections.
indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
        constexpr borrowed_iterator_t<R>
        ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for the overloads with no parameters by those names. Returns: The first iterator i in the range [first,last) such that for every iterator j in the range [first, last),
bool(invoke(comp, invoke(proj, *i), invoke(proj, *j)))
// is false. Returns last if first == last.
// Complexity: Exactly max(last - first - 1,0) comparisons and twice as many projections.
constexpr ranges::minmax_result<borrowed_iterator_t<R>>
        ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
// Returns: {first, first} if [first, last) is empty, otherwise {m, M}, where m is the first iterator in [first, last) such that no iterator in the range refers to a smaller element, and where M is the last
template<class ForwardIterator>
constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator max_element(ExecutionPolicy&& exec,
                            ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                      Compare comp);
template<class ExecutionPolicy, class ForwardIterator, class Compare>
ForwardIterator max_element(ExecutionPolicy&& exec,
                            ForwardIterator first, ForwardIterator last,
                            Compare comp);
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
template<forward_range R, class Proj = identity,
         template<class ForwardIterator>
         constexpr pair<ForwardIterator, ForwardIterator>
         minmax_element(ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator>
pair<ForwardIterator, ForwardIterator>
minmax_element(ExecutionPolicy&& exec,
               ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
constexpr pair<ForwardIterator, ForwardIterator>
minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
template<class ExecutionPolicy, class ForwardIterator, class Compare>
pair<ForwardIterator, ForwardIterator>
minmax_element(ExecutionPolicy&& exec,
               ForwardIterator first, ForwardIterator last, Compare comp);
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr ranges::minmax_result<I>
ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
template<forward_range R, class Proj = identity,
         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// iterator224 in [first, last) such that no iterator in the range refers to a larger element.
// Complexity: Let N be last - first. At most max(􏰅 3 (N − 1)􏰆, 0) comparisons and twice as many
constexpr const T&
ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
// Let comp be less{} for the overloads with no parameter comp, and let proj be identity{} for the overloads with no parameter proj.
// Preconditions: bool(invoke(comp, invoke(proj, hi), invoke(proj, lo))) is false. For the first form, type T meets the Cpp17LessThanComparable requirements (Table 28).
// Returns: lo if bool(invoke(comp, invoke(proj, v), invoke(proj, lo))) is true, hi if bool( invoke(comp, invoke(proj, hi), invoke(proj, v))) is true, otherwise v.
// [Note 1: If NaN is avoided, T can be a floating-point type.
// Complexity: At most two comparisons and three applications of the projection.
//  applications of the projection, if any.
// 27.8.10 Bounded value [alg.clamp]
template<class T>
constexpr const T& clamp(const T& v, const T& lo, const T& hi);
template<class T, class Compare>
constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp);
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
// 27.8.11 Lexicographical comparison [alg.lex.comparison]
template<class InputIterator1, class InputIterator2>
constexpr bool
lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
bool
lexicographical_compare(ExecutionPolicy&& exec,
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2);
template<class InputIterator1, class InputIterator2, class Compare>
constexpr bool
lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        Compare comp);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class Compare>
bool
lexicographical_compare(ExecutionPolicy&& exec,
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2,
                        Compare comp);
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         class Proj1 = identity, class Proj2 = identity,
         indirect_strict_weak_order<projected<I1, Proj1>,
                                    projected<I2, Proj2>> Comp = ranges::less>
constexpr bool
ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
                                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, class Proj1 = identity,
         class Proj2 = identity,
         indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                    projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
constexpr bool
ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
// Returns: true if and only if the sequence of elements defined by the range [first1, last1) is lexico- graphically less than the sequence of elements defined by the range [first2, last2).
// Complexity: At most 2min(last1 - first1, last2 - first2) applications of the corresponding comparison and each projection, if any.
// Remarks: If two sequences have the same number of elements and their corresponding elements (if any) are equivalent, then neither sequence is lexicographically less than the other. If one sequence is a proper prefix of the other, then the shorter sequence is lexicographically less than the longer sequence. Otherwise, the lexicographical comparison of the sequences yields the same result as the comparison of the first corresponding pair of elements that are not equivalent.
// [Example 1: ranges::lexicographical_compare(I1, S1, I2, S2, Comp, Proj1, Proj2) can be implemen- ted as:
for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
    if (invoke(comp, invoke(proj1, *first1), invoke(proj2, *first2))) return true;
    if (invoke(comp, invoke(proj2, *first2), invoke(proj1, *first1))) return false;
}
return first1 == last1 && first2 != last2;
// [Note 1 : An empty sequence is lexicographically less than any non-empty sequence, but not less than any empty sequence.
// 27.8.12 Three-way comparison algorithms [alg.three.way]
template<class InputIterator1, class InputIterator2, class Cmp>
constexpr auto
lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
                                  InputIterator2 b2, InputIterator2 e2,
                                  Cmp comp)
-> decltype(comp(*b1, *b2));
// Let N be min(e1 - b1, e2 - b2). Let E(n) be comp(*(b1 + n), *(b2 + n)).
// Mandates: decltype(comp(*b1, *b2)) is a comparison category type.
// Returns: E(i), where i is the smallest integer in [0,N) such that E(i) != 0 is true, or (e1 - b1) <=> (e2 - b2) if no such integer exists.
// Complexity: At most N applications of comp.
template<class InputIterator1, class InputIterator2>
constexpr auto
lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
                                  InputIterator2 b2, InputIterator2 e2);
// Effects: Equivalent to:
return lexicographical_compare_three_way(b1, e1, b2, e2, compare_three_way());
// 27.8.13 Permutation generators [alg.permutation.generators]
template<class BidirectionalIterator>
constexpr bool next_permutation(BidirectionalIterator first,
                                BidirectionalIterator last);
template<class BidirectionalIterator, class Compare>
constexpr bool next_permutation(BidirectionalIterator first,
                                BidirectionalIterator last, Compare comp);
template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr ranges::next_permutation_result<I>
ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
template<bidirectional_range R, class Comp = ranges::less,
         class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
constexpr ranges::next_permutation_result<borrowed_iterator_t<R>>
ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
// Let comp be less{} and proj be identity{} for overloads with no parameters by those names. Preconditions: For the overloads in namespace std, BidirectionalIterator meets the Cpp17Value- Swappable requirements (16.4.4.3).
// Effects: Takes a sequence defined by the range [first, last) and transforms it into the next permutation. The next permutation is found by assuming that the set of all permutations is lexicographically sorted with respect to comp and proj. If no such permutation exists, transforms the sequence into the first permutation; that is, the ascendingly-sorted one.
// Returns: Let B be true if a next permutation was found and otherwise false. Returns: — B for the overloads in namespace std.
// — { last, B } for the overloads in namespace ranges.
// Complexity: At most (last - first) / 2 swaps.
// Let comp be less{} and proj be identity{} for overloads with no parameters by those names. Preconditions: For the overloads in namespace std, BidirectionalIterator meets the Cpp17Value- Swappable requirements (16.4.4.3).
// Effects: Takes a sequence defined by the range [first,last) and transforms it into the previous permutation. The previous permutation is found by assuming that the set of all permutations is lexicographically sorted with respect to comp and proj. If no such permutation exists, transforms the sequence into the last permutation; that is, the descendingly-sorted one.
// Returns: Let B be true if a previous permutation was found and otherwise false. Returns: — B for the overloads in namespace std.
// — { last, B } for the overloads in namespace ranges.
// Complexity: At most (last - first) / 2 swaps.
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

## 編纂・実行結果(compile and go)

```ubuntu:bash
$ clang++ p1223.cpp -std=03 -o p1223l -I. -Wall
In file included from p1223.cpp:10:
In file included from ./N4910.h:11:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/atomic:38:
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/c++0x_warning.h:32:2: error: This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
#error This file requires compiler and library support \
 ^
p1223.cpp:17:3: error: unknown type name 'constexpr'
  constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
  ^
p1223.cpp:19:28: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
  void sort(ExecutionPolicy&& exec,
                           ^
p1223.cpp:22:3: error: unknown type name 'constexpr'
  constexpr void sort(RandomAccessIterator first, RandomAccessIterator last,
  ^
p1223.cpp:25:28: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
  void sort(ExecutionPolicy&& exec,
                           ^
p1223.cpp:28:10: error: unknown type name 'random_access_iterator'; did you mean 'random_access_iterator_tag'?
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         ^~~~~~~~~~~~~~~~~~~~~~
         random_access_iterator_tag
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/stl_iterator_base_types.h:107:10: note: 'random_access_iterator_tag' declared here
  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
         ^
p1223.cpp:28:33: error: a non-type template parameter cannot have type 'std::random_access_iterator_tag' before C++20
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
                                ^
p1223.cpp:28:68: error: use of undeclared identifier 'ranges'
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
                                                                   ^
p1223.cpp:29:23: error: unknown type name 'identity'
         class Proj = identity>
                      ^
p1223.cpp:30:3: error: unknown type name 'requires'
  requires sortable<I, Comp, Proj>
  ^
p1223.cpp:33:10: error: unknown type name 'random_access_range'
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
         ^
p1223.cpp:33:46: error: use of undeclared identifier 'ranges'
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
                                             ^
p1223.cpp:33:73: error: unknown type name 'identity'
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
                                                                        ^
p1223.cpp:34:2: error: use of undeclared identifier 'alg'
[alg.sort] [sort]
 ^
p1223.cpp:35:9: error: brackets are not allowed here; to declare an array, place the brackets after the name
requires sortable<iterator_t<R>, Comp, Proj>
        ^
        [alg.sort] [sort]
p1223.cpp:35:1: error: C++ requires a type specifier for all declarations
requires sortable<iterator_t<R>, Comp, Proj>
^
p1223.cpp:34:13: error: reference to overloaded function could not be resolved; did you mean to call it?
[alg.sort] [sort]
            ^~~~
p1223.cpp:25:8: note: possible target for call
  void sort(ExecutionPolicy&& exec,
       ^
p1223.cpp:19:8: note: possible target for call
  void sort(ExecutionPolicy&& exec,
       ^
p1223.cpp:35:1: warning: variable templates are a C++14 extension [-Wc++14-extensions]
requires sortable<iterator_t<R>, Comp, Proj>
^
p1223.cpp:35:9: error: expected ';' at end of declaration
requires sortable<iterator_t<R>, Comp, Proj>
        ^
        ;
p1223.cpp:35:19: error: use of undeclared identifier 'iterator_t'
requires sortable<iterator_t<R>, Comp, Proj>
                  ^
p1223.cpp:36:10: error: expected ';' after top level declarator
constexpr borrowed_iterator_t<R>
         ^
         ;
p1223.cpp:42:35: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
  void stable_sort(ExecutionPolicy&& exec,
                                  ^
p1223.cpp:48:35: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
  void stable_sort(ExecutionPolicy&& exec,
                                  ^
p1223.cpp:51:10: error: unknown type name 'random_access_iterator'; did you mean 'random_access_iterator_tag'?
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         ^~~~~~~~~~~~~~~~~~~~~~
         random_access_iterator_tag
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/stl_iterator_base_types.h:107:10: note: 'random_access_iterator_tag' declared here
  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
         ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
5 warnings and 20 errors generated.
$ clang++ p1223.cpp -std=2b -o p1223l -I. -Wall
p1223.cpp:32:13: error: out-of-line declaration of 'sort' does not match any declaration in namespace 'std::ranges'
    ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
            ^~~~
p1223.cpp:33:10: error: unknown type name 'random_access_range'
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
         ^
p1223.cpp:34:2: error: use of undeclared identifier 'alg'
[alg.sort] [sort]
 ^
p1223.cpp:35:1: error: expected unqualified-id
requires sortable<iterator_t<R>, Comp, Proj>
^
p1223.cpp:54:13: error: out-of-line declaration of 'stable_sort' does not match any declaration in namespace 'std::ranges'
  I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
            ^~~~~~~~~~~
p1223.cpp:55:10: error: unknown type name 'random_access_range'
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
         ^
p1223.cpp:56:21: error: use of undeclared identifier 'iterator_t'
  requires sortable<iterator_t<R>, Comp, Proj>
                    ^
p1223.cpp:92:11: error: out-of-line declaration of 'partial_sort' does not match any declaration in namespace 'std::ranges'
  ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
          ^~~~~~~~~~~~
p1223.cpp:96:20: error: expected unqualified-id
       class Proj1 = identity, class Proj2 = identity>
                   ^
p1223.cpp:105:10: error: unknown type name 'random_access_range'
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
         ^
p1223.cpp:106:21: error: use of undeclared identifier 'iterator_t'
  requires sortable<iterator_t<R>, Comp, Proj>
                    ^
p1223.cpp:110:1: error: expected unqualified-id
return ranges::partial_sort(ranges::begin(r), middle, ranges::end(r), comp, proj);
^
p1223.cpp:142:13: error: no template named 'partial_sort_copy_result' in namespace 'std::ranges'; did you mean 'partial_sort_copy'?
  constexpr ranges::partial_sort_copy_result<I1, I2>
            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            partial_sort_copy
p1223.cpp:133:5: note: 'partial_sort_copy' declared here
    partial_sort_copy(ExecutionPolicy&& exec,
    ^
p1223.cpp:142:21: error: C++ requires a type specifier for all declarations
  constexpr ranges::partial_sort_copy_result<I1, I2>
  ~~~~~~~~~         ^
p1223.cpp:142:21: error: no variable template matches specialization; did you mean to use 'partial_sort_copy' as function template instead?
p1223.cpp:142:53: error: expected ';' at end of declaration
  constexpr ranges::partial_sort_copy_result<I1, I2>
                                                    ^
                                                    ;
p1223.cpp:143:31: error: unknown type name 'I1'
    ranges::partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
                              ^
p1223.cpp:143:41: error: unknown type name 'S1'
    ranges::partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
                                        ^
p1223.cpp:143:50: error: unknown type name 'I2'
    ranges::partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
                                                 ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.

$ g++ p1223.cpp -std=03 -o p1223g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p1223.cpp:10:
/usr/local/include/c++/12.1.0/bits/c++0x_warning.h:32:2: error: #error This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
   32 | #error This file requires compiler and library support \
      |  ^~~~~
p1223.cpp:17:3: warning: identifier 'constexpr' is a keyword in C++11 [-Wc++11-compat]
   17 |   constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1223.cpp:1109:6: warning: identifier 'decltype' is a keyword in C++11 [-Wc++11-compat]
 1109 |   -> decltype(comp(*b1, *b2));
      |      ^~~~~~~~
p1223.cpp:17:3: error: 'constexpr' does not name a type
   17 |   constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1223.cpp:17:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:19:28: error: expected ',' or '...' before '&&' token
   19 |   void sort(ExecutionPolicy&& exec,
      |                            ^~
p1223.cpp:22:3: error: 'constexpr' does not name a type
   22 |   constexpr void sort(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1223.cpp:22:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:25:28: error: expected ',' or '...' before '&&' token
   25 |   void sort(ExecutionPolicy&& exec,
      |                            ^~
p1223.cpp:28:10: error: 'random_access_iterator' has not been declared
   28 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:28:36: error: 'sentinel_for' has not been declared
   28 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:28:48: error: expected '>' before '<' token
   28 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:30:3: error: 'requires' does not name a type
   30 |   requires sortable<I, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:30:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:32:49: error: expected unqualified-id before ',' token
   32 |     ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                 ^
p1223.cpp:32:56: error: expected constructor, destructor, or type conversion before 'proj'
   32 |     ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                        ^~~~
p1223.cpp:32:65: error: expected unqualified-id before ')' token
   32 |     ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1223.cpp:33:10: error: 'random_access_range' has not been declared
   33 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:33:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:33:46: error: 'ranges' does not name a type
   33 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                              ^~~~~~
p1223.cpp:33:52: error: expected '>' before '::' token
   33 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                    ^~
p1223.cpp:34:1: error: expected unqualified-id before '[' token
   34 | [alg.sort] [sort]
      | ^
p1223.cpp:37:37: error: expected unqualified-id before ',' token
   37 |   ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                     ^
p1223.cpp:37:44: error: expected constructor, destructor, or type conversion before 'proj'
   37 |   ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^~~~
p1223.cpp:37:53: error: expected unqualified-id before ')' token
   37 |   ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1223.cpp:42:35: error: expected ',' or '...' before '&&' token
   42 |   void stable_sort(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:48:35: error: expected ',' or '...' before '&&' token
   48 |   void stable_sort(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:51:10: error: 'random_access_iterator' has not been declared
   51 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:51:36: error: 'sentinel_for' has not been declared
   51 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:51:48: error: expected '>' before '<' token
   51 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:53:3: error: 'requires' does not name a type
   53 |   requires sortable<I, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:53:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:54:56: error: expected unqualified-id before ',' token
   54 |   I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1223.cpp:54:63: error: expected constructor, destructor, or type conversion before 'proj'
   54 |   I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1223.cpp:54:72: error: expected unqualified-id before ')' token
   54 |   I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1223.cpp:55:10: error: 'random_access_range' has not been declared
   55 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:55:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:55:46: error: 'ranges' does not name a type
   55 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                              ^~~~~~
p1223.cpp:55:52: error: expected '>' before '::' token
   55 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                    ^~
p1223.cpp:56:3: error: 'requires' does not name a type
   56 |   requires sortable<iterator_t<R>, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:56:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:58:46: error: expected unqualified-id before ',' token
   58 |     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^
p1223.cpp:58:53: error: expected constructor, destructor, or type conversion before 'proj'
   58 |     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^~~~
p1223.cpp:58:62: error: expected unqualified-id before ')' token
   58 |     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:69:3: error: 'constexpr' does not name a type
   69 |   constexpr void partial_sort(RandomAccessIterator first,
      |   ^~~~~~~~~
p1223.cpp:69:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:73:36: error: expected ',' or '...' before '&&' token
   73 |   void partial_sort(ExecutionPolicy&& exec,
      |                                    ^~
p1223.cpp:78:3: error: 'constexpr' does not name a type
   78 |   constexpr void partial_sort(RandomAccessIterator first,
      |   ^~~~~~~~~
p1223.cpp:78:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:83:36: error: expected ',' or '...' before '&&' token
   83 |   void partial_sort(ExecutionPolicy&& exec,
      |                                    ^~
p1223.cpp:88:10: error: 'random_access_iterator' has not been declared
   88 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:88:36: error: 'sentinel_for' has not been declared
   88 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:88:48: error: expected '>' before '<' token
   88 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:90:1: error: 'requires' does not name a type
   90 | requires sortable<I, Comp, Proj>
      | ^~~~~~~~
p1223.cpp:90:1: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:92:65: error: expected unqualified-id before ',' token
   92 |   ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1223.cpp:92:72: error: expected constructor, destructor, or type conversion before 'proj'
   92 |   ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                        ^~~~
p1223.cpp:92:81: error: expected unqualified-id before ')' token
   92 |   ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                                 ^
p1223.cpp:96:20: error: expected unqualified-id before '=' token
   96 |        class Proj1 = identity, class Proj2 = identity>
      |                    ^
p1223.cpp:102:66: error: expected unqualified-id before ',' token
  102 |   ranges::partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
      |                                                                  ^
p1223.cpp:103:35: error: expected constructor, destructor, or type conversion before 'proj1'
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^~~~~
p1223.cpp:103:45: error: expected unqualified-id before ',' token
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                             ^
p1223.cpp:103:53: error: expected constructor, destructor, or type conversion before 'proj2'
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^~~~~
p1223.cpp:103:63: error: expected unqualified-id before ')' token
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                               ^
p1223.cpp:105:10: error: 'random_access_range' has not been declared
  105 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:105:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:105:46: error: 'ranges' does not name a type
  105 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                              ^~~~~~
p1223.cpp:105:52: error: expected '>' before '::' token
  105 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                    ^~
p1223.cpp:106:3: error: 'requires' does not name a type
  106 |   requires sortable<iterator_t<R>, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:106:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:108:65: error: expected unqualified-id before ',' token
  108 | ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1223.cpp:108:72: error: expected constructor, destructor, or type conversion before 'proj'
  108 | ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                        ^~~~
p1223.cpp:108:81: error: expected unqualified-id before ')' token
  108 | ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                                 ^
p1223.cpp:110:1: error: expected unqualified-id before 'return'
  110 | return ranges::partial_sort(ranges::begin(r), middle, ranges::end(r), comp, proj);
      | ^~~~~~
p1223.cpp:113:3: error: 'constexpr' does not name a type
  113 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1223.cpp:113:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:119:38: error: expected ',' or '...' before '&&' token
  119 |     partial_sort_copy(ExecutionPolicy&& exec,
      |                                      ^~
p1223.cpp:125:3: error: 'constexpr' does not name a type
  125 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1223.cpp:125:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:133:38: error: expected ',' or '...' before '&&' token
  133 |     partial_sort_copy(ExecutionPolicy&& exec,
      |                                      ^~
p1223.cpp:138:10: error: 'input_iterator' has not been declared
  138 | template<input_iterator I1, sentinel_for<I1> S1, random_access_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:138:29: error: 'sentinel_for' has not been declared
  138 | template<input_iterator I1, sentinel_for<I1> S1, random_access_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:138:41: error: expected '>' before '<' token
  138 | template<input_iterator I1, sentinel_for<I1> S1, random_access_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:140:3: error: 'requires' does not name a type
  140 |   requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
      |   ^~~~~~~~
p1223.cpp:140:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:144:45: error: expected unqualified-id before ',' token
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                             ^
p1223.cpp:144:53: error: expected constructor, destructor, or type conversion before 'proj1'
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^~~~~
p1223.cpp:144:63: error: expected unqualified-id before ',' token
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                               ^
p1223.cpp:144:71: error: expected constructor, destructor, or type conversion before 'proj2'
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                       ^~~~~
p1223.cpp:144:81: error: expected unqualified-id before ')' token
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                                 ^
p1223.cpp:145:10: error: 'input_range' has not been declared
  145 | template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |          ^~~~~~~~~~~
p1223.cpp:145:26: error: 'random_access_range' has not been declared
  145 | template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:145:63: error: 'ranges' does not name a type
  145 | template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                                                               ^~~~~~
p1223.cpp:145:69: error: expected '>' before '::' token
  145 | template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                                                                     ^~
p1223.cpp:159:70: error: expected unqualified-id before ';' token
  159 | constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);
      |                                                                      ^
p1223.cpp:160:8: error: found ':' in nested-name-specifier, expected '::'
  160 | Effects: Equivalent to: return is_sorted_until(first, last) == last;
      |        ^
      |        ::
p1223.cpp:160:1: error: 'Effects' does not name a type
  160 | Effects: Equivalent to: return is_sorted_until(first, last) == last;
      | ^~~~~~~
p1223.cpp:162:33: error: expected ',' or '...' before '&&' token
  162 |   bool is_sorted(ExecutionPolicy&& exec,
      |                                 ^~
p1223.cpp:165:1: error: expected unqualified-id before 'return'
  165 | return is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last) == last;
      | ^~~~~~
p1223.cpp:167:3: error: 'constexpr' does not name a type
  167 |   constexpr bool is_sorted(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1223.cpp:167:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:171:33: error: expected ',' or '...' before '&&' token
  171 |   bool is_sorted(ExecutionPolicy&& exec,
      |                                 ^~
p1223.cpp:175:1: error: expected unqualified-id before 'return'
  175 | return is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last;
      | ^~~~~~
p1223.cpp:176:10: error: 'forward_iterator' has not been declared
  176 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:176:30: error: 'sentinel_for' has not been declared
  176 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:176:42: error: expected '>' before '<' token
  176 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1223.cpp:178:65: error: expected unqualified-id before '{' token
  178 |   constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1223.cpp:178:67: error: expected unqualified-id before ',' token
  178 |   constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                   ^
p1223.cpp:178:74: error: expected constructor, destructor, or type conversion before 'proj'
  178 |   constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                          ^~~~
p1223.cpp:178:83: error: expected unqualified-id before ')' token
  178 |   constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                   ^
p1223.cpp:179:10: error: 'forward_range' has not been declared
  179 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:179:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:179:40: error: 'identity' does not name a type
  179 | template<forward_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1223.cpp:180:8: error: 'indirect_strict_weak_order' has not been declared
  180 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:180:34: error: expected '>' before '<' token
  180 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                  ^
p1223.cpp:181:53: error: expected unqualified-id before '{' token
  181 | constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1223.cpp:181:55: error: expected unqualified-id before ',' token
  181 | constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1223.cpp:181:62: error: expected constructor, destructor, or type conversion before 'proj'
  181 | constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1223.cpp:181:71: error: expected unqualified-id before ')' token
  181 | constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1223.cpp:184:3: error: 'constexpr' does not name a type
  184 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:184:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:188:36: error: expected ',' or '...' before '&&' token
  188 |     is_sorted_until(ExecutionPolicy&& exec,
      |                                    ^~
p1223.cpp:191:3: error: 'constexpr' does not name a type
  191 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:191:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:196:36: error: expected ',' or '...' before '&&' token
  196 |     is_sorted_until(ExecutionPolicy&& exec,
      |                                    ^~
p1223.cpp:199:10: error: 'forward_iterator' has not been declared
  199 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:199:30: error: 'sentinel_for' has not been declared
  199 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:199:42: error: expected '>' before '<' token
  199 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1223.cpp:201:68: error: expected unqualified-id before '{' token
  201 |   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^
p1223.cpp:201:70: error: expected unqualified-id before ',' token
  201 |   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:201:77: error: expected constructor, destructor, or type conversion before 'proj'
  201 |   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                             ^~~~
p1223.cpp:201:86: error: expected unqualified-id before ')' token
  201 |   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                      ^
p1223.cpp:202:10: error: 'forward_range' has not been declared
  202 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:202:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:202:40: error: 'identity' does not name a type
  202 | template<forward_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1223.cpp:203:10: error: 'indirect_strict_weak_order' has not been declared
  203 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:203:36: error: expected '>' before '<' token
  203 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:205:48: error: expected unqualified-id before '{' token
  205 |     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                ^
p1223.cpp:205:50: error: expected unqualified-id before ',' token
  205 |     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                  ^
p1223.cpp:205:57: error: expected constructor, destructor, or type conversion before 'proj'
  205 |     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                         ^~~~
p1223.cpp:205:66: error: expected unqualified-id before ')' token
  205 |     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1223.cpp:207:1: error: 'requires' does not name a type
  207 | requires sortable<I, Comp, Proj>
      | ^~~~~~~~
p1223.cpp:207:1: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:209:61: error: expected unqualified-id before ',' token
  209 |   ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1223.cpp:209:68: error: expected constructor, destructor, or type conversion before 'proj'
  209 |   ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1223.cpp:209:77: error: expected unqualified-id before ')' token
  209 |   ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1223.cpp:212:1: error: 'ments' does not name a type
  212 | ments.
      | ^~~~~
p1223.cpp:219:35: error: expected ',' or '...' before '&&' token
  219 |   void nth_element(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:223:3: error: 'constexpr' does not name a type
  223 |   constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
      |   ^~~~~~~~~
p1223.cpp:223:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:226:35: error: expected ',' or '...' before '&&' token
  226 |   void nth_element(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:229:10: error: 'random_access_iterator' has not been declared
  229 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:229:36: error: 'sentinel_for' has not been declared
  229 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:229:48: error: expected '>' before '<' token
  229 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:232:10: error: 'ranges' does not name a type
  232 |          ranges::less>
      |          ^~~~~~
p1223.cpp:234:60: error: expected unqualified-id before ',' token
  234 |   ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:234:67: error: expected constructor, destructor, or type conversion before 'proj'
  234 |   ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                   ^~~~
p1223.cpp:234:76: error: expected unqualified-id before ')' token
  234 |   ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                            ^
p1223.cpp:236:12: error: expected ')' before '(' token
  236 | bool(invoke(comp, invoke(proj, e), value)).
      |     ~      ^
      |            )
p1223.cpp:243:61: error: expected unqualified-id before ',' token
  243 | ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1223.cpp:243:68: error: expected constructor, destructor, or type conversion before 'proj'
  243 | ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1223.cpp:243:77: error: expected unqualified-id before ')' token
  243 | ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1223.cpp:245:1: error: expected unqualified-id before 'return'
  245 | return ranges::nth_element(ranges::begin(r), nth, ranges::end(r), comp, proj);
      | ^~~~~~
p1223.cpp:250:3: error: 'constexpr' does not name a type
  250 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:250:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:254:3: error: 'constexpr' does not name a type
  254 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:254:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:257:10: error: 'forward_iterator' has not been declared
  257 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:257:30: error: 'sentinel_for' has not been declared
  257 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:257:42: error: expected '>' before '<' token
  257 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                          ^
p1223.cpp:259:80: error: expected unqualified-id before '{' token
  259 |   constexpr I ranges::lower_bound(I first, S last, const T& value, Comp comp = {},
      |                                                                                ^
p1223.cpp:259:82: error: expected unqualified-id before ',' token
  259 |   constexpr I ranges::lower_bound(I first, S last, const T& value, Comp comp = {},
      |                                                                                  ^
p1223.cpp:260:40: error: expected constructor, destructor, or type conversion before 'proj'
  260 |                                   Proj proj = {});
      |                                        ^~~~
p1223.cpp:260:49: error: expected unqualified-id before ')' token
  260 |                                   Proj proj = {});
      |                                                 ^
p1223.cpp:261:10: error: 'forward_range' has not been declared
  261 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:261:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:261:49: error: 'identity' does not name a type
  261 | template<forward_range R, class T, class Proj = identity,
      |                                                 ^~~~~~~~
p1223.cpp:262:10: error: 'indirect_strict_weak_order' has not been declared
  262 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:262:36: error: expected '>' before '<' token
  262 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                    ^
p1223.cpp:267:32: error: expected unqualified-id before ';' token
  267 |                 const T& value);
      |                                ^
p1223.cpp:269:3: error: 'constexpr' does not name a type
  269 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:269:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:272:10: error: 'ranges' does not name a type
  272 |          ranges::less>
      |          ^~~~~~
p1223.cpp:274:60: error: expected unqualified-id before ',' token
  274 |   ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:274:67: error: expected constructor, destructor, or type conversion before 'proj'
  274 |   ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                   ^~~~
p1223.cpp:274:76: error: expected unqualified-id before ')' token
  274 |   ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                            ^
p1223.cpp:278:11: error: expected unqualified-id before '{' token
  278 |           {lower_bound(first, last, value, comp),
      |           ^
p1223.cpp:281:12: error: 'ranges' does not name a type
  281 |            ranges::upper_bound(first, last, value, comp, proj)}
      |            ^~~~~~
p1223.cpp:281:63: error: expected declaration before '}' token
  281 |            ranges::upper_bound(first, last, value, comp, proj)}
      |                                                               ^
p1223.cpp:283:10: error: 'forward_iterator' has not been declared
  283 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:283:30: error: 'sentinel_for' has not been declared
  283 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:283:42: error: expected '>' before '<' token
  283 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                          ^
p1223.cpp:285:80: error: expected unqualified-id before '{' token
  285 |   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                ^
p1223.cpp:285:82: error: expected unqualified-id before ',' token
  285 |   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1223.cpp:285:89: error: expected constructor, destructor, or type conversion before 'proj'
  285 |   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                         ^~~~
p1223.cpp:285:98: error: expected unqualified-id before ')' token
  285 |   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                                  ^
p1223.cpp:286:10: error: 'forward_range' has not been declared
  286 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:286:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:286:49: error: 'identity' does not name a type
  286 | template<forward_range R, class T, class Proj = identity,
      |                                                 ^~~~~~~~
p1223.cpp:287:10: error: 'indirect_strict_weak_order' has not been declared
  287 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:287:36: error: expected '>' before '<' token
  287 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                    ^
p1223.cpp:290:60: error: expected unqualified-id before '{' token
  290 |     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:290:62: error: expected unqualified-id before ',' token
  290 |     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:290:69: error: expected constructor, destructor, or type conversion before 'proj'
  290 |     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                     ^~~~
p1223.cpp:290:78: error: expected unqualified-id before ')' token
  290 |     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                              ^
p1223.cpp:292:1: error: expected unqualified-id before '!' token
  292 | !bool(invoke(comp, value, invoke(proj, e))).
      | ^
p1223.cpp:300:3: error: 'constexpr' does not name a type
  300 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1223.cpp:300:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:304:10: error: 'forward_iterator' has not been declared
  304 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:304:30: error: 'sentinel_for' has not been declared
  304 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:304:42: error: expected '>' before '<' token
  304 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                          ^
p1223.cpp:307:70: error: expected unqualified-id before '{' token
  307 |     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:307:72: error: expected unqualified-id before ',' token
  307 |     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1223.cpp:307:79: error: expected constructor, destructor, or type conversion before 'proj'
  307 |     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                               ^~~~
p1223.cpp:307:88: error: expected unqualified-id before ')' token
  307 |     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                        ^
p1223.cpp:308:10: error: 'forward_range' has not been declared
  308 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:308:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:308:49: error: 'identity' does not name a type
  308 | template<forward_range R, class T, class Proj = identity,
      |                                                 ^~~~~~~~
p1223.cpp:309:10: error: 'indirect_strict_weak_order' has not been declared
  309 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:309:36: error: expected '>' before '<' token
  309 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                    ^
p1223.cpp:314:34: error: expected unqualified-id before ';' token
  314 |                   const T& value);
      |                                  ^
p1223.cpp:316:3: error: 'constexpr' does not name a type
  316 |   constexpr bool
      |   ^~~~~~~~~
p1223.cpp:316:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:319:10: error: 'forward_iterator' has not been declared
  319 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:319:30: error: 'sentinel_for' has not been declared
  319 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:319:42: error: expected '>' before '<' token
  319 | template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                          ^
p1223.cpp:321:85: error: expected unqualified-id before '{' token
  321 |   constexpr bool ranges::binary_search(I first, S last, const T& value, Comp comp = {},
      |                                                                                     ^
p1223.cpp:321:87: error: expected unqualified-id before ',' token
  321 |   constexpr bool ranges::binary_search(I first, S last, const T& value, Comp comp = {},
      |                                                                                       ^
p1223.cpp:322:45: error: expected constructor, destructor, or type conversion before 'proj'
  322 |                                        Proj proj = {});
      |                                             ^~~~
p1223.cpp:322:54: error: expected unqualified-id before ')' token
  322 |                                        Proj proj = {});
      |                                                      ^
p1223.cpp:323:10: error: 'forward_range' has not been declared
  323 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:323:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:323:49: error: 'identity' does not name a type
  323 | template<forward_range R, class T, class Proj = identity,
      |                                                 ^~~~~~~~
p1223.cpp:324:10: error: 'indirect_strict_weak_order' has not been declared
  324 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:324:36: error: expected '>' before '<' token
  324 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                    ^
p1223.cpp:326:75: error: expected unqualified-id before '{' token
  326 |   constexpr bool ranges::binary_search(R&& r, const T& value, Comp comp = {},
      |                                                                           ^
p1223.cpp:326:77: error: expected unqualified-id before ',' token
  326 |   constexpr bool ranges::binary_search(R&& r, const T& value, Comp comp = {},
      |                                                                             ^
p1223.cpp:327:45: error: expected constructor, destructor, or type conversion before 'proj'
  327 |                                        Proj proj = {});
      |                                             ^~~~
p1223.cpp:327:54: error: expected unqualified-id before ')' token
  327 |                                        Proj proj = {});
      |                                                      ^
p1223.cpp:331:8: error: 'indirect_unary_predicate' does not name a type
  331 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:332:71: error: expected unqualified-id before ')' token
  332 | constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {});
      |                                                                       ^
p1223.cpp:339:3: error: 'constexpr' does not name a type
  339 |   constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
      |   ^~~~~~~~~
p1223.cpp:339:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:341:38: error: expected ',' or '...' before '&&' token
  341 |   bool is_partitioned(ExecutionPolicy&& exec,
      |                                      ^~
p1223.cpp:343:10: error: 'input_iterator' has not been declared
  343 | template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~
p1223.cpp:343:28: error: 'sentinel_for' has not been declared
  343 | template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                            ^~~~~~~~~~~~
p1223.cpp:343:40: error: expected '>' before '<' token
  343 | template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                        ^
p1223.cpp:345:81: error: expected unqualified-id before '{' token
  345 |   constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});
      |                                                                                 ^
p1223.cpp:345:83: error: expected unqualified-id before ')' token
  345 |   constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});
      |                                                                                   ^
p1223.cpp:346:10: error: 'input_range' has not been declared
  346 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:346:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:346:38: error: 'identity' does not name a type
  346 | template<input_range R, class Proj = identity,
      |                                      ^~~~~~~~
p1223.cpp:348:3: error: expected 'class' or 'typename' before 'constexpr'
  348 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:348:13: error: expected '>' before 'ForwardIterator'
  348 |   constexpr ForwardIterator
      |             ^~~~~~~~~~~~~~~
p1223.cpp:349:75: error: expected unqualified-id before ';' token
  349 |     partition(ForwardIterator first, ForwardIterator last, Predicate pred);
      |                                                                           ^
p1223.cpp:352:30: error: expected ',' or '...' before '&&' token
  352 |     partition(ExecutionPolicy&& exec,
      |                              ^~
p1223.cpp:354:10: error: 'permutable' has not been declared
  354 | template<permutable I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~
p1223.cpp:354:24: error: 'sentinel_for' has not been declared
  354 | template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                        ^~~~~~~~~~~~
p1223.cpp:354:36: error: expected '>' before '<' token
  354 | template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                                    ^
p1223.cpp:357:63: error: expected unqualified-id before '{' token
  357 |     ranges::partition(I first, S last, Pred pred, Proj proj = {});
      |                                                               ^
p1223.cpp:357:65: error: expected unqualified-id before ')' token
  357 |     ranges::partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                 ^
p1223.cpp:358:10: error: 'forward_range' has not been declared
  358 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:358:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:358:40: error: 'identity' does not name a type
  358 | template<forward_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1223.cpp:359:10: error: 'indirect_unary_predicate' has not been declared
  359 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:359:34: error: expected '>' before '<' token
  359 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                  ^
p1223.cpp:362:49: error: expected unqualified-id before '{' token
  362 | ranges::partition(R&& r, Pred pred, Proj proj = {});
      |                                                 ^
p1223.cpp:362:51: error: expected unqualified-id before ')' token
  362 | ranges::partition(R&& r, Pred pred, Proj proj = {});
      |                                                   ^
p1223.cpp:371:8: error: 'indirect_unary_predicate' does not name a type
  371 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:373:81: error: expected unqualified-id before ')' token
  373 | borrowed_subrange_t<R> ranges::stable_partition(R&& r, Pred pred, Proj proj = {});
      |                                                                                 ^
p1223.cpp:374:1: error: 'Let' does not name a type
  374 | Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
      | ^~~
p1223.cpp:374:24: error: expected unqualified-id before 'for'
  374 | Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
      |                        ^~~
p1223.cpp:387:37: error: expected ',' or '...' before '&&' token
  387 |     stable_partition(ExecutionPolicy&& exec,
      |                                     ^~
p1223.cpp:389:10: error: 'bidirectional_iterator' has not been declared
  389 | template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:389:36: error: 'sentinel_for' has not been declared
  389 | template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                    ^~~~~~~~~~~~
p1223.cpp:389:48: error: expected '>' before '<' token
  389 | template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                                ^
p1223.cpp:392:80: error: expected unqualified-id before '{' token
  392 |   subrange<I> ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                                ^
p1223.cpp:392:82: error: expected unqualified-id before ')' token
  392 |   subrange<I> ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                                  ^
p1223.cpp:393:10: error: 'bidirectional_range' has not been declared
  393 | template<bidirectional_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:393:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:393:46: error: 'identity' does not name a type
  393 | template<bidirectional_range R, class Proj = identity,
      |                                              ^~~~~~~~
p1223.cpp:395:3: error: expected 'class' or 'typename' before 'constexpr'
  395 |   constexpr pair<OutputIterator1, OutputIterator2>
      |   ^~~~~~~~~
p1223.cpp:395:13: error: expected '>' before 'pair'
  395 |   constexpr pair<OutputIterator1, OutputIterator2>
      |             ^~~~
p1223.cpp:397:88: error: expected unqualified-id before ';' token
  397 |                    OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred);
      |                                                                                        ^
p1223.cpp:401:35: error: expected ',' or '...' before '&&' token
  401 |     partition_copy(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:404:10: error: 'input_iterator' has not been declared
  404 | template<input_iterator I, sentinel_for<I> S, weakly_incrementable O1, weakly_incrementable O2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:404:28: error: 'sentinel_for' has not been declared
  404 | template<input_iterator I, sentinel_for<I> S, weakly_incrementable O1, weakly_incrementable O2,
      |                            ^~~~~~~~~~~~
p1223.cpp:404:40: error: expected '>' before '<' token
  404 | template<input_iterator I, sentinel_for<I> S, weakly_incrementable O1, weakly_incrementable O2,
      |                                        ^
p1223.cpp:409:40: error: expected unqualified-id before '{' token
  409 |                            Proj proj = {});
      |                                        ^
p1223.cpp:409:42: error: expected unqualified-id before ')' token
  409 |                            Proj proj = {});
      |                                          ^
p1223.cpp:410:10: error: 'input_range' has not been declared
  410 | template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |          ^~~~~~~~~~~
p1223.cpp:410:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:410:25: error: 'weakly_incrementable' has not been declared
  410 | template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |                         ^~~~~~~~~~~~~~~~~~~~
p1223.cpp:410:50: error: 'weakly_incrementable' has not been declared
  410 | template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |                                                  ^~~~~~~~~~~~~~~~~~~~
p1223.cpp:411:23: error: 'identity' does not name a type
  411 |          class Proj = identity,
      |                       ^~~~~~~~
p1223.cpp:412:10: error: 'indirect_unary_predicate' has not been declared
  412 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:412:34: error: expected '>' before '<' token
  412 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                  ^
p1223.cpp:416:85: error: expected unqualified-id before '{' token
  416 |     ranges::partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      |                                                                                     ^
p1223.cpp:416:87: error: expected unqualified-id before ')' token
  416 |     ranges::partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      |                                                                                       ^
p1223.cpp:426:8: error: 'indirect_unary_predicate' does not name a type
  426 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:428:59: error: expected unqualified-id before ')' token
  428 |   ranges::partition_point(R&& r, Pred pred, Proj proj = {});
      |                                                           ^
p1223.cpp:434:3: error: 'constexpr' does not name a type
  434 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:434:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:436:10: error: 'forward_iterator' has not been declared
  436 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:436:30: error: 'sentinel_for' has not been declared
  436 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:436:42: error: expected '>' before '<' token
  436 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1223.cpp:438:79: error: expected unqualified-id before '{' token
  438 |   constexpr I ranges::partition_point(I first, S last, Pred pred, Proj proj = {});
      |                                                                               ^
p1223.cpp:438:81: error: expected unqualified-id before ')' token
  438 |   constexpr I ranges::partition_point(I first, S last, Pred pred, Proj proj = {});
      |                                                                                 ^
p1223.cpp:439:10: error: 'forward_range' has not been declared
  439 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:439:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:439:40: error: 'identity' does not name a type
  439 | template<forward_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1223.cpp:443:3: error: expected 'class' or 'typename' before 'constexpr'
  443 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:443:13: error: expected '>' before 'OutputIterator'
  443 |   constexpr OutputIterator
      |             ^~~~~~~~~~~~~~
p1223.cpp:446:33: error: expected unqualified-id before ';' token
  446 |           OutputIterator result);
      |                                 ^
p1223.cpp:450:26: error: expected ',' or '...' before '&&' token
  450 |     merge(ExecutionPolicy&& exec,
      |                          ^~
p1223.cpp:456:3: error: 'constexpr' does not name a type
  456 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:456:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:463:26: error: expected ',' or '...' before '&&' token
  463 |     merge(ExecutionPolicy&& exec,
      |                          ^~
p1223.cpp:467:10: error: 'input_iterator' has not been declared
  467 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:467:29: error: 'sentinel_for' has not been declared
  467 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:467:41: error: expected '>' before '<' token
  467 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:470:3: error: 'requires' does not name a type
  470 |   requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:470:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:473:33: error: expected unqualified-id before ',' token
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1223.cpp:473:41: error: expected constructor, destructor, or type conversion before 'proj1'
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1223.cpp:473:51: error: expected unqualified-id before ',' token
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:473:59: error: expected constructor, destructor, or type conversion before 'proj2'
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:473:69: error: expected unqualified-id before ')' token
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:474:10: error: 'input_range' has not been declared
  474 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |          ^~~~~~~~~~~
p1223.cpp:474:26: error: 'input_range' has not been declared
  474 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                          ^~~~~~~~~~~
p1223.cpp:474:42: error: 'weakly_incrementable' has not been declared
  474 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                                          ^~~~~~~~~~~~~~~~~~~~
p1223.cpp:474:79: error: 'ranges' does not name a type
  474 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                                                                               ^~~~~~
p1223.cpp:474:85: error: expected '>' before '::' token
  474 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                                                                                     ^~
p1223.cpp:476:3: error: 'requires' does not name a type
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:476:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:479:33: error: expected unqualified-id before ',' token
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1223.cpp:479:41: error: expected constructor, destructor, or type conversion before 'proj1'
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1223.cpp:479:51: error: expected unqualified-id before ',' token
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:479:59: error: expected constructor, destructor, or type conversion before 'proj2'
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:479:69: error: expected unqualified-id before ')' token
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:493:37: error: expected ',' or '...' before '&&' token
  493 |   void inplace_merge(ExecutionPolicy&& exec,
      |                                     ^~
p1223.cpp:502:37: error: expected ',' or '...' before '&&' token
  502 |   void inplace_merge(ExecutionPolicy&& exec,
      |                                     ^~
p1223.cpp:506:10: error: 'bidirectional_iterator' has not been declared
  506 | template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:506:36: error: 'sentinel_for' has not been declared
  506 | template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:506:48: error: expected '>' before '<' token
  506 | template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:508:3: error: 'requires' does not name a type
  508 |   requires sortable<I, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:508:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:509:68: error: expected unqualified-id before ',' token
  509 |   I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^
p1223.cpp:509:75: error: expected constructor, destructor, or type conversion before 'proj'
  509 |   I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                           ^~~~
p1223.cpp:509:84: error: expected unqualified-id before ')' token
  509 |   I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                                    ^
p1223.cpp:520:9: error: 'constexpr' does not name a type
  520 |         constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
      |         ^~~~~~~~~
p1223.cpp:520:9: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:524:66: error: expected unqualified-id before ',' token
  524 | ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1223.cpp:524:73: error: expected constructor, destructor, or type conversion before 'proj'
  524 | ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                         ^~~~
p1223.cpp:524:82: error: expected unqualified-id before ')' token
  524 | ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1223.cpp:526:1: error: expected unqualified-id before 'return'
  526 | return ranges::inplace_merge(ranges::begin(r), middle, ranges::end(r), comp, proj);
      | ^~~~~~
p1223.cpp:529:1: error: 'InputIterator2' does not name a type
  529 | InputIterator2 first2, InputIterator2 last2);
      | ^~~~~~~~~~~~~~
p1223.cpp:531:32: error: expected ',' or '...' before '&&' token
  531 |   bool includes(ExecutionPolicy&& exec,
      |                                ^~
p1223.cpp:535:3: error: 'constexpr' does not name a type
  535 |   constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
      |   ^~~~~~~~~
p1223.cpp:535:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:539:32: error: expected ',' or '...' before '&&' token
  539 |   bool includes(ExecutionPolicy&& exec,
      |                                ^~
p1223.cpp:543:10: error: 'input_iterator' has not been declared
  543 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:543:29: error: 'sentinel_for' has not been declared
  543 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:543:41: error: expected '>' before '<' token
  543 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:547:89: error: expected unqualified-id before '{' token
  547 |   constexpr bool ranges::includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
      |                                                                                         ^
p1223.cpp:547:91: error: expected unqualified-id before ',' token
  547 |   constexpr bool ranges::includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
      |                                                                                           ^
p1223.cpp:548:41: error: expected constructor, destructor, or type conversion before 'proj1'
  548 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1223.cpp:548:51: error: expected unqualified-id before ',' token
  548 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:548:59: error: expected constructor, destructor, or type conversion before 'proj2'
  548 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:548:69: error: expected unqualified-id before ')' token
  548 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:549:10: error: 'input_range' has not been declared
  549 | template<input_range R1, input_range R2, class Proj1 = identity,
      |          ^~~~~~~~~~~
p1223.cpp:549:26: error: 'input_range' has not been declared
  549 | template<input_range R1, input_range R2, class Proj1 = identity,
      |                          ^~~~~~~~~~~
p1223.cpp:549:56: error: 'identity' does not name a type
  549 | template<input_range R1, input_range R2, class Proj1 = identity,
      |                                                        ^~~~~~~~
p1223.cpp:550:24: error: 'identity' does not name a type
  550 |          class Proj2 = identity,
      |                        ^~~~~~~~
p1223.cpp:551:10: error: 'indirect_strict_weak_order' has not been declared
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:551:36: error: expected '>' before '<' token
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                    ^
p1223.cpp:553:65: error: expected unqualified-id before '{' token
  553 |   constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {},
      |                                                                 ^
p1223.cpp:553:67: error: expected unqualified-id before ',' token
  553 |   constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {},
      |                                                                   ^
p1223.cpp:554:41: error: expected constructor, destructor, or type conversion before 'proj1'
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1223.cpp:554:51: error: expected unqualified-id before ',' token
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:554:59: error: expected constructor, destructor, or type conversion before 'proj2'
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:554:69: error: expected unqualified-id before ')' token
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:562:3: error: 'constexpr' does not name a type
  562 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:562:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:569:30: error: expected ',' or '...' before '&&' token
  569 |     set_union(ExecutionPolicy&& exec,
      |                              ^~
p1223.cpp:574:3: error: 'constexpr' does not name a type
  574 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:574:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:581:30: error: expected ',' or '...' before '&&' token
  581 |     set_union(ExecutionPolicy&& exec,
      |                              ^~
p1223.cpp:585:10: error: 'input_iterator' has not been declared
  585 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:585:29: error: 'sentinel_for' has not been declared
  585 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:585:41: error: expected '>' before '<' token
  585 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:588:3: error: 'requires' does not name a type
  588 |   requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:588:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:590:89: error: expected unqualified-id before ',' token
  590 |     ranges::set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
      |                                                                                         ^
p1223.cpp:591:29: error: expected constructor, destructor, or type conversion before 'proj1'
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                             ^~~~~
p1223.cpp:591:39: error: expected unqualified-id before ',' token
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1223.cpp:591:47: error: expected constructor, destructor, or type conversion before 'proj2'
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1223.cpp:591:57: error: expected unqualified-id before ')' token
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1223.cpp:592:10: error: 'input_range' has not been declared
  592 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:592:26: error: 'input_range' has not been declared
  592 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:592:42: error: 'weakly_incrementable' has not been declared
  592 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                                          ^~~~~~~~~~~~~~~~~~~~
p1223.cpp:593:23: error: 'ranges' does not name a type
  593 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                       ^~~~~~
p1223.cpp:593:29: error: expected '>' before '::' token
  593 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                             ^~
p1223.cpp:594:3: error: 'requires' does not name a type
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:594:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:596:65: error: expected unqualified-id before ',' token
  596 |     ranges::set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                                 ^
p1223.cpp:597:29: error: expected constructor, destructor, or type conversion before 'proj1'
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                             ^~~~~
p1223.cpp:597:39: error: expected unqualified-id before ',' token
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1223.cpp:597:47: error: expected constructor, destructor, or type conversion before 'proj2'
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1223.cpp:597:57: error: expected unqualified-id before ')' token
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1223.cpp:609:3: error: 'constexpr' does not name a type
  609 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:609:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:616:37: error: expected ',' or '...' before '&&' token
  616 |     set_intersection(ExecutionPolicy&& exec,
      |                                     ^~
p1223.cpp:622:3: error: 'constexpr' does not name a type
  622 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:622:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:629:37: error: expected ',' or '...' before '&&' token
  629 |     set_intersection(ExecutionPolicy&& exec,
      |                                     ^~
p1223.cpp:635:79: error: expected ')' before ';' token
  635 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                               ^
      |                                                                               )
p1223.cpp:629:21: note: to match this '('
  629 |     set_intersection(ExecutionPolicy&& exec,
      |                     ^
p1223.cpp:644:1: error: 'ForwardIterator' does not name a type
  644 | ForwardIterator result, Compare comp);
      | ^~~~~~~~~~~~~~~
p1223.cpp:645:10: error: 'input_iterator' has not been declared
  645 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:645:29: error: 'sentinel_for' has not been declared
  645 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:645:41: error: expected '>' before '<' token
  645 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:648:3: error: 'requires' does not name a type
  648 |   requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:648:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:651:44: error: expected unqualified-id before ',' token
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                            ^
p1223.cpp:651:52: error: expected constructor, destructor, or type conversion before 'proj1'
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                    ^~~~~
p1223.cpp:651:62: error: expected unqualified-id before ',' token
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                              ^
p1223.cpp:651:70: error: expected constructor, destructor, or type conversion before 'proj2'
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                      ^~~~~
p1223.cpp:651:80: error: expected unqualified-id before ')' token
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                                ^
p1223.cpp:652:10: error: 'input_range' has not been declared
  652 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:652:26: error: 'input_range' has not been declared
  652 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:652:42: error: 'weakly_incrementable' has not been declared
  652 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                                          ^~~~~~~~~~~~~~~~~~~~
p1223.cpp:653:23: error: 'ranges' does not name a type
  653 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                       ^~~~~~
p1223.cpp:653:29: error: expected '>' before '::' token
  653 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                             ^~
p1223.cpp:657:3: error: 'constexpr' does not name a type
  657 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:657:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:664:35: error: expected ',' or '...' before '&&' token
  664 |     set_difference(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:670:3: error: 'constexpr' does not name a type
  670 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:670:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:677:35: error: expected ',' or '...' before '&&' token
  677 |     set_difference(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:681:10: error: 'input_iterator' has not been declared
  681 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:681:29: error: 'sentinel_for' has not been declared
  681 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:681:41: error: expected '>' before '<' token
  681 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:684:3: error: 'requires' does not name a type
  684 |   requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:684:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:687:42: error: expected unqualified-id before ',' token
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                          ^
p1223.cpp:687:50: error: expected constructor, destructor, or type conversion before 'proj1'
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^~~~~
p1223.cpp:687:60: error: expected unqualified-id before ',' token
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
p1223.cpp:687:68: error: expected constructor, destructor, or type conversion before 'proj2'
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                    ^~~~~
p1223.cpp:687:78: error: expected unqualified-id before ')' token
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                              ^
p1223.cpp:688:10: error: 'input_range' has not been declared
  688 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:688:26: error: 'input_range' has not been declared
  688 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:688:42: error: 'weakly_incrementable' has not been declared
  688 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                                          ^~~~~~~~~~~~~~~~~~~~
p1223.cpp:689:23: error: 'ranges' does not name a type
  689 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                       ^~~~~~
p1223.cpp:689:29: error: expected '>' before '::' token
  689 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                             ^~
p1223.cpp:690:3: error: 'requires' does not name a type
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:690:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:693:42: error: expected unqualified-id before ',' token
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                          ^
p1223.cpp:693:50: error: expected constructor, destructor, or type conversion before 'proj1'
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^~~~~
p1223.cpp:693:60: error: expected unqualified-id before ',' token
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
p1223.cpp:693:68: error: expected constructor, destructor, or type conversion before 'proj2'
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                    ^~~~~
p1223.cpp:693:78: error: expected unqualified-id before ')' token
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                              ^
p1223.cpp:704:3: error: 'constexpr' does not name a type
  704 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:704:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:711:45: error: expected ',' or '...' before '&&' token
  711 |     set_symmetric_difference(ExecutionPolicy&& exec,
      |                                             ^~
p1223.cpp:717:3: error: 'constexpr' does not name a type
  717 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:717:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:724:45: error: expected ',' or '...' before '&&' token
  724 |     set_symmetric_difference(ExecutionPolicy&& exec,
      |                                             ^~
p1223.cpp:730:10: error: 'input_iterator' has not been declared
  730 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:730:29: error: 'sentinel_for' has not been declared
  730 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:730:41: error: expected '>' before '<' token
  730 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:733:3: error: 'requires' does not name a type
  733 |   requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:733:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:736:52: error: expected unqualified-id before ',' token
  736 |                                      Comp comp = {}, Proj1 proj1 = {},
      |                                                    ^
p1223.cpp:736:60: error: expected constructor, destructor, or type conversion before 'proj1'
  736 |                                      Comp comp = {}, Proj1 proj1 = {},
      |                                                            ^~~~~
p1223.cpp:736:70: error: expected unqualified-id before ',' token
  736 |                                      Comp comp = {}, Proj1 proj1 = {},
      |                                                                      ^
p1223.cpp:737:44: error: expected constructor, destructor, or type conversion before 'proj2'
  737 |                                      Proj2 proj2 = {});
      |                                            ^~~~~
p1223.cpp:737:54: error: expected unqualified-id before ')' token
  737 |                                      Proj2 proj2 = {});
      |                                                      ^
p1223.cpp:738:10: error: 'input_range' has not been declared
  738 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:738:26: error: 'input_range' has not been declared
  738 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:738:42: error: 'weakly_incrementable' has not been declared
  738 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                                          ^~~~~~~~~~~~~~~~~~~~
p1223.cpp:739:23: error: 'ranges' does not name a type
  739 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                       ^~~~~~
p1223.cpp:739:29: error: expected '>' before '::' token
  739 |          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                             ^~
p1223.cpp:740:3: error: 'requires' does not name a type
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1223.cpp:740:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:743:80: error: expected unqualified-id before ',' token
  743 |     ranges::set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                                                ^
p1223.cpp:744:44: error: expected constructor, destructor, or type conversion before 'proj1'
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                            ^~~~~
p1223.cpp:744:54: error: expected unqualified-id before ',' token
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^
p1223.cpp:744:62: error: expected constructor, destructor, or type conversion before 'proj2'
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                              ^~~~~
p1223.cpp:744:72: error: expected unqualified-id before ')' token
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                        ^
p1223.cpp:760:6: error: 'constexpr' does not name a type
  760 |      constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last);
      |      ^~~~~~~~~
p1223.cpp:760:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:762:6: error: 'constexpr' does not name a type
  762 |      constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last,
      |      ^~~~~~~~~
p1223.cpp:762:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:764:13: error: 'random_access_iterator' has not been declared
  764 |    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |             ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:764:39: error: 'sentinel_for' has not been declared
  764 |    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                       ^~~~~~~~~~~~
p1223.cpp:764:51: error: expected '>' before '<' token
  764 |    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                   ^
p1223.cpp:766:6: error: 'requires' does not name a type
  766 |      requires sortable<I, Comp, Proj>
      |      ^~~~~~~~
p1223.cpp:766:6: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:768:57: error: expected unqualified-id before ',' token
  768 |        ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1223.cpp:768:64: error: expected constructor, destructor, or type conversion before 'proj'
  768 |        ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^~~~
p1223.cpp:768:73: error: expected unqualified-id before ')' token
  768 |        ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                         ^
p1223.cpp:769:10: error: 'random_access_range' has not been declared
  769 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:769:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:769:46: error: 'ranges' does not name a type
  769 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                              ^~~~~~
p1223.cpp:769:52: error: expected '>' before '::' token
  769 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                    ^~
p1223.cpp:770:3: error: 'requires' does not name a type
  770 |   requires sortable<iterator_t<R>, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:770:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:772:44: error: expected unqualified-id before ',' token
  772 |     ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1223.cpp:772:51: error: expected constructor, destructor, or type conversion before 'proj'
  772 |     ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1223.cpp:772:60: error: expected unqualified-id before ')' token
  772 |     ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:784:3: error: 'constexpr' does not name a type
  784 |   constexpr void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1223.cpp:784:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:786:3: error: 'constexpr' does not name a type
  786 |   constexpr void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1223.cpp:786:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:788:10: error: 'random_access_iterator' has not been declared
  788 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:788:36: error: 'sentinel_for' has not been declared
  788 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:788:48: error: expected '>' before '<' token
  788 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:790:3: error: 'requires' does not name a type
  790 |   requires sortable<I, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:790:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:792:53: error: expected unqualified-id before ',' token
  792 |     ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1223.cpp:792:60: error: expected constructor, destructor, or type conversion before 'proj'
  792 |     ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                            ^~~~
p1223.cpp:792:69: error: expected unqualified-id before ')' token
  792 |     ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                     ^
p1223.cpp:793:10: error: 'random_access_range' has not been declared
  793 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:793:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:793:46: error: 'ranges' does not name a type
  793 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                              ^~~~~~
p1223.cpp:793:52: error: expected '>' before '::' token
  793 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                    ^~
p1223.cpp:794:1: error: 'requires' does not name a type
  794 | requires sortable<iterator_t<R>, Comp, Proj>
      | ^~~~~~~~
p1223.cpp:794:1: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:796:41: error: expected unqualified-id before ',' token
  796 |   ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                         ^
p1223.cpp:796:48: error: expected constructor, destructor, or type conversion before 'proj'
  796 |   ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                ^~~~
p1223.cpp:796:57: error: expected unqualified-id before ')' token
  796 |   ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1223.cpp:802:3: error: 'constexpr' does not name a type
  802 |   constexpr void make_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1223.cpp:802:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:804:3: error: 'constexpr' does not name a type
  804 |   constexpr void make_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1223.cpp:804:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:806:10: error: 'random_access_iterator' has not been declared
  806 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:806:36: error: 'sentinel_for' has not been declared
  806 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:806:48: error: expected '>' before '<' token
  806 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:808:3: error: 'requires' does not name a type
  808 |   requires sortable<I, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:808:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:810:54: error: expected unqualified-id before ',' token
  810 |     ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1223.cpp:810:61: error: expected constructor, destructor, or type conversion before 'proj'
  810 |     ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^~~~
p1223.cpp:810:70: error: expected unqualified-id before ')' token
  810 |     ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:811:10: error: 'random_access_range' has not been declared
  811 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:811:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:811:46: error: 'ranges' does not name a type
  811 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                              ^~~~~~
p1223.cpp:811:52: error: expected '>' before '::' token
  811 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                    ^~
p1223.cpp:812:3: error: 'requires' does not name a type
  812 |   requires sortable<iterator_t<R>, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:812:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:814:44: error: expected unqualified-id before ',' token
  814 |     ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1223.cpp:814:51: error: expected constructor, destructor, or type conversion before 'proj'
  814 |     ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1223.cpp:814:60: error: expected unqualified-id before ')' token
  814 |     ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:825:3: error: 'constexpr' does not name a type
  825 |   constexpr void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1223.cpp:825:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:827:3: error: 'constexpr' does not name a type
  827 |   constexpr void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1223.cpp:827:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:829:10: error: 'random_access_iterator' has not been declared
  829 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:829:36: error: 'sentinel_for' has not been declared
  829 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:829:48: error: expected '>' before '<' token
  829 | template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:831:3: error: 'requires' does not name a type
  831 |   requires sortable<I, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:831:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:833:54: error: expected unqualified-id before ',' token
  833 |     ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1223.cpp:833:61: error: expected constructor, destructor, or type conversion before 'proj'
  833 |     ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^~~~
p1223.cpp:833:70: error: expected unqualified-id before ')' token
  833 |     ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:834:10: error: 'random_access_range' has not been declared
  834 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:834:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:834:46: error: 'ranges' does not name a type
  834 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                              ^~~~~~
p1223.cpp:834:52: error: expected '>' before '::' token
  834 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                    ^~
p1223.cpp:835:1: error: 'requires' does not name a type
  835 | requires sortable<iterator_t<R>, Comp, Proj>
      | ^~~~~~~~
p1223.cpp:835:1: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:837:42: error: expected unqualified-id before ',' token
  837 |   ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                          ^
p1223.cpp:837:49: error: expected constructor, destructor, or type conversion before 'proj'
  837 |   ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^~~~
p1223.cpp:837:58: error: expected unqualified-id before ')' token
  837 |   ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1223.cpp:840:1: error: 'constexpr' does not name a type
  840 | constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
      | ^~~~~~~~~
p1223.cpp:840:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:843:31: error: expected ',' or '...' before '&&' token
  843 |   bool is_heap(ExecutionPolicy&& exec,
      |                               ^~
p1223.cpp:846:1: error: expected unqualified-id before 'return'
  846 | return is_heap_until(std::forward<ExecutionPolicy>(exec), first, last) == last;
      | ^~~~~~
p1223.cpp:848:3: error: 'constexpr' does not name a type
  848 |   constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1223.cpp:848:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:852:31: error: expected ',' or '...' before '&&' token
  852 |   bool is_heap(ExecutionPolicy&& exec, RandomAccessIterator first, RandomAccessIterator last, Compare comp);
      |                               ^~
p1223.cpp:854:1: error: expected unqualified-id before 'return'
  854 | return is_heap_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last;
      | ^~~~~~
p1223.cpp:855:10: error: 'random_access_iterator' has not been declared
  855 | template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:855:36: error: 'sentinel_for' has not been declared
  855 | template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                    ^~~~~~~~~~~~
p1223.cpp:855:48: error: expected '>' before '<' token
  855 | template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                                ^
p1223.cpp:857:63: error: expected unqualified-id before '{' token
  857 |   constexpr bool ranges::is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                               ^
p1223.cpp:857:65: error: expected unqualified-id before ',' token
  857 |   constexpr bool ranges::is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1223.cpp:857:72: error: expected constructor, destructor, or type conversion before 'proj'
  857 |   constexpr bool ranges::is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                        ^~~~
p1223.cpp:857:81: error: expected unqualified-id before ')' token
  857 |   constexpr bool ranges::is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                 ^
p1223.cpp:858:10: error: 'random_access_range' has not been declared
  858 | template<random_access_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:858:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:858:46: error: 'identity' does not name a type
  858 | template<random_access_range R, class Proj = identity,
      |                                              ^~~~~~~~
p1223.cpp:859:10: error: 'indirect_strict_weak_order' has not been declared
  859 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:859:36: error: expected '>' before '<' token
  859 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:860:53: error: expected unqualified-id before '{' token
  860 |   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1223.cpp:860:55: error: expected unqualified-id before ',' token
  860 |   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1223.cpp:860:62: error: expected constructor, destructor, or type conversion before 'proj'
  860 |   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1223.cpp:860:71: error: expected unqualified-id before ')' token
  860 |   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1223.cpp:862:8: error: 'indirect_strict_weak_order' does not name a type
  862 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:864:46: error: expected unqualified-id before ',' token
  864 |   ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^
p1223.cpp:864:53: error: expected constructor, destructor, or type conversion before 'proj'
  864 |   ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^~~~
p1223.cpp:864:62: error: expected unqualified-id before ')' token
  864 |   ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:866:1: error: 'constexpr' does not name a type
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      | ^~~~~~~~~
p1223.cpp:866:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:866:70: error: expected unqualified-id before ',' token
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:866:77: error: expected constructor, destructor, or type conversion before 'proj'
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                             ^~~~
p1223.cpp:866:86: error: expected unqualified-id before ')' token
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                                      ^
p1223.cpp:872:3: error: 'constexpr' does not name a type
  872 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1223.cpp:872:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:876:34: error: expected ',' or '...' before '&&' token
  876 |     is_heap_until(ExecutionPolicy&& exec,
      |                                  ^~
p1223.cpp:879:3: error: 'constexpr' does not name a type
  879 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1223.cpp:879:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:884:34: error: expected ',' or '...' before '&&' token
  884 |     is_heap_until(ExecutionPolicy&& exec,
      |                                  ^~
p1223.cpp:887:10: error: 'random_access_iterator' has not been declared
  887 | template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:887:36: error: 'sentinel_for' has not been declared
  887 | template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                    ^~~~~~~~~~~~
p1223.cpp:887:48: error: expected '>' before '<' token
  887 | template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                                ^
p1223.cpp:889:66: error: expected unqualified-id before '{' token
  889 |   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1223.cpp:889:68: error: expected unqualified-id before ',' token
  889 |   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^
p1223.cpp:889:75: error: expected constructor, destructor, or type conversion before 'proj'
  889 |   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                           ^~~~
p1223.cpp:889:84: error: expected unqualified-id before ')' token
  889 |   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                    ^
p1223.cpp:890:10: error: 'random_access_range' has not been declared
  890 | template<random_access_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:890:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:890:46: error: 'identity' does not name a type
  890 | template<random_access_range R, class Proj = identity,
      |                                              ^~~~~~~~
p1223.cpp:894:3: error: expected 'class' or 'typename' before 'constexpr'
  894 |   constexpr const T& min(const T& a, const T& b);
      |   ^~~~~~~~~
p1223.cpp:894:13: error: expected '>' before 'const'
  894 |   constexpr const T& min(const T& a, const T& b);
      |             ^~~~~
p1223.cpp:894:49: error: expected unqualified-id before ';' token
  894 |   constexpr const T& min(const T& a, const T& b);
      |                                                 ^
p1223.cpp:896:3: error: 'constexpr' does not name a type
  896 |   constexpr const T& min(const T& a, const T& b, Compare comp);
      |   ^~~~~~~~~
p1223.cpp:896:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:897:32: error: 'identity' does not name a type
  897 | template<class T, class Proj = identity,
      |                                ^~~~~~~~
p1223.cpp:898:10: error: 'indirect_strict_weak_order' has not been declared
  898 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:898:36: error: expected '>' before '<' token
  898 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:900:41: error: expected unqualified-id before ';' token
  900 |   constexpr T min(initializer_list<T> r);
      |                                         ^
p1223.cpp:902:3: error: 'constexpr' does not name a type
  902 |   constexpr T min(initializer_list<T> r, Compare comp);
      |   ^~~~~~~~~
p1223.cpp:902:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:903:10: error: 'copyable' has not been declared
  903 | template<copyable T, class Proj = identity,
      |          ^~~~~~~~
p1223.cpp:903:35: error: 'identity' does not name a type
  903 | template<copyable T, class Proj = identity,
      |                                   ^~~~~~~~
p1223.cpp:904:10: error: 'indirect_strict_weak_order' has not been declared
  904 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:904:36: error: expected '>' before '<' token
  904 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:905:62: error: expected unqualified-id before '{' token
  905 |   constexpr T ranges::min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:905:64: error: expected unqualified-id before ',' token
  905 |   constexpr T ranges::min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1223.cpp:905:71: error: expected constructor, destructor, or type conversion before 'proj'
  905 |   constexpr T ranges::min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                       ^~~~
p1223.cpp:905:80: error: expected unqualified-id before ')' token
  905 |   constexpr T ranges::min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                                ^
p1223.cpp:906:10: error: 'input_range' has not been declared
  906 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:906:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:906:38: error: 'identity' does not name a type
  906 | template<input_range R, class Proj = identity,
      |                                      ^~~~~~~~
p1223.cpp:907:10: error: 'indirect_strict_weak_order' has not been declared
  907 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:907:36: error: expected '>' before '<' token
  907 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:910:36: error: expected unqualified-id before '{' token
  910 |     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
      |                                    ^
p1223.cpp:910:38: error: expected unqualified-id before ',' token
  910 |     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1223.cpp:910:45: error: expected constructor, destructor, or type conversion before 'proj'
  910 |     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1223.cpp:910:54: error: expected unqualified-id before ')' token
  910 |     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1223.cpp:915:8: error: 'indirect_strict_weak_order' does not name a type
  915 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:918:36: error: expected unqualified-id before ',' token
  918 |   ranges::max(R&& r, Comp comp = {}, Proj proj = {});
      |                                    ^
p1223.cpp:918:43: error: expected constructor, destructor, or type conversion before 'proj'
  918 |   ranges::max(R&& r, Comp comp = {}, Proj proj = {});
      |                                           ^~~~
p1223.cpp:918:52: error: expected unqualified-id before ')' token
  918 |   ranges::max(R&& r, Comp comp = {}, Proj proj = {});
      |                                                    ^
p1223.cpp:924:3: error: 'constexpr' does not name a type
  924 |   constexpr const T& max(const T& a, const T& b);
      |   ^~~~~~~~~
p1223.cpp:924:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:926:3: error: 'constexpr' does not name a type
  926 |   constexpr const T& max(const T& a, const T& b, Compare comp);
      |   ^~~~~~~~~
p1223.cpp:926:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:927:32: error: 'identity' does not name a type
  927 | template<class T, class Proj = identity,
      |                                ^~~~~~~~
p1223.cpp:928:10: error: 'indirect_strict_weak_order' has not been declared
  928 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:928:36: error: expected '>' before '<' token
  928 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:929:68: error: expected unqualified-id before '{' token
  929 | constexpr const T& ranges::max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                    ^
p1223.cpp:929:70: error: expected unqualified-id before ',' token
  929 | constexpr const T& ranges::max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:929:77: error: expected constructor, destructor, or type conversion before 'proj'
  929 | constexpr const T& ranges::max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                             ^~~~
p1223.cpp:929:86: error: expected unqualified-id before ')' token
  929 | constexpr const T& ranges::max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                                      ^
p1223.cpp:935:3: error: 'constexpr' does not name a type
  935 |   constexpr T max(initializer_list<T> r);
      |   ^~~~~~~~~
p1223.cpp:935:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:937:3: error: 'constexpr' does not name a type
  937 |   constexpr T max(initializer_list<T> r, Compare comp);
      |   ^~~~~~~~~
p1223.cpp:937:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:938:10: error: 'copyable' has not been declared
  938 | template<copyable T, class Proj = identity,
      |          ^~~~~~~~
p1223.cpp:938:35: error: 'identity' does not name a type
  938 | template<copyable T, class Proj = identity,
      |                                   ^~~~~~~~
p1223.cpp:939:10: error: 'indirect_strict_weak_order' has not been declared
  939 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:939:36: error: expected '>' before '<' token
  939 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:940:62: error: expected unqualified-id before '{' token
  940 |   constexpr T ranges::max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:940:64: error: expected unqualified-id before ',' token
  940 |   constexpr T ranges::max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1223.cpp:940:71: error: expected constructor, destructor, or type conversion before 'proj'
  940 |   constexpr T ranges::max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                       ^~~~
p1223.cpp:940:80: error: expected unqualified-id before ')' token
  940 |   constexpr T ranges::max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                                ^
p1223.cpp:941:10: error: 'input_range' has not been declared
  941 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:941:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:941:38: error: 'identity' does not name a type
  941 | template<input_range R, class Proj = identity,
      |                                      ^~~~~~~~
p1223.cpp:943:3: error: expected 'class' or 'typename' before 'constexpr'
  943 |   constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
      |   ^~~~~~~~~
p1223.cpp:943:13: error: expected '>' before 'pair'
  943 |   constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
      |             ^~~~
p1223.cpp:943:68: error: expected unqualified-id before ';' token
  943 |   constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
      |                                                                    ^
p1223.cpp:945:3: error: 'constexpr' does not name a type
  945 |   constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
      |   ^~~~~~~~~
p1223.cpp:945:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:946:32: error: 'identity' does not name a type
  946 | template<class T, class Proj = identity,
      |                                ^~~~~~~~
p1223.cpp:947:10: error: 'indirect_strict_weak_order' has not been declared
  947 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:947:36: error: expected '>' before '<' token
  947 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:949:56: error: expected unqualified-id before '{' token
  949 |     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1223.cpp:949:58: error: expected unqualified-id before ',' token
  949 |     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1223.cpp:949:65: error: expected constructor, destructor, or type conversion before 'proj'
  949 |     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                 ^~~~
p1223.cpp:949:74: error: expected unqualified-id before ')' token
  949 |     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                          ^
p1223.cpp:954:1: error: 'requires' does not name a type
  954 | requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
      | ^~~~~~~~
p1223.cpp:954:1: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:956:39: error: expected unqualified-id before ',' token
  956 |   ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                       ^
p1223.cpp:956:46: error: expected constructor, destructor, or type conversion before 'proj'
  956 |   ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^~~~
p1223.cpp:956:55: error: expected unqualified-id before ')' token
  956 |   ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1223.cpp:962:3: error: 'constexpr' does not name a type
  962 |   constexpr pair<T, T> minmax(initializer_list<T> t);
      |   ^~~~~~~~~
p1223.cpp:962:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:964:3: error: 'constexpr' does not name a type
  964 |   constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
      |   ^~~~~~~~~
p1223.cpp:964:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:965:10: error: 'copyable' has not been declared
  965 | template<copyable T, class Proj = identity,
      |          ^~~~~~~~
p1223.cpp:965:35: error: 'identity' does not name a type
  965 | template<copyable T, class Proj = identity,
      |                                   ^~~~~~~~
p1223.cpp:966:10: error: 'indirect_strict_weak_order' has not been declared
  966 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:966:36: error: expected '>' before '<' token
  966 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:968:55: error: expected unqualified-id before '{' token
  968 |     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1223.cpp:968:57: error: expected unqualified-id before ',' token
  968 |     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1223.cpp:968:64: error: expected constructor, destructor, or type conversion before 'proj'
  968 |     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                ^~~~
p1223.cpp:968:73: error: expected unqualified-id before ')' token
  968 |     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                         ^
p1223.cpp:969:10: error: 'input_range' has not been declared
  969 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:969:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:969:38: error: 'identity' does not name a type
  969 | template<input_range R, class Proj = identity,
      |                                      ^~~~~~~~
p1223.cpp:970:10: error: 'indirect_strict_weak_order' has not been declared
  970 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:970:36: error: expected '>' before '<' token
  970 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:973:85: error: expected unqualified-id before ';' token
  973 |   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
      |                                                                                     ^
p1223.cpp:975:46: error: expected ',' or '...' before '&&' token
  975 |   ForwardIterator min_element(ExecutionPolicy&& exec,
      |                                              ^~
p1223.cpp:978:3: error: 'constexpr' does not name a type
  978 |   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1223.cpp:978:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:981:46: error: expected ',' or '...' before '&&' token
  981 |   ForwardIterator min_element(ExecutionPolicy&& exec,
      |                                              ^~
p1223.cpp:983:10: error: 'forward_iterator' has not been declared
  983 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:983:30: error: 'sentinel_for' has not been declared
  983 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:983:42: error: expected '>' before '<' token
  983 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1223.cpp:985:64: error: expected unqualified-id before '{' token
  985 |   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1223.cpp:985:66: error: expected unqualified-id before ',' token
  985 |   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1223.cpp:985:73: error: expected constructor, destructor, or type conversion before 'proj'
  985 |   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                         ^~~~
p1223.cpp:985:82: error: expected unqualified-id before ')' token
  985 |   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1223.cpp:986:10: error: 'forward_range' has not been declared
  986 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:986:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:986:40: error: 'identity' does not name a type
  986 | template<forward_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1223.cpp:987:10: error: 'indirect_strict_weak_order' has not been declared
  987 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:987:36: error: expected '>' before '<' token
  987 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:989:44: error: expected unqualified-id before '{' token
  989 |     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1223.cpp:989:46: error: expected unqualified-id before ',' token
  989 |     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^
p1223.cpp:989:53: error: expected constructor, destructor, or type conversion before 'proj'
  989 |     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^~~~
p1223.cpp:989:62: error: expected unqualified-id before ')' token
  989 |     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:991:14: error: expected ')' before '(' token
  991 |   bool(invoke(comp, invoke(proj, *j), invoke(proj, *i)))
      |       ~      ^
      |              )
p1223.cpp:996:44: error: expected unqualified-id before ',' token
  996 |   ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1223.cpp:996:51: error: expected constructor, destructor, or type conversion before 'proj'
  996 |   ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1223.cpp:996:60: error: expected unqualified-id before ')' token
  996 |   ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:998:12: error: expected ')' before '(' token
  998 | bool(invoke(comp, invoke(proj, *i), invoke(proj, *j)))
      |     ~      ^
      |            )
p1223.cpp:1002:47: error: expected unqualified-id before ',' token
 1002 |   ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^
p1223.cpp:1002:54: error: expected constructor, destructor, or type conversion before 'proj'
 1002 |   ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^~~~
p1223.cpp:1002:63: error: expected unqualified-id before ')' token
 1002 |   ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                               ^
p1223.cpp:1005:3: error: 'constexpr' does not name a type
 1005 |   constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
      |   ^~~~~~~~~
p1223.cpp:1005:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1007:46: error: expected ',' or '...' before '&&' token
 1007 |   ForwardIterator max_element(ExecutionPolicy&& exec,
      |                                              ^~
p1223.cpp:1010:3: error: 'constexpr' does not name a type
 1010 |   constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1223.cpp:1010:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1013:46: error: expected ',' or '...' before '&&' token
 1013 |   ForwardIterator max_element(ExecutionPolicy&& exec,
      |                                              ^~
p1223.cpp:1016:10: error: 'forward_iterator' has not been declared
 1016 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:1016:30: error: 'sentinel_for' has not been declared
 1016 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:1016:42: error: expected '>' before '<' token
 1016 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1223.cpp:1018:64: error: expected unqualified-id before '{' token
 1018 |   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1223.cpp:1018:66: error: expected unqualified-id before ',' token
 1018 |   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1223.cpp:1018:73: error: expected constructor, destructor, or type conversion before 'proj'
 1018 |   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                         ^~~~
p1223.cpp:1018:82: error: expected unqualified-id before ')' token
 1018 |   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1223.cpp:1019:10: error: 'forward_range' has not been declared
 1019 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:1019:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:1019:40: error: 'identity' does not name a type
 1019 | template<forward_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1223.cpp:1021:3: error: expected 'class' or 'typename' before 'constexpr'
 1021 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1223.cpp:1021:13: error: expected '>' before 'pair'
 1021 |   constexpr pair<ForwardIterator, ForwardIterator>
      |             ^~~~
p1223.cpp:1022:64: error: expected unqualified-id before ';' token
 1022 |     minmax_element(ForwardIterator first, ForwardIterator last);
      |                                                                ^
p1223.cpp:1025:35: error: expected ',' or '...' before '&&' token
 1025 |     minmax_element(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:1028:3: error: 'constexpr' does not name a type
 1028 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1223.cpp:1028:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1032:35: error: expected ',' or '...' before '&&' token
 1032 |     minmax_element(ExecutionPolicy&& exec,
      |                                   ^~
p1223.cpp:1034:10: error: 'forward_iterator' has not been declared
 1034 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~
p1223.cpp:1034:30: error: 'sentinel_for' has not been declared
 1034 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1223.cpp:1034:42: error: expected '>' before '<' token
 1034 | template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1223.cpp:1037:57: error: expected unqualified-id before '{' token
 1037 |     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1223.cpp:1037:59: error: expected unqualified-id before ',' token
 1037 |     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                           ^
p1223.cpp:1037:66: error: expected constructor, destructor, or type conversion before 'proj'
 1037 |     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                  ^~~~
p1223.cpp:1037:75: error: expected unqualified-id before ')' token
 1037 |     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                           ^
p1223.cpp:1038:10: error: 'forward_range' has not been declared
 1038 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:1038:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:1038:40: error: 'identity' does not name a type
 1038 | template<forward_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1223.cpp:1039:10: error: 'indirect_strict_weak_order' has not been declared
 1039 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1039:36: error: expected '>' before '<' token
 1039 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:1043:67: error: expected unqualified-id before '{' token
 1043 |   ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                   ^
p1223.cpp:1043:69: error: expected unqualified-id before ',' token
 1043 |   ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                     ^
p1223.cpp:1043:76: error: expected constructor, destructor, or type conversion before 'proj'
 1043 |   ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                            ^~~~
p1223.cpp:1043:85: error: expected unqualified-id before ')' token
 1043 |   ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                                     ^
p1223.cpp:1052:3: error: 'constexpr' does not name a type
 1052 |   constexpr const T& clamp(const T& v, const T& lo, const T& hi);
      |   ^~~~~~~~~
p1223.cpp:1052:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1054:3: error: 'constexpr' does not name a type
 1054 |   constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp);
      |   ^~~~~~~~~
p1223.cpp:1054:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1055:32: error: 'identity' does not name a type
 1055 | template<class T, class Proj = identity,
      |                                ^~~~~~~~
p1223.cpp:1056:10: error: 'indirect_strict_weak_order' has not been declared
 1056 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1056:36: error: expected '>' before '<' token
 1056 |          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                    ^
p1223.cpp:1061:73: error: expected unqualified-id before ';' token
 1061 |                             InputIterator2 first2, InputIterator2 last2);
      |                                                                         ^
p1223.cpp:1064:44: error: expected ',' or '...' before '&&' token
 1064 |     lexicographical_compare(ExecutionPolicy&& exec,
      |                                            ^~
p1223.cpp:1068:3: error: 'constexpr' does not name a type
 1068 |   constexpr bool
      |   ^~~~~~~~~
p1223.cpp:1068:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1075:44: error: expected ',' or '...' before '&&' token
 1075 |     lexicographical_compare(ExecutionPolicy&& exec,
      |                                            ^~
p1223.cpp:1079:10: error: 'input_iterator' has not been declared
 1079 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1223.cpp:1079:29: error: 'sentinel_for' has not been declared
 1079 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1223.cpp:1079:41: error: expected '>' before '<' token
 1079 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1223.cpp:1085:49: error: expected unqualified-id before '{' token
 1085 |                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                 ^
p1223.cpp:1085:51: error: expected unqualified-id before ',' token
 1085 |                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:1085:59: error: expected constructor, destructor, or type conversion before 'proj1'
 1085 |                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:1085:69: error: expected unqualified-id before ',' token
 1085 |                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:1085:77: error: expected constructor, destructor, or type conversion before 'proj2'
 1085 |                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                             ^~~~~
p1223.cpp:1085:87: error: expected unqualified-id before ')' token
 1085 |                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                                       ^
p1223.cpp:1086:10: error: 'input_range' has not been declared
 1086 | template<input_range R1, input_range R2, class Proj1 = identity,
      |          ^~~~~~~~~~~
p1223.cpp:1086:26: error: 'input_range' has not been declared
 1086 | template<input_range R1, input_range R2, class Proj1 = identity,
      |                          ^~~~~~~~~~~
p1223.cpp:1086:56: error: 'identity' does not name a type
 1086 | template<input_range R1, input_range R2, class Proj1 = identity,
      |                                                        ^~~~~~~~
p1223.cpp:1087:24: error: 'identity' does not name a type
 1087 |          class Proj2 = identity,
      |                        ^~~~~~~~
p1223.cpp:1088:10: error: 'indirect_strict_weak_order' has not been declared
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1088:36: error: expected '>' before '<' token
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                    ^
p1223.cpp:1091:67: error: expected unqualified-id before '{' token
 1091 |     ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
      |                                                                   ^
p1223.cpp:1091:69: error: expected unqualified-id before ',' token
 1091 |     ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
      |                                                                     ^
p1223.cpp:1092:43: error: expected constructor, destructor, or type conversion before 'proj1'
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                           ^~~~~
p1223.cpp:1092:53: error: expected unqualified-id before ',' token
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^
p1223.cpp:1092:61: error: expected constructor, destructor, or type conversion before 'proj2'
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                             ^~~~~
p1223.cpp:1092:71: error: expected unqualified-id before ')' token
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                       ^
p1223.cpp:1097:8: error: expected unqualified-id before 'for'
 1097 |        for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
      |        ^~~
p1223.cpp:1097:16: error: 'first1' does not name a type
 1097 |        for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
      |                ^~~~~~
p1223.cpp:1097:53: error: expected unqualified-id before '++' token
 1097 |        for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
      |                                                     ^~
p1223.cpp:1101:8: error: expected unqualified-id before 'return'
 1101 |        return first1 == last1 && first2 != last2;
      |        ^~~~~~
p1223.cpp:1105:3: error: 'constexpr' does not name a type
 1105 |   constexpr auto
      |   ^~~~~~~~~
p1223.cpp:1105:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1115:3: error: 'constexpr' does not name a type
 1115 |   constexpr auto
      |   ^~~~~~~~~
p1223.cpp:1115:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1119:1: error: expected unqualified-id before 'return'
 1119 | return lexicographical_compare_three_way(b1, e1, b2, e2, compare_three_way());
      | ^~~~~~
p1223.cpp:1122:3: error: 'constexpr' does not name a type
 1122 |   constexpr bool next_permutation(BidirectionalIterator first,
      |   ^~~~~~~~~
p1223.cpp:1122:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1125:3: error: 'constexpr' does not name a type
 1125 |   constexpr bool next_permutation(BidirectionalIterator first,
      |   ^~~~~~~~~
p1223.cpp:1125:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1223.cpp:1127:10: error: 'bidirectional_iterator' has not been declared
 1127 | template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1127:36: error: 'sentinel_for' has not been declared
 1127 | template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                    ^~~~~~~~~~~~
p1223.cpp:1127:48: error: expected '>' before '<' token
 1127 | template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                ^
p1223.cpp:1129:3: error: 'requires' does not name a type
 1129 |   requires sortable<I, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:1129:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:1131:61: error: expected unqualified-id before ',' token
 1131 |     ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1223.cpp:1131:68: error: expected constructor, destructor, or type conversion before 'proj'
 1131 |     ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1223.cpp:1131:77: error: expected unqualified-id before ')' token
 1131 |     ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1223.cpp:1132:10: error: 'bidirectional_range' has not been declared
 1132 | template<bidirectional_range R, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:1132:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:1132:46: error: 'ranges' does not name a type
 1132 | template<bidirectional_range R, class Comp = ranges::less,
      |                                              ^~~~~~
p1223.cpp:1132:52: error: expected '>' before '::' token
 1132 | template<bidirectional_range R, class Comp = ranges::less,
      |                                                    ^~
p1223.cpp:1134:3: error: 'requires' does not name a type
 1134 |   requires sortable<iterator_t<R>, Comp, Proj>
      |   ^~~~~~~~
p1223.cpp:1134:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1223.cpp:1136:51: error: expected unqualified-id before ',' token
 1136 |     ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1223.cpp:1136:58: error: expected constructor, destructor, or type conversion before 'proj'
 1136 |     ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^~~~
p1223.cpp:1136:67: error: expected unqualified-id before ')' token
 1136 |     ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                   ^

$ g++ p1223.cpp -std=2b -o p1223g -I. -Wall
p1223.cpp:32:65: error: 'I std::ranges::sort(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
   32 |     ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1223.cpp:33:10: error: 'random_access_range' has not been declared
   33 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:33:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:34:1: error: expected unqualified-id before '[' token
   34 | [alg.sort] [sort]
      | ^
p1223.cpp:37:37: error: expected unqualified-id before ',' token
   37 |   ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                     ^
p1223.cpp:37:44: error: expected constructor, destructor, or type conversion before 'proj'
   37 |   ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^~~~
p1223.cpp:37:53: error: expected unqualified-id before ')' token
   37 |   ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1223.cpp:54:72: error: 'I std::ranges::stable_sort(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
   54 |   I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1223.cpp:55:10: error: 'random_access_range' has not been declared
   55 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:55:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:56:21: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
   56 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                     ^~~~~~~~~~
      |                     std::ranges::iterator_t
In file included from /usr/local/include/c++/12.1.0/string_view:50,
                 from /usr/local/include/c++/12.1.0/bits/basic_string.h:48,
                 from /usr/local/include/c++/12.1.0/string:53,
                 from /usr/local/include/c++/12.1.0/bits/locale_classes.h:40,
                 from /usr/local/include/c++/12.1.0/bits/ios_base.h:41,
                 from /usr/local/include/c++/12.1.0/ios:42,
                 from /usr/local/include/c++/12.1.0/ostream:38,
                 from /usr/local/include/c++/12.1.0/iostream:39,
                 from N4910.h:2,
                 from p1223.cpp:10:
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:56:12: error: parse error in template argument list
   56 |   requires sortable<iterator_t<R>, Comp, Proj>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:56:12: error: template argument 1 is invalid
p1223.cpp:56:34: error: expected unqualified-id before ',' token
   56 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1223.cpp:58:46: error: expected unqualified-id before ',' token
   58 |     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^
p1223.cpp:58:53: error: expected constructor, destructor, or type conversion before 'proj'
   58 |     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^~~~
p1223.cpp:58:62: error: expected unqualified-id before ')' token
   58 |     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:92:81: error: 'I std::ranges::partial_sort(I, I, S, Comp, Proj)' should have been declared inside 'std::ranges'
   92 |   ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                                 ^
p1223.cpp:96:20: error: expected unqualified-id before '=' token
   96 |        class Proj1 = identity, class Proj2 = identity>
      |                    ^
p1223.cpp:102:66: error: expected unqualified-id before ',' token
  102 |   ranges::partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
      |                                                                  ^
p1223.cpp:103:35: error: expected constructor, destructor, or type conversion before 'proj1'
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^~~~~
p1223.cpp:103:45: error: expected unqualified-id before ',' token
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                             ^
p1223.cpp:103:53: error: expected constructor, destructor, or type conversion before 'proj2'
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^~~~~
p1223.cpp:103:63: error: expected unqualified-id before ')' token
  103 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                               ^
p1223.cpp:105:10: error: 'random_access_range' has not been declared
  105 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:105:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:106:21: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  106 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                     ^~~~~~~~~~
      |                     std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:106:12: error: parse error in template argument list
  106 |   requires sortable<iterator_t<R>, Comp, Proj>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:106:12: error: template argument 1 is invalid
p1223.cpp:106:34: error: expected unqualified-id before ',' token
  106 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1223.cpp:108:65: error: expected unqualified-id before ',' token
  108 | ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1223.cpp:108:72: error: expected constructor, destructor, or type conversion before 'proj'
  108 | ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                        ^~~~
p1223.cpp:108:81: error: expected unqualified-id before ')' token
  108 | ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                                 ^
p1223.cpp:110:1: error: expected unqualified-id before 'return'
  110 | return ranges::partial_sort(ranges::begin(r), middle, ranges::end(r), comp, proj);
      | ^~~~~~
p1223.cpp:142:21: error: 'partial_sort_copy_result' in namespace 'std::ranges' does not name a template type
  142 |   constexpr ranges::partial_sort_copy_result<I1, I2>
      |                     ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:144:45: error: expected unqualified-id before ',' token
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                             ^
p1223.cpp:144:53: error: expected constructor, destructor, or type conversion before 'proj1'
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^~~~~
p1223.cpp:144:63: error: expected unqualified-id before ',' token
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                               ^
p1223.cpp:144:71: error: expected constructor, destructor, or type conversion before 'proj2'
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                       ^~~~~
p1223.cpp:144:81: error: expected unqualified-id before ')' token
  144 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                                 ^
p1223.cpp:145:10: error: 'input_range' has not been declared
  145 | template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |          ^~~~~~~~~~~
p1223.cpp:145:26: error: 'random_access_range' has not been declared
  145 | template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:149:14: error: expected ')' before '(' token
  149 |   bool(invoke(comp, invoke(proj1, *a1), invoke(proj2, *y2))).
      |       ~      ^
      |              )
p1223.cpp:149:14: error: expected '>' before '(' token
p1223.cpp:149:60: error: expected unqualified-id before ')' token
  149 |   bool(invoke(comp, invoke(proj1, *a1), invoke(proj2, *y2))).
      |                                                            ^
p1223.cpp:160:8: error: found ':' in nested-name-specifier, expected '::'
  160 | Effects: Equivalent to: return is_sorted_until(first, last) == last;
      |        ^
      |        ::
p1223.cpp:160:1: error: 'Effects' does not name a type
  160 | Effects: Equivalent to: return is_sorted_until(first, last) == last;
      | ^~~~~~~
p1223.cpp:165:1: error: expected unqualified-id before 'return'
  165 | return is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last) == last;
      | ^~~~~~
p1223.cpp:175:1: error: expected unqualified-id before 'return'
  175 | return is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last;
      | ^~~~~~
p1223.cpp:178:83: error: 'bool std::ranges::is_sorted(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  178 |   constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                   ^
p1223.cpp:179:10: error: 'forward_range' has not been declared
  179 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:179:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:180:45: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  180 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                             ^~~~~~~~~~
      |                                             std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:180:57: error: wrong number of template arguments (1, should be 2)
  180 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                         ^
In file included from /usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:71,
                 from /usr/local/include/c++/12.1.0/bits/stl_construct.h:61,
                 from /usr/local/include/c++/12.1.0/bits/char_traits.h:46,
                 from /usr/local/include/c++/12.1.0/ios:40:
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:180:8: error: template argument 2 is invalid
  180 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:180:67: error: 'Comp' does not name a type
  180 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                   ^~~~
p1223.cpp:181:55: error: expected unqualified-id before ',' token
  181 | constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1223.cpp:181:62: error: expected constructor, destructor, or type conversion before 'proj'
  181 | constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1223.cpp:181:71: error: expected unqualified-id before ')' token
  181 | constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1223.cpp:201:86: error: 'I std::ranges::is_sorted_until(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  201 |   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                      ^
p1223.cpp:202:10: error: 'forward_range' has not been declared
  202 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:202:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:203:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  203 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:203:59: error: wrong number of template arguments (1, should be 2)
  203 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                           ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:203:10: error: template argument 2 is invalid
  203 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:203:69: error: 'Comp' does not name a type
  203 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                     ^~~~
p1223.cpp:205:50: error: expected unqualified-id before ',' token
  205 |     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                  ^
p1223.cpp:205:57: error: expected constructor, destructor, or type conversion before 'proj'
  205 |     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                         ^~~~
p1223.cpp:205:66: error: expected unqualified-id before ')' token
  205 |     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1223.cpp:207:1: error: expected unqualified-id before 'requires'
  207 | requires sortable<I, Comp, Proj>
      | ^~~~~~~~
p1223.cpp:209:61: error: expected unqualified-id before ',' token
  209 |   ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1223.cpp:209:68: error: expected constructor, destructor, or type conversion before 'proj'
  209 |   ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1223.cpp:209:77: error: expected unqualified-id before ')' token
  209 |   ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1223.cpp:212:1: error: 'ments' does not name a type
  212 | ments.
      | ^~~~~
p1223.cpp:232:22: error: expected unqualified-id before '>' token
  232 |          ranges::less>
      |                      ^
p1223.cpp:234:60: error: expected unqualified-id before ',' token
  234 |   ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:234:67: error: expected constructor, destructor, or type conversion before 'proj'
  234 |   ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                   ^~~~
p1223.cpp:234:76: error: expected unqualified-id before ')' token
  234 |   ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                            ^
p1223.cpp:236:12: error: expected ')' before '(' token
  236 | bool(invoke(comp, invoke(proj, e), value)).
      |     ~      ^
      |            )
p1223.cpp:243:61: error: expected unqualified-id before ',' token
  243 | ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1223.cpp:243:68: error: expected constructor, destructor, or type conversion before 'proj'
  243 | ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1223.cpp:243:77: error: expected unqualified-id before ')' token
  243 | ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1223.cpp:245:1: error: expected unqualified-id before 'return'
  245 | return ranges::nth_element(ranges::begin(r), nth, ranges::end(r), comp, proj);
      | ^~~~~~
p1223.cpp:260:49: error: 'I std::ranges::lower_bound(I, S, const T&, Comp, Proj)' should have been declared inside 'std::ranges'
  260 |                                   Proj proj = {});
      |                                                 ^
p1223.cpp:261:10: error: 'forward_range' has not been declared
  261 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:261:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:262:57: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  262 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                         ^~~~~~~~~~
      |                                                         std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:262:69: error: wrong number of template arguments (1, should be 2)
  262 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                     ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:262:10: error: wrong number of template arguments (4, should be at least 2)
  262 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:739:13: note: provided for 'template<class _Fn, class _I1, class _I2> concept std::indirect_strict_weak_order'
  739 |     concept indirect_strict_weak_order
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:262:79: error: 'Comp' does not name a type
  262 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                               ^~~~
p1223.cpp:272:22: error: expected unqualified-id before '>' token
  272 |          ranges::less>
      |                      ^
p1223.cpp:274:60: error: expected unqualified-id before ',' token
  274 |   ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:274:67: error: expected constructor, destructor, or type conversion before 'proj'
  274 |   ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                   ^~~~
p1223.cpp:274:76: error: expected unqualified-id before ')' token
  274 |   ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                            ^
p1223.cpp:278:11: error: expected unqualified-id before '{' token
  278 |           {lower_bound(first, last, value, comp),
      |           ^
p1223.cpp:281:31: error: expected constructor, destructor, or type conversion before '(' token
  281 |            ranges::upper_bound(first, last, value, comp, proj)}
      |                               ^
p1223.cpp:281:63: error: expected declaration before '}' token
  281 |            ranges::upper_bound(first, last, value, comp, proj)}
      |                                                               ^
p1223.cpp:285:98: error: 'I std::ranges::upper_bound(I, S, const T&, Comp, Proj)' should have been declared inside 'std::ranges'
  285 |   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                                  ^
p1223.cpp:286:10: error: 'forward_range' has not been declared
  286 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:286:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:287:57: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  287 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                         ^~~~~~~~~~
      |                                                         std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:287:69: error: wrong number of template arguments (1, should be 2)
  287 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                     ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:287:10: error: wrong number of template arguments (4, should be at least 2)
  287 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:739:13: note: provided for 'template<class _Fn, class _I1, class _I2> concept std::indirect_strict_weak_order'
  739 |     concept indirect_strict_weak_order
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:287:79: error: 'Comp' does not name a type
  287 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                               ^~~~
p1223.cpp:290:62: error: expected unqualified-id before ',' token
  290 |     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:290:69: error: expected constructor, destructor, or type conversion before 'proj'
  290 |     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                     ^~~~
p1223.cpp:290:78: error: expected unqualified-id before ')' token
  290 |     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                              ^
p1223.cpp:292:1: error: expected unqualified-id before '!' token
  292 | !bool(invoke(comp, value, invoke(proj, e))).
      | ^
p1223.cpp:306:13: error: 'subrange' does not name a type
  306 |   constexpr subrange<I>
      |             ^~~~~~~~
p1223.cpp:307:72: error: expected unqualified-id before ',' token
  307 |     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1223.cpp:307:79: error: expected constructor, destructor, or type conversion before 'proj'
  307 |     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                               ^~~~
p1223.cpp:307:88: error: expected unqualified-id before ')' token
  307 |     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                        ^
p1223.cpp:308:10: error: 'forward_range' has not been declared
  308 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:308:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:309:57: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  309 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                         ^~~~~~~~~~
      |                                                         std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:309:69: error: wrong number of template arguments (1, should be 2)
  309 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                     ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:309:10: error: wrong number of template arguments (4, should be at least 2)
  309 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:739:13: note: provided for 'template<class _Fn, class _I1, class _I2> concept std::indirect_strict_weak_order'
  739 |     concept indirect_strict_weak_order
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:309:79: error: 'Comp' does not name a type
  309 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                               ^~~~
p1223.cpp:322:54: error: 'bool std::ranges::binary_search(I, S, const T&, Comp, Proj)' should have been declared inside 'std::ranges'
  322 |                                        Proj proj = {});
      |                                                      ^
p1223.cpp:323:10: error: 'forward_range' has not been declared
  323 | template<forward_range R, class T, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:323:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:324:57: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  324 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                         ^~~~~~~~~~
      |                                                         std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:324:69: error: wrong number of template arguments (1, should be 2)
  324 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                     ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:324:10: error: wrong number of template arguments (4, should be at least 2)
  324 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:739:13: note: provided for 'template<class _Fn, class _I1, class _I2> concept std::indirect_strict_weak_order'
  739 |     concept indirect_strict_weak_order
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:324:79: error: 'Comp' does not name a type
  324 |          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                               ^~~~
p1223.cpp:326:77: error: expected unqualified-id before ',' token
  326 |   constexpr bool ranges::binary_search(R&& r, const T& value, Comp comp = {},
      |                                                                             ^
p1223.cpp:327:45: error: expected constructor, destructor, or type conversion before 'proj'
  327 |                                        Proj proj = {});
      |                                             ^~~~
p1223.cpp:327:54: error: expected unqualified-id before ')' token
  327 |                                        Proj proj = {});
      |                                                      ^
p1223.cpp:331:43: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  331 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                           ^~~~~~~~~~
      |                                           std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:331:55: error: wrong number of template arguments (1, should be 2)
  331 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                       ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:331:58: error: 'Proj' was not declared in this scope; did you mean 'Proj1'?
  331 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^~~~
      |                                                          Proj1
p1223.cpp:331:8: error: template argument 1 is invalid
  331 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:331:8: error: template argument 2 is invalid
p1223.cpp:331:8: error: '<expression error>' does not name a type
p1223.cpp:332:71: error: expected unqualified-id before ')' token
  332 | constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {});
      |                                                                       ^
p1223.cpp:345:83: error: 'bool std::ranges::is_partitioned(I, S, Pred, Proj)' should have been declared inside 'std::ranges'
  345 |   constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});
      |                                                                                   ^
p1223.cpp:346:10: error: 'input_range' has not been declared
  346 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:346:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:348:3: error: expected 'class' or 'typename' before 'constexpr'
  348 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1223.cpp:348:3: error: expected identifier before 'constexpr'
p1223.cpp:348:3: error: expected '>' before 'constexpr'
p1223.cpp:349:75: error: expected unqualified-id before ';' token
  349 |     partition(ForwardIterator first, ForwardIterator last, Predicate pred);
      |                                                                           ^
p1223.cpp:356:13: error: 'subrange' does not name a type
  356 |   constexpr subrange<I>
      |             ^~~~~~~~
p1223.cpp:357:65: error: expected unqualified-id before ')' token
  357 |     ranges::partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                 ^
p1223.cpp:358:10: error: 'forward_range' has not been declared
  358 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:358:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:359:45: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  359 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                             ^~~~~~~~~~
      |                                             std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:359:57: error: wrong number of template arguments (1, should be 2)
  359 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                         ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:359:10: error: wrong number of template arguments (3, should be 2)
  359 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:710:13: note: provided for 'template<class _Fn, class _Iter> concept std::indirect_unary_predicate'
  710 |     concept indirect_unary_predicate = indirectly_readable<_Iter>
      |             ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:359:67: error: 'Pred' does not name a type
  359 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                                   ^~~~
p1223.cpp:362:51: error: expected unqualified-id before ')' token
  362 | ranges::partition(R&& r, Pred pred, Proj proj = {});
      |                                                   ^
p1223.cpp:371:43: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  371 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                           ^~~~~~~~~~
      |                                           std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:371:55: error: wrong number of template arguments (1, should be 2)
  371 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                       ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:371:58: error: 'Proj' was not declared in this scope; did you mean 'Proj1'?
  371 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^~~~
      |                                                          Proj1
p1223.cpp:371:8: error: template argument 1 is invalid
  371 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:371:8: error: template argument 2 is invalid
p1223.cpp:371:8: error: '<expression error>' does not name a type
p1223.cpp:373:81: error: expected unqualified-id before ')' token
  373 | borrowed_subrange_t<R> ranges::stable_partition(R&& r, Pred pred, Proj proj = {});
      |                                                                                 ^
p1223.cpp:374:1: error: 'Let' does not name a type
  374 | Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
      | ^~~
p1223.cpp:374:24: error: expected unqualified-id before 'for'
  374 | Let proj be identity{} for the overloads with no parameter named proj and let E(x) be bool(invoke( pred, invoke(proj, x))).
      |                        ^~~
p1223.cpp:392:3: error: 'subrange' does not name a type
  392 |   subrange<I> ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
      |   ^~~~~~~~
p1223.cpp:392:82: error: expected unqualified-id before ')' token
  392 |   subrange<I> ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                                  ^
p1223.cpp:393:10: error: 'bidirectional_range' has not been declared
  393 | template<bidirectional_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:393:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:395:3: error: expected 'class' or 'typename' before 'constexpr'
  395 |   constexpr pair<OutputIterator1, OutputIterator2>
      |   ^~~~~~~~~
p1223.cpp:395:3: error: expected identifier before 'constexpr'
p1223.cpp:395:3: error: expected '>' before 'constexpr'
p1223.cpp:397:88: error: expected unqualified-id before ';' token
  397 |                    OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred);
      |                                                                                        ^
p1223.cpp:407:21: error: 'partition_copy_result' in namespace 'std::ranges' does not name a template type
  407 |   constexpr ranges::partition_copy_result<I, O1, O2>
      |                     ^~~~~~~~~~~~~~~~~~~~~
p1223.cpp:409:42: error: expected unqualified-id before ')' token
  409 |                            Proj proj = {});
      |                                          ^
p1223.cpp:410:10: error: 'input_range' has not been declared
  410 | template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |          ^~~~~~~~~~~
p1223.cpp:410:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:412:45: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  412 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                             ^~~~~~~~~~
      |                                             std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:412:57: error: wrong number of template arguments (1, should be 2)
  412 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                         ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:412:10: error: wrong number of template arguments (3, should be 2)
  412 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:710:13: note: provided for 'template<class _Fn, class _Iter> concept std::indirect_unary_predicate'
  710 |     concept indirect_unary_predicate = indirectly_readable<_Iter>
      |             ^~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:412:67: error: 'Pred' does not name a type
  412 |          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                                   ^~~~
p1223.cpp:416:87: error: expected unqualified-id before ')' token
  416 |     ranges::partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      |                                                                                       ^
p1223.cpp:426:43: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  426 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                           ^~~~~~~~~~
      |                                           std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:426:55: error: wrong number of template arguments (1, should be 2)
  426 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                       ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:426:58: error: 'Proj' was not declared in this scope; did you mean 'Proj1'?
  426 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^~~~
      |                                                          Proj1
p1223.cpp:426:8: error: template argument 1 is invalid
  426 |        indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:426:8: error: template argument 2 is invalid
p1223.cpp:426:8: error: '<expression error>' does not name a type
p1223.cpp:428:59: error: expected unqualified-id before ')' token
  428 |   ranges::partition_point(R&& r, Pred pred, Proj proj = {});
      |                                                           ^
p1223.cpp:438:81: error: 'I std::ranges::partition_point(I, S, Pred, Proj)' should have been declared inside 'std::ranges'
  438 |   constexpr I ranges::partition_point(I first, S last, Pred pred, Proj proj = {});
      |                                                                                 ^
p1223.cpp:439:10: error: 'forward_range' has not been declared
  439 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:439:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:443:3: error: expected 'class' or 'typename' before 'constexpr'
  443 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1223.cpp:443:3: error: expected identifier before 'constexpr'
p1223.cpp:443:3: error: expected '>' before 'constexpr'
p1223.cpp:446:33: error: expected unqualified-id before ';' token
  446 |           OutputIterator result);
      |                                 ^
p1223.cpp:471:21: error: 'merge_result' in namespace 'std::ranges' does not name a template type; did you mean 'move_result'?
  471 |   constexpr ranges::merge_result<I1, I2, O>
      |                     ^~~~~~~~~~~~
      |                     move_result
p1223.cpp:473:33: error: expected unqualified-id before ',' token
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1223.cpp:473:41: error: expected constructor, destructor, or type conversion before 'proj1'
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1223.cpp:473:51: error: expected unqualified-id before ',' token
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:473:59: error: expected constructor, destructor, or type conversion before 'proj2'
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:473:69: error: expected unqualified-id before ')' token
  473 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:474:10: error: 'input_range' has not been declared
  474 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |          ^~~~~~~~~~~
p1223.cpp:474:26: error: 'input_range' has not been declared
  474 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                          ^~~~~~~~~~~
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:22: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                      ^~~~~~~~~~
      |                      std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:476:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:476:12: error: wrong number of template arguments (1, should be at least 3)
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:905:13: note: provided for 'template<class _I1, class _I2, class _Out, class _Rel, class _P1, class _P2> concept std::mergeable'
  905 |     concept mergeable = input_iterator<_I1> && input_iterator<_I2>
      |             ^~~~~~~~~
p1223.cpp:476:36: error: expected unqualified-id before ',' token
  476 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                    ^
p1223.cpp:479:33: error: expected unqualified-id before ',' token
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1223.cpp:479:41: error: expected constructor, destructor, or type conversion before 'proj1'
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1223.cpp:479:51: error: expected unqualified-id before ',' token
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:479:59: error: expected constructor, destructor, or type conversion before 'proj2'
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:479:69: error: expected unqualified-id before ')' token
  479 |                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:509:84: error: 'I std::ranges::inplace_merge(I, I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  509 |   I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                                    ^
p1223.cpp:521:1: error: expected identifier before 'template'
  521 | template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
      | ^~~~~~~~
p1223.cpp:521:1: error: expected ',' or '...' before 'template'
p1223.cpp:524:83: error: expected ')' before ';' token
  524 | ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
      |                                                                                   ^
      |                                                                                   )
p1223.cpp:520:32: note: to match this '('
  520 |         constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
      |                                ^
p1223.cpp:526:1: error: expected unqualified-id before 'return'
  526 | return ranges::inplace_merge(ranges::begin(r), middle, ranges::end(r), comp, proj);
      | ^~~~~~
p1223.cpp:529:1: error: 'InputIterator2' does not name a type
  529 | InputIterator2 first2, InputIterator2 last2);
      | ^~~~~~~~~~~~~~
p1223.cpp:548:69: error: 'bool std::ranges::includes(I1, S1, I2, S2, Comp, Proj1, Proj2)' should have been declared inside 'std::ranges'
  548 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:549:10: error: 'input_range' has not been declared
  549 | template<input_range R1, input_range R2, class Proj1 = identity,
      |          ^~~~~~~~~~~
p1223.cpp:549:26: error: 'input_range' has not been declared
  549 | template<input_range R1, input_range R2, class Proj1 = identity,
      |                          ^~~~~~~~~~~
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:551:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:551:60: error: wrong number of template arguments (1, should be 2)
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:551:10: error: template argument 2 is invalid
  551 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:552:58: error: 'R2' was not declared in this scope; did you mean 'R'?
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:552:60: error: wrong number of template arguments (1, should be 2)
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                            ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:552:68: error: expected '>' before '>>' token
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                    ^~
p1223.cpp:552:71: error: 'Comp' does not name a type
  552 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                       ^~~~
p1223.cpp:553:67: error: expected unqualified-id before ',' token
  553 |   constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {},
      |                                                                   ^
p1223.cpp:554:41: error: expected constructor, destructor, or type conversion before 'proj1'
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1223.cpp:554:51: error: expected unqualified-id before ',' token
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1223.cpp:554:59: error: expected constructor, destructor, or type conversion before 'proj2'
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1223.cpp:554:69: error: expected unqualified-id before ')' token
  554 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1223.cpp:589:21: error: 'set_union_result' in namespace 'std::ranges' does not name a template type
  589 |   constexpr ranges::set_union_result<I1, I2, O>
      |                     ^~~~~~~~~~~~~~~~
p1223.cpp:590:89: error: expected unqualified-id before ',' token
  590 |     ranges::set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
      |                                                                                         ^
p1223.cpp:591:29: error: expected constructor, destructor, or type conversion before 'proj1'
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                             ^~~~~
p1223.cpp:591:39: error: expected unqualified-id before ',' token
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1223.cpp:591:47: error: expected constructor, destructor, or type conversion before 'proj2'
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1223.cpp:591:57: error: expected unqualified-id before ')' token
  591 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1223.cpp:592:10: error: 'input_range' has not been declared
  592 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:592:26: error: 'input_range' has not been declared
  592 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:22: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                      ^~~~~~~~~~
      |                      std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:594:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:594:12: error: wrong number of template arguments (1, should be at least 3)
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:905:13: note: provided for 'template<class _I1, class _I2, class _Out, class _Rel, class _P1, class _P2> concept std::mergeable'
  905 |     concept mergeable = input_iterator<_I1> && input_iterator<_I2>
      |             ^~~~~~~~~
p1223.cpp:594:36: error: expected unqualified-id before ',' token
  594 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                    ^
p1223.cpp:596:65: error: expected unqualified-id before ',' token
  596 |     ranges::set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                                 ^
p1223.cpp:597:29: error: expected constructor, destructor, or type conversion before 'proj1'
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                             ^~~~~
p1223.cpp:597:39: error: expected unqualified-id before ',' token
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1223.cpp:597:47: error: expected constructor, destructor, or type conversion before 'proj2'
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1223.cpp:597:57: error: expected unqualified-id before ')' token
  597 |                       Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1223.cpp:632:1: error: expected identifier before 'requires'
  632 | requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      | ^~~~~~~~
p1223.cpp:632:1: error: expected ',' or '...' before 'requires'
p1223.cpp:635:79: error: expected ')' before ';' token
  635 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                               ^
      |                                                                               )
p1223.cpp:629:21: note: to match this '('
  629 |     set_intersection(ExecutionPolicy&& exec,
      |                     ^
p1223.cpp:644:1: error: 'ForwardIterator' does not name a type
  644 | ForwardIterator result, Compare comp);
      | ^~~~~~~~~~~~~~~
p1223.cpp:649:21: error: 'set_intersection_result' in namespace 'std::ranges' does not name a template type
  649 |   constexpr ranges::set_intersection_result<I1, I2, O>
      |                     ^~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:651:44: error: expected unqualified-id before ',' token
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                            ^
p1223.cpp:651:52: error: expected constructor, destructor, or type conversion before 'proj1'
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                    ^~~~~
p1223.cpp:651:62: error: expected unqualified-id before ',' token
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                              ^
p1223.cpp:651:70: error: expected constructor, destructor, or type conversion before 'proj2'
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                      ^~~~~
p1223.cpp:651:80: error: expected unqualified-id before ')' token
  651 |                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                                ^
p1223.cpp:652:10: error: 'input_range' has not been declared
  652 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:652:26: error: 'input_range' has not been declared
  652 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:658:5: error: too many template-parameter-lists
  658 |     set_difference(InputIterator1 first1, InputIterator1 last1,
      |     ^~~~~~~~~~~~~~
p1223.cpp:685:21: error: 'set_difference_result' in namespace 'std::ranges' does not name a template type
  685 |   constexpr ranges::set_difference_result<I1, O>
      |                     ^~~~~~~~~~~~~~~~~~~~~
p1223.cpp:687:42: error: expected unqualified-id before ',' token
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                          ^
p1223.cpp:687:50: error: expected constructor, destructor, or type conversion before 'proj1'
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^~~~~
p1223.cpp:687:60: error: expected unqualified-id before ',' token
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
p1223.cpp:687:68: error: expected constructor, destructor, or type conversion before 'proj2'
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                    ^~~~~
p1223.cpp:687:78: error: expected unqualified-id before ')' token
  687 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                              ^
p1223.cpp:688:10: error: 'input_range' has not been declared
  688 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:688:26: error: 'input_range' has not been declared
  688 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:22: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                      ^~~~~~~~~~
      |                      std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:690:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:690:12: error: wrong number of template arguments (1, should be at least 3)
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:905:13: note: provided for 'template<class _I1, class _I2, class _Out, class _Rel, class _P1, class _P2> concept std::mergeable'
  905 |     concept mergeable = input_iterator<_I1> && input_iterator<_I2>
      |             ^~~~~~~~~
p1223.cpp:690:36: error: expected unqualified-id before ',' token
  690 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                    ^
p1223.cpp:693:42: error: expected unqualified-id before ',' token
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                          ^
p1223.cpp:693:50: error: expected constructor, destructor, or type conversion before 'proj1'
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^~~~~
p1223.cpp:693:60: error: expected unqualified-id before ',' token
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
p1223.cpp:693:68: error: expected constructor, destructor, or type conversion before 'proj2'
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                    ^~~~~
p1223.cpp:693:78: error: expected unqualified-id before ')' token
  693 |                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                              ^
p1223.cpp:734:21: error: 'set_symmetric_difference_result' in namespace 'std::ranges' does not name a template type
  734 |   constexpr ranges::set_symmetric_difference_result<I1, I2, O>
      |                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:736:52: error: expected unqualified-id before ',' token
  736 |                                      Comp comp = {}, Proj1 proj1 = {},
      |                                                    ^
p1223.cpp:736:60: error: expected constructor, destructor, or type conversion before 'proj1'
  736 |                                      Comp comp = {}, Proj1 proj1 = {},
      |                                                            ^~~~~
p1223.cpp:736:70: error: expected unqualified-id before ',' token
  736 |                                      Comp comp = {}, Proj1 proj1 = {},
      |                                                                      ^
p1223.cpp:737:44: error: expected constructor, destructor, or type conversion before 'proj2'
  737 |                                      Proj2 proj2 = {});
      |                                            ^~~~~
p1223.cpp:737:54: error: expected unqualified-id before ')' token
  737 |                                      Proj2 proj2 = {});
      |                                                      ^
p1223.cpp:738:10: error: 'input_range' has not been declared
  738 | template<input_range R1, input_range R2, weakly_incrementable O,
      |          ^~~~~~~~~~~
p1223.cpp:738:26: error: 'input_range' has not been declared
  738 | template<input_range R1, input_range R2, weakly_incrementable O,
      |                          ^~~~~~~~~~~
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:22: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                      ^~~~~~~~~~
      |                      std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:740:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1223.cpp:740:12: error: wrong number of template arguments (1, should be at least 3)
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:905:13: note: provided for 'template<class _I1, class _I2, class _Out, class _Rel, class _P1, class _P2> concept std::mergeable'
  905 |     concept mergeable = input_iterator<_I1> && input_iterator<_I2>
      |             ^~~~~~~~~
p1223.cpp:740:36: error: expected unqualified-id before ',' token
  740 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                    ^
p1223.cpp:743:80: error: expected unqualified-id before ',' token
  743 |     ranges::set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                                                ^
p1223.cpp:744:44: error: expected constructor, destructor, or type conversion before 'proj1'
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                            ^~~~~
p1223.cpp:744:54: error: expected unqualified-id before ',' token
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^
p1223.cpp:744:62: error: expected constructor, destructor, or type conversion before 'proj2'
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                              ^~~~~
p1223.cpp:744:72: error: expected unqualified-id before ')' token
  744 |                                      Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                        ^
p1223.cpp:768:73: error: 'I std::ranges::push_heap(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  768 |        ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                         ^
p1223.cpp:769:10: error: 'random_access_range' has not been declared
  769 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:769:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:770:21: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  770 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                     ^~~~~~~~~~
      |                     std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:770:12: error: parse error in template argument list
  770 |   requires sortable<iterator_t<R>, Comp, Proj>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:770:12: error: template argument 1 is invalid
p1223.cpp:770:34: error: expected unqualified-id before ',' token
  770 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1223.cpp:772:44: error: expected unqualified-id before ',' token
  772 |     ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1223.cpp:772:51: error: expected constructor, destructor, or type conversion before 'proj'
  772 |     ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1223.cpp:772:60: error: expected unqualified-id before ')' token
  772 |     ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:792:69: error: 'I std::ranges::pop_heap(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  792 |     ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                     ^
p1223.cpp:793:10: error: 'random_access_range' has not been declared
  793 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:793:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:794:19: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  794 | requires sortable<iterator_t<R>, Comp, Proj>
      |                   ^~~~~~~~~~
      |                   std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:794:10: error: parse error in template argument list
  794 | requires sortable<iterator_t<R>, Comp, Proj>
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:794:10: error: template argument 1 is invalid
p1223.cpp:794:32: error: expected unqualified-id before ',' token
  794 | requires sortable<iterator_t<R>, Comp, Proj>
      |                                ^
p1223.cpp:796:41: error: expected unqualified-id before ',' token
  796 |   ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                         ^
p1223.cpp:796:48: error: expected constructor, destructor, or type conversion before 'proj'
  796 |   ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                ^~~~
p1223.cpp:796:57: error: expected unqualified-id before ')' token
  796 |   ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1223.cpp:810:70: error: 'I std::ranges::make_heap(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  810 |     ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:811:10: error: 'random_access_range' has not been declared
  811 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:811:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:812:21: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  812 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                     ^~~~~~~~~~
      |                     std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:812:12: error: parse error in template argument list
  812 |   requires sortable<iterator_t<R>, Comp, Proj>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:812:12: error: template argument 1 is invalid
p1223.cpp:812:34: error: expected unqualified-id before ',' token
  812 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1223.cpp:814:44: error: expected unqualified-id before ',' token
  814 |     ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1223.cpp:814:51: error: expected constructor, destructor, or type conversion before 'proj'
  814 |     ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1223.cpp:814:60: error: expected unqualified-id before ')' token
  814 |     ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:833:70: error: 'I std::ranges::sort_heap(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  833 |     ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:834:10: error: 'random_access_range' has not been declared
  834 | template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:834:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:835:19: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  835 | requires sortable<iterator_t<R>, Comp, Proj>
      |                   ^~~~~~~~~~
      |                   std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:835:10: error: parse error in template argument list
  835 | requires sortable<iterator_t<R>, Comp, Proj>
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:835:10: error: template argument 1 is invalid
p1223.cpp:835:32: error: expected unqualified-id before ',' token
  835 | requires sortable<iterator_t<R>, Comp, Proj>
      |                                ^
p1223.cpp:837:42: error: expected unqualified-id before ',' token
  837 |   ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                          ^
p1223.cpp:837:49: error: expected constructor, destructor, or type conversion before 'proj'
  837 |   ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^~~~
p1223.cpp:837:58: error: expected unqualified-id before ')' token
  837 |   ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1223.cpp:846:1: error: expected unqualified-id before 'return'
  846 | return is_heap_until(std::forward<ExecutionPolicy>(exec), first, last) == last;
      | ^~~~~~
p1223.cpp:854:1: error: expected unqualified-id before 'return'
  854 | return is_heap_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last;
      | ^~~~~~
p1223.cpp:857:81: error: 'bool std::ranges::is_heap(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  857 |   constexpr bool ranges::is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                 ^
p1223.cpp:858:10: error: 'random_access_range' has not been declared
  858 | template<random_access_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:858:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:859:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  859 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:859:59: error: wrong number of template arguments (1, should be 2)
  859 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                           ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:859:10: error: template argument 2 is invalid
  859 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:859:69: error: 'Comp' does not name a type
  859 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                     ^~~~
p1223.cpp:860:55: error: expected unqualified-id before ',' token
  860 |   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1223.cpp:860:62: error: expected constructor, destructor, or type conversion before 'proj'
  860 |   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1223.cpp:860:71: error: expected unqualified-id before ')' token
  860 |   constexpr bool ranges::is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1223.cpp:862:45: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  862 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                             ^~~~~~~~~~
      |                                             std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:862:57: error: wrong number of template arguments (1, should be 2)
  862 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                         ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:862:60: error: 'Proj' was not declared in this scope; did you mean 'Proj1'?
  862 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^~~~
      |                                                            Proj1
p1223.cpp:862:8: error: template argument 1 is invalid
  862 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:862:8: error: template argument 2 is invalid
p1223.cpp:862:8: error: template argument 3 is invalid
p1223.cpp:862:8: error: '<expression error>' does not name a type
p1223.cpp:864:46: error: expected unqualified-id before ',' token
  864 |   ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^
p1223.cpp:864:53: error: expected constructor, destructor, or type conversion before 'proj'
  864 |   ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^~~~
p1223.cpp:864:62: error: expected unqualified-id before ')' token
  864 |   ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:866:17: error: 'T' does not name a type
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                 ^
p1223.cpp:866:70: error: expected unqualified-id before ',' token
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                      ^
p1223.cpp:866:77: error: expected constructor, destructor, or type conversion before 'proj'
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                             ^~~~
p1223.cpp:866:86: error: expected unqualified-id before ')' token
  866 | constexpr const T& ranges::min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                                      ^
p1223.cpp:889:84: error: 'I std::ranges::is_heap_until(I, S, Comp, Proj)' should have been declared inside std::ranges'
  889 |   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                    ^
p1223.cpp:890:10: error: 'random_access_range' has not been declared
  890 | template<random_access_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:890:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:894:3: error: expected 'class' or 'typename' before 'constexpr'
  894 |   constexpr const T& min(const T& a, const T& b);
      |   ^~~~~~~~~
p1223.cpp:894:3: error: expected identifier before 'constexpr'
p1223.cpp:894:3: error: expected '>' before 'constexpr'
p1223.cpp:894:49: error: expected unqualified-id before ';' token
  894 |   constexpr const T& min(const T& a, const T& b);
      |                                                 ^
p1223.cpp:899:10: error: declaration of template parameter 'T' shadows template parameter
  899 | template<class T>
      |          ^~~~~
p1223.cpp:897:10: note: template parameter 'T' declared here
  897 | template<class T, class Proj = identity,
      |          ^~~~~
p1223.cpp:900:15: error: too many template-parameter-lists
  900 |   constexpr T min(initializer_list<T> r);
      |               ^~~
p1223.cpp:905:80: error: 'T std::ranges::min(std::initializer_list<_Tp>, Comp, Proj)' should have been declared inside 'std::ranges'
  905 |   constexpr T ranges::min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                                ^
p1223.cpp:906:10: error: 'input_range' has not been declared
  906 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:906:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:907:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  907 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:907:59: error: wrong number of template arguments (1, should be 2)
  907 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                           ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:907:10: error: template argument 2 is invalid
  907 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:907:69: error: 'Comp' does not name a type
  907 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                     ^~~~
p1223.cpp:910:38: error: expected unqualified-id before ',' token
  910 |     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1223.cpp:910:45: error: expected constructor, destructor, or type conversion before 'proj'
  910 |     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1223.cpp:910:54: error: expected unqualified-id before ')' token
  910 |     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1223.cpp:915:45: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  915 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                             ^~~~~~~~~~
      |                                             std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:915:57: error: wrong number of template arguments (1, should be 2)
  915 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                         ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:915:60: error: 'Proj' was not declared in this scope; did you mean 'Proj1'?
  915 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^~~~
      |                                                            Proj1
p1223.cpp:915:8: error: template argument 1 is invalid
  915 |        indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:915:8: error: template argument 2 is invalid
p1223.cpp:915:8: error: template argument 3 is invalid
p1223.cpp:915:8: error: '<expression error>' does not name a type
p1223.cpp:918:36: error: expected unqualified-id before ',' token
  918 |   ranges::max(R&& r, Comp comp = {}, Proj proj = {});
      |                                    ^
p1223.cpp:918:43: error: expected constructor, destructor, or type conversion before 'proj'
  918 |   ranges::max(R&& r, Comp comp = {}, Proj proj = {});
      |                                           ^~~~
p1223.cpp:918:52: error: expected unqualified-id before ')' token
  918 |   ranges::max(R&& r, Comp comp = {}, Proj proj = {});
      |                                                    ^
p1223.cpp:929:86: error: 'const T& std::ranges::max(const T&, const T&, Comp, Proj)' should have been declared inside 'std::ranges'
  929 | constexpr const T& ranges::max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                                      ^
p1223.cpp:940:80: error: 'T std::ranges::max(std::initializer_list<_Tp>, Comp, Proj)' should have been declared inside 'std::ranges'
  940 |   constexpr T ranges::max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                                ^
p1223.cpp:941:10: error: 'input_range' has not been declared
  941 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:941:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:943:3: error: expected 'class' or 'typename' before 'constexpr'
  943 |   constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
      |   ^~~~~~~~~
p1223.cpp:943:3: error: expected identifier before 'constexpr'
p1223.cpp:943:3: error: expected '>' before 'constexpr'
p1223.cpp:943:68: error: expected unqualified-id before ';' token
  943 |   constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
      |                                                                    ^
p1223.cpp:948:21: error: 'minmax_result' in namespace 'std::ranges' does not name a template type; did you mean 'move_result'?
  948 |   constexpr ranges::minmax_result<const T&>
      |                     ^~~~~~~~~~~~~
      |                     move_result
p1223.cpp:949:58: error: expected unqualified-id before ',' token
  949 |     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1223.cpp:949:65: error: expected constructor, destructor, or type conversion before 'proj'
  949 |     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                 ^~~~
p1223.cpp:949:74: error: expected unqualified-id before ')' token
  949 |     ranges::minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                          ^
p1223.cpp:954:1: error: expected unqualified-id before 'requires'
  954 | requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
      | ^~~~~~~~
p1223.cpp:956:39: error: expected unqualified-id before ',' token
  956 |   ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                       ^
p1223.cpp:956:46: error: expected constructor, destructor, or type conversion before 'proj'
  956 |   ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^~~~
p1223.cpp:956:55: error: expected unqualified-id before ')' token
  956 |   ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1223.cpp:967:21: error: 'minmax_result' in namespace 'std::ranges' does not name a template type; did you mean 'move_result'?
  967 |   constexpr ranges::minmax_result<T>
      |                     ^~~~~~~~~~~~~
      |                     move_result
p1223.cpp:968:57: error: expected unqualified-id before ',' token
  968 |     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1223.cpp:968:64: error: expected constructor, destructor, or type conversion before 'proj'
  968 |     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                ^~~~
p1223.cpp:968:73: error: expected unqualified-id before ')' token
  968 |     ranges::minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                         ^
p1223.cpp:969:10: error: 'input_range' has not been declared
  969 | template<input_range R, class Proj = identity,
      |          ^~~~~~~~~~~
p1223.cpp:969:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:970:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  970 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:970:59: error: wrong number of template arguments (1, should be 2)
  970 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                           ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:970:10: error: template argument 2 is invalid
  970 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:970:69: error: 'Comp' does not name a type
  970 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                     ^~~~
p1223.cpp:985:82: error: 'I std::ranges::min_element(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
  985 |   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1223.cpp:986:10: error: 'forward_range' has not been declared
  986 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:986:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:987:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_t'?
  987 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:987:59: error: wrong number of template arguments (1, should be 2)
  987 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                           ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:987:10: error: template argument 2 is invalid
  987 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:987:69: error: 'Comp' does not name a type
  987 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                     ^~~~
p1223.cpp:989:46: error: expected unqualified-id before ',' token
  989 |     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                              ^
p1223.cpp:989:53: error: expected constructor, destructor, or type conversion before 'proj'
  989 |     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^~~~
p1223.cpp:989:62: error: expected unqualified-id before ')' token
  989 |     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1223.cpp:991:14: error: expected ')' before '(' token
  991 |   bool(invoke(comp, invoke(proj, *j), invoke(proj, *i)))
      |       ~      ^
      |              )
p1223.cpp:996:44: error: expected unqualified-id before ',' token
  996 |   ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1223.cpp:996:51: error: expected constructor, destructor, or type conversion before 'proj'
  996 |   ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1223.cpp:996:60: error: expected unqualified-id before ')' token
  996 |   ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1223.cpp:998:12: error: expected ')' before '(' token
  998 | bool(invoke(comp, invoke(proj, *i), invoke(proj, *j)))
      |     ~      ^
      |            )
p1223.cpp:1002:47: error: expected unqualified-id before ',' token
 1002 |   ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^
p1223.cpp:1002:54: error: expected constructor, destructor, or type conversion before 'proj'
 1002 |   ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^~~~
p1223.cpp:1002:63: error: expected unqualified-id before ')' token
 1002 |   ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                               ^
p1223.cpp:1018:82: error: 'I std::ranges::max_element(I, S, Comp, Proj)' should have been declared inside 'std::ranges'
 1018 |   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1223.cpp:1019:10: error: 'forward_range' has not been declared
 1019 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:1019:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:1021:3: error: expected 'class' or 'typename' before 'constexpr'
 1021 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1223.cpp:1021:3: error: expected identifier before 'constexpr'
p1223.cpp:1021:3: error: expected '>' before 'constexpr'
p1223.cpp:1022:64: error: expected unqualified-id before ';' token
 1022 |     minmax_element(ForwardIterator first, ForwardIterator last);
      |                                                                ^
p1223.cpp:1036:21: error: 'minmax_result' in namespace 'std::ranges' does not name a template type; did you mean 'move_result'?
 1036 |   constexpr ranges::minmax_result<I>
      |                     ^~~~~~~~~~~~~
      |                     move_result
p1223.cpp:1037:59: error: expected unqualified-id before ',' token
 1037 |     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                           ^
p1223.cpp:1037:66: error: expected constructor, destructor, or type conversion before 'proj'
 1037 |     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                  ^~~~
p1223.cpp:1037:75: error: expected unqualified-id before ')' token
 1037 |     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                           ^
p1223.cpp:1038:10: error: 'forward_range' has not been declared
 1038 | template<forward_range R, class Proj = identity,
      |          ^~~~~~~~~~~~~
p1223.cpp:1038:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:1039:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1039 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:1039:59: error: wrong number of template arguments (1, should be 2)
 1039 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                           ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:1039:10: error: template argument 2 is invalid
 1039 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1039:69: error: 'Comp' does not name a type
 1039 |          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                     ^~~~
p1223.cpp:1043:69: error: expected unqualified-id before ',' token
 1043 |   ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                     ^
p1223.cpp:1043:76: error: expected constructor, destructor, or type conversion before 'proj'
 1043 |   ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                            ^~~~
p1223.cpp:1043:85: error: expected unqualified-id before ')' token
 1043 |   ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                                     ^
p1223.cpp:1060:5: error: too many template-parameter-lists
 1060 |     lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
      |     ^~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1085:87: error: 'bool std::ranges::lexicographical_compare(I1, S1, I2, S2, Comp, Proj1, Proj2)' should have been declared inside 'std::ranges'
 1085 |                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                                       ^
p1223.cpp:1086:10: error: 'input_range' has not been declared
 1086 | template<input_range R1, input_range R2, class Proj1 = identity,
      |          ^~~~~~~~~~~
p1223.cpp:1086:26: error: 'input_range' has not been declared
 1086 | template<input_range R1, input_range R2, class Proj1 = identity,
      |                          ^~~~~~~~~~~
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:1088:58: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                          ^~
      |                                                          y1
p1223.cpp:1088:60: error: wrong number of template arguments (1, should be 2)
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:1088:10: error: template argument 2 is invalid
 1088 |          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                               ^~~~~~~~~~
      |                                               std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:1089:58: error: 'R2' was not declared in this scope; did you mean 'R'?
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                          ^~
      |                                                          R
p1223.cpp:1089:60: error: wrong number of template arguments (1, should be 2)
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                            ^
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:757:12: note: provided for 'template<class _Iter, class _Proj>  requires (indirectly_readable<_Iter>) && (indirectly_regular_unary_invocable<_Proj, _Iter>) struct std::projected'
  757 |     struct projected
      |            ^~~~~~~~~
p1223.cpp:1089:68: error: expected '>' before '>>' token
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                    ^~
p1223.cpp:1089:71: error: 'Comp' does not name a type
 1089 |                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                       ^~~~
p1223.cpp:1091:69: error: expected unqualified-id before ',' token
 1091 |     ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
      |                                                                     ^
p1223.cpp:1092:43: error: expected constructor, destructor, or type conversion before 'proj1'
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                           ^~~~~
p1223.cpp:1092:53: error: expected unqualified-id before ',' token
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^
p1223.cpp:1092:61: error: expected constructor, destructor, or type conversion before 'proj2'
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                             ^~~~~
p1223.cpp:1092:71: error: expected unqualified-id before ')' token
 1092 |                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                       ^
p1223.cpp:1097:8: error: expected unqualified-id before 'for'
 1097 |        for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
      |        ^~~
p1223.cpp:1097:16: error: 'first1' does not name a type
 1097 |        for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
      |                ^~~~~~
p1223.cpp:1097:53: error: expected unqualified-id before '++' token
 1097 |        for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
      |                                                     ^~
p1223.cpp:1101:8: error: expected unqualified-id before 'return'
 1101 |        return first1 == last1 && first2 != last2;
      |        ^~~~~~
p1223.cpp:1119:1: error: expected unqualified-id before 'return'
 1119 | return lexicographical_compare_three_way(b1, e1, b2, e2, compare_three_way());
      | ^~~~~~
p1223.cpp:1130:21: error: 'next_permutation_result' in namespace 'std::ranges' does not name a template type
 1130 |   constexpr ranges::next_permutation_result<I>
      |                     ^~~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1131:61: error: expected unqualified-id before ',' token
 1131 |     ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1223.cpp:1131:68: error: expected constructor, destructor, or type conversion before 'proj'
 1131 |     ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1223.cpp:1131:77: error: expected unqualified-id before ')' token
 1131 |     ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1223.cpp:1132:10: error: 'bidirectional_range' has not been declared
 1132 | template<bidirectional_range R, class Comp = ranges::less,
      |          ^~~~~~~~~~~~~~~~~~~
p1223.cpp:1132:10: error: two or more data types in declaration of 'parameter'
p1223.cpp:1134:21: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1134 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                     ^~~~~~~~~~
      |                     std::ranges::iterator_t
/usr/local/include/c++/12.1.0/bits/ranges_base.h:595:11: note: 'std::ranges::iterator_t' declared here
  595 |     using iterator_t = std::__detail::__range_iter_t<_Tp>;
      |           ^~~~~~~~~~
p1223.cpp:1134:12: error: parse error in template argument list
 1134 |   requires sortable<iterator_t<R>, Comp, Proj>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1223.cpp:1134:12: error: template argument 1 is invalid
p1223.cpp:1134:34: error: expected unqualified-id before ',' token
 1134 |   requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1223.cpp:1136:51: error: expected unqualified-id before ',' token
 1136 |     ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1223.cpp:1136:58: error: expected constructor, destructor, or type conversion before 'proj'
 1136 |     ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^~~~
p1223.cpp:1136:67: error: expected unqualified-id before ')' token
 1136 |     ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                   ^
```

## 検討事項(agenda)
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。

<!-- リンクエラーの解説をする。clang++とg++の比較。意味のある出力。
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。-->

# 参考資料(reference)


関連する自己参照以外は、こちらの先頭に移転。

C言語（C++)に対する誤解、曲解、無理解、爽快。

https://qiita.com/kaizen_nagoya/items/3f3992c9722c1cee2e3a

#include "N4910.h"

https://qiita.com/kaizen_nagoya/items/163a47cef7d6bb1c33a8

C++N4910資料の改善点

https://qiita.com/kaizen_nagoya/items/fb4ceb5d117a54641af3

dockerにclang

https://qiita.com/kaizen_nagoya/items/8829ffeee397eda50e80

docker gnu(gcc/g++) and llvm(clang/clang++)

https://qiita.com/kaizen_nagoya/items/059874ea39c4de64c0f7

コンパイル用shell script C版(clangとgcc)とC++版(clang++とg++)

https://qiita.com/kaizen_nagoya/items/74220c0577a512c2d7da


C++N4910:2022 tag follower 300人超えました。ありがとうございます。

https://qiita.com/kaizen_nagoya/items/a63fb96d351ac5c16ff7

astyle 使ってみた

https://qiita.com/kaizen_nagoya/items/3c9a87a781d53a1a23f3

DoCAP（ドゥーキャップ）って何ですか？

https://qiita.com/kaizen_nagoya/items/47e0e6509ab792c43327

小川メソッド　覚え（書きかけ）

https://qiita.com/kaizen_nagoya/items/3593d72eca551742df68

 ＜この記事は個人の過去の経験に基づく個人の感想です。現在所属する組織、業務とは関係がありません。＞

# 文書履歴(document history)
ver. 0.01 初稿 　20220815